• Best use of MongoDB Atlas

• Working together from the beehive
• IF NO SPACE - work at the QF Office
• IF TOO LOUD OR NEED BREAK - go to the car
• Keep in mind alternated Military Nap (4hrs)
• Eric is driving

• Do we need caddy?
• Go over rules and see if there is anything we missed
• Create completion checklist (we will be tired a checklist could save us)
• Ask if they are going to kick us out at a specific time
• Ask if there is a place for us to work at location
• Ask what is the WiFi?
• Ask where the private Git repo will be and when we will have access?
• what events and talks are required?
• Where will the talks be?
• 03:30PM - 4:00PM - Keynote talk from NASA ASTRONAUT MIKE FOREMAN
• 10:30AM - 11:00AM - (OPTIONAL) ask where this is: MONGODB Workshop: Get more hands on experience with MongoDB which could give you an edge on their 2 challenges that include a total of $5000 cash!
• Bathrooms?

Build a MongoDB live query system that provides live queries to client apps from MongoDB

1. MUST: handle updating lists
   1. MUST: remove item from list (pop out)
   2. MUST: add item to list (pop in)
   3. MUST: update item in list (update)
2. MUST: handle updating single entities
3. SHOULD: handle full text search in MongoDB Atlas
4. SHOULD: handle aggregations
5. SHOULD: handle pagination
6. NICE TO HAVE: find one
7. NICE TO HAVE: Find
8. NICE TO HAVE: Aggregation (map/reduce) - lane map? Or lane report? Original City -> Destination City and cost?
9. NICE TO HAVE: Aggregation full text
10. NICE TO HAVE: location updates (tracking)

• The sort fields MUST be in the collection
• We could use $out and store the live queries
• Each live query could have it's own collection
• null for normal query matches both null and non-existence, on aggregation only matches null.

• API -> APP: insert - list id + id + payload + after or before (other) id

• API -> APP: remove - list id + id

• API -> APP: update - list id + payload

• API -> APP: move - list id + from id + after or before (other) id

• API -> APP: overwrite - list id + full list

• APP -> API: subscribe - list query

• APP -> API: unsubscribe - list id

• APP -> API: query - list query

• APP -> API: refresh - list id

• - at 11am

1. docker is setup
2. web socket is setup
3. vite default app is setup

• - at ???

(goal by 12:00pm)

• - at 12:30pm

(goal by 12:30pm)

• - at 1:30pm

(goal at 1:30pm)

• - at 2:32pm

(goal at 2:30pm)

• - at 4:00pm

(goal of 3:15pm)

• - 4:50pm

(goal of 4:45pm)

• - 7:17pm

(goal 7:00PM)

(goal 10:30PM)

Add pages with dummy data to client Connection find one query to react Connect subscription list to react Add filters of status, bol, city, state

• Build the client foundation (visuals and base connection)
• Build the bridge (socket.io connection)
• Connect the socket io to the client
• Setup socket io to connect to eric's functions
• bridge: subscribe, unsubscribe, refresh,
• create functions for Eric to hit to send down things back through the socket

• refreshLiveQuery
• createLiveQuery
• query
• setting up the live query system in MongoDB
• connecting back to sending down
• seed database with fake data
• setting up models
• set up environments
• setup Heroku

System that automatically updates data on a continual basis

We work with MongoDB in production environments on a daily basis. MongoDB is effective at handling our constantly changing data heavy workloads. One thing that we would love to have in MongoDB is the ability to have live queries. We haven't found a good solution yet so we decided to create one. Having the ability to fetch data from Mongo and automatically stay up to date would allow us to re-imagine how we integrate with MongoDB in our production apps.

With this in mind, this is what we built. We proudly present Mongo Live Query, a prototype that highlights the power of using live queries in MongoDB. This prototype is built on top of MongoDB Atlas and change streams.

Our aim was to prove out the idea of live queries in MongoDB with our scale and complexity in mind. It must handle complex aggregations including Atlas Text Search. In the same vein, we aligned our prototype towards the Best use of MongoDB Atlas challenge / prize.

To keep the scope focused on our goal of proving out the idea we made the choice to not focus on implementing any security measures for the prototype.

So let's jump into the app and take a quick peek. We are going to be running a worker on the server that is constantly changing and updating the data as we go. The list and individual views are all connected via live queries.

Consider walks / short breaks