Skip to main content
100%

Notify socket.io users when MongoDB data collection changes

✓ Published0🌍 Public
Aackuser
Last edited Feb 7, 2018
Created on Nov 11, 2019

This example shows a real-time notification system that pushes MongoDB collection changes to connected socket.io clients. The code sets a watch on the User collection using MongoDB’s changeStream API, then listens for socket connections. Upon any change event, it queries the full User collection with `User.find({})` and emits the updated data to the client via `socket.emit('users', data)`. It demonstrates live data synchronization between a MongoDB backend and browser clients through socket.io’s event-driven communication.

AI-generated description

Similar vizzes

Loading thumbnail…

Notify socket.io users when MongoDB data collection changes

This example shows how MongoDB data changes are streamed to connected Socket.io users in real time. It uses the MongoDB `User.watch()` change stream to monitor collection modifications, and on each change, queries all users via `User.find({})` before emitting the updated dataset through `socket.emit('users', data)`. The code integrates with an Express app and a Socket.io server, logging connection events and collection changes to the console. No visualization library is involved; the focus is on the backend data pipeline that pushes fresh data to clients.

Aackuser
96% match
Loading thumbnail…

Gist 444255

This example demonstrates a Node.js server that queries MongoDB collections and logs their contents to the console, primarily as a backend testing or debugging tool. The code uses the `mongo.Db` and `mongo.Server` APIs to connect to a local MongoDB instance on port 27017, then defines HTTP routes via a `get()` handler. For each route, it retrieves documents from specific collections—`some-collection` and `another-collection` (the latter with a limit of 10)—and prints each item using `sys.puts` and `sys.inspect`. The visualization aspect is absent; the example focuses on database interaction and response handling.

CCaged
57% match
Loading thumbnail…

Gist 660bf021ec250dfb10016d384d524bd7

This example shows a real-time chat application where users exchange messages through a Node.js server. The visualization tracks message flow and user activity using a force-directed graph rendered with D3.js’s `d3.forceSimulation` for node positioning and link physics. Each user appears as a node, with edges connecting them to messages they send, while color and size encode online status and message frequency. The code uses Socket.IO for live data updates and D3’s `transition.attrTween` to animate new nodes and links smoothly as events arrive, making the conversation pattern immediately visible.

FFrankieFabuloso
55% match
Loading thumbnail…

Emit event with Mongoose

The example shows how to emit a custom event after a Mongoose document is saved, using a post-save hook. The code defines `UserSchema.post('save', function() {...})`, which triggers a `'changed'` event on the document instance, passing the document and its `altered` field as arguments. After emitting, the hook deletes `this.altered` to clean up. This demonstrates Mongoose's middleware system and Node.js's `EventEmitter` pattern for observing model changes, without any visualization library or rendering data involved.

Aalessioalex
54% match
Loading thumbnail…

MapReduce with MongoDB in NodeJS

This example demonstrates a MapReduce operation in MongoDB, executed from a Node.js application, that aggregates sensor measurements into hourly averages per user and device. The code defines custom `map`, `reduce`, and `finalize` functions to group raw data points by a composite key of user email, device UID, and the hour timestamp, then computes a weighted average value and total weight. The operation queries MongoDB’s `Measure` collection, merges results into an output collection named `measure1hs`, and reports execution statistics via a callback. The implementation uses MongoDB’s native `db.Measure.collection.mapReduce` API directly, bypassing Mongoose, and handles asynchronous completion through a callback function.

Aackuser
54% match
Loading thumbnail…

Node.js + Socket.io + Bash. A collaborative terminal for your browser.

This example demonstrates a collaborative terminal in the browser, where multiple users share a live bash session and see each other’s commands and output in real time. It shows a simple web page that displays the shell’s stdout and stderr as a scrolling log, while a text input lets any connected client send commands to the server. The server uses Node.js’s `child_process.spawn` to launch bash, and Socket.io’s `listen` and `broadcast` methods to relay data between the shell and all clients. The client-side `term.html` uses jQuery for DOM updates and Socket.io’s `io.Socket` for message handling, rendering each line as a `<p>` element.

Aackuser
53% match
Loading thumbnail…

Aggregate data from MongoDB with Node.js and mongoose

This example demonstrates how to calculate an account balance by aggregating embedded financial records in MongoDB using Node.js and Mongoose. It defines Account and Record schemas, inserts sample data, and runs an aggregation pipeline with `$match`, `$unwind`, and `$group` to sum record amounts via `AccountModel.aggregate()`. The code also shows CRUD operations for accounts and records, with results logged to the console.

Aackuser
52% match
Loading thumbnail…

Gist 370577

This example demonstrates a Scala program that interacts with MongoDB through the Casbah MongoDB Scala driver, showing how to define a case class `User` with fields like `id`, `name`, and optional `age`, then insert 50 randomly generated users into a collection. It queries users using the `User` shape's `where` clauses (e.g., `User.age is_> 50`), sorts them by age, and deletes users outside a specified age range. The code also shows inserting a raw `Map` directly into a collection and uses for-comprehensions to iterate over query results, highlighting the driver’s Scala-specific query and collection APIs.

Aakollegger
51% match