mongo-realtime 1.1.3 → 1.2.0

package/README.md

@@ -29,18 +29,19 @@ npm install mongo-realtime
 ```javascript
 const express = require("express");
 const http = require("http");
-const mongoose = require("mongoose");
 const MongoRealtime = require("mongo-realtime");
 
 const app = express();
 const server = http.createServer(app);
 
-mongoose.connect("mongodb://localhost:27017/mydb").then((c) => {
-  console.log("Connected to db", c.connection.name);
-});
-
 MongoRealtime.init({
-  connection: mongoose.connection,
+  dbUri: "mongodb://localhost:27017/mydb",
+  onDbConnect: (conn) => {
+    console.log("Connected to db", conn.name);
+  },
+  onDbError: (err) => {
+    console.log(err.message);
+  },
   server: server,
   ignore: ["posts"], // ignore 'posts' collection
   onSocket: (socket) => {
@@ -67,17 +68,20 @@ Initializes the socket system and MongoDB Change Streams.
 
 \* means required
 
-| Parameter                | Type                    | Description                                                                      |
-| ------------------------ | ----------------------- | -------------------------------------------------------------------------------- |
-| `options.connection`     | `mongoose.Connection`\* | Active Mongoose connection                                                       |
-| `options.server`         | `http.Server`\*         | HTTP server to attach Socket.IO                                                  |
-| `options.authentify`     | `Function`              | Function to authenticate socket connections. Should return true if authenticated |
-| `options.middlewares`    | `Array[Function]`       | Array of Socket.IO middlewares                                                   |
-| `options.onSocket`       | `Function`              | Callback on socket connection                                                    |
-| `options.offSocket`      | `Function`              | Callback on socket disconnection                                                 |
-| `options.watch`          | `Array[String]`         | Collections to only watch. Listen to all when is empty                           |
-| `options.ignore`         | `Array[String]`         | Collections to only ignore. Overrides watch array                                |
-| `options.autoListStream` | `Array[String]`         | Collections to automatically stream to clients. Default is all                   |
+| Parameter                | Type              | Description                                                                      |
+| ------------------------ | ----------------- | -------------------------------------------------------------------------------- |
+| `options.dbUri`          | `String`\*        | Database URI                                                                     |
+| `options.dbOptions`      | `Object`          | Mongoose connection options                                                      |
+| `options.onDbConnect`    | `Function`        | Callback on successful database connection                                       |
+| `options.onDbError`      | `Function`        | Callback on database connection error                                            |
+| `options.server`         | `http.Server`\*   | HTTP server to attach Socket.IO                                                  |
+| `options.authentify`     | `Function`        | Function to authenticate socket connections. Should return true if authenticated |
+| `options.middlewares`    | `Array[Function]` | Array of Socket.IO middlewares                                                   |
+| `options.onSocket`       | `Function`        | Callback on socket connection                                                    |
+| `options.offSocket`      | `Function`        | Callback on socket disconnection                                                 |
+| `options.watch`          | `Array[String]`   | Collections to only watch. Listen to all when is empty                           |
+| `options.ignore`         | `Array[String]`   | Collections to only ignore. Overrides watch array                                |
+| `options.autoListStream` | `Array[String]`   | Collections to automatically stream to clients. Default is all                   |
 
 #### Static Properties and Methods
 
@@ -160,7 +164,7 @@ Each event contains the full MongoDB change object:
 
 ```javascript
 MongoRealtime.init({
-  connection: connection,
+  dbUri: "mongodb://localhost:27017/mydb",
   server: server,
   onSocket: (socket) => {
     socket.on("subscribe:users", () => {
@@ -209,7 +213,7 @@ MongoRealtime.io.to("users-room").emit("custom-event", data);
 
 ```javascript
 MongoRealtime.init({
-  connection: mongoose.connection,
+  dbUri: "mongodb://localhost:27017/mydb",
   server: server,
   onSocket: (socket) => {
     socket.on("error", (error) => {
@@ -228,6 +232,15 @@ MongoRealtime.init({
 
 ### Socket Authentication
 
+You can provide an `authentify` function in the init options to authenticate socket connections.\
+The function receives the token (from `socket.handshake.auth.token` or `socket.handshake.headers.authorization`) and the socket object.\
+When setted, it rejects connections based on this logic:
+
+- Token not provided -> error `NO_TOKEN_PROVIDED`
+- Token invalid or returns `false` -> error `UNAUTHORIZED`
+- Any other error -> error `AUTH_ERROR`
+- Return `true` to accept the connection
+
 ```javascript
 function authenticateSocket(token, socket) {
   const verify = AuthService.verifyToken(token);
@@ -239,7 +252,7 @@ function authenticateSocket(token, socket) {
 }
 
 MongoRealtime.init({
-  connection: mongoose.connection,
+  dbUri: "mongodb://localhost:27017/mydb",
   server: server,
   authentify: authenticateSocket,
   middlewares: [
@@ -264,7 +277,7 @@ On init, when `safeListStream` is `true`(default), two list streams can't have t
 
 ```javascript
 MongoRealtime.init({
-  connection: mongoose.connection,
+  dbUri: "mongodb://localhost:27017/mydb",
   server: server,
   autoListStream: ["users"], // automatically stream users collection only
 });
@@ -291,16 +304,16 @@ To avoid all these issues, you can set `safeListStream` to `false` in the init o
 
 ```javascript
 MongoRealtime.init({
-  connection: mongoose.connection,
+  dbUri: "mongodb://localhost:27017/mydb",
   server: server,
   autoListStream: [], // stream no collection automatically (you can add your own filtered streams later)
 });
 // or
 MongoRealtime.init({
-  connection: mongoose.connection,
+  dbUri: "mongodb://localhost:27017/mydb",
   server: server,
   safeListStream: false, // disable safe mode (you can override existing streams)
-  // Still stream all collections automatically but you can override them 
+  // Still stream all collections automatically but you can override them
 }):
 
 MongoRealtime.addListStream("posts", "posts", (doc) => !!doc.title); // client can listen to db:stream:posts
@@ -311,7 +324,7 @@ MongoRealtime.addListStream("users", "users", (doc) => !!doc.email); // will not
 
 ```javascript
 MongoRealtime.init({
-  connection: mongoose.connection,
+  dbUri: "mongodb://localhost:27017/mydb",
   server: server,
   authentify: (token, socket) => {
     try {
@@ -379,6 +392,8 @@ MongoRealtime.addListStream(
 
 ### MongoDB must be in Replica Set mode
 
+To use Change Streams, MongoDB must be running as a replica set. For local development, you can initiate a single-node replica set:
+
 ```bash
 mongod --replSet rs0
 

package/index.js

@@ -1,14 +1,7 @@
+const mongoose = require("mongoose");
 const { Server } = require("socket.io");
-
-function sortObj(obj = {}) {
-  const out = {};
-  for (let k of Object.keys(obj).sort()) {
-    const v = obj[k];
-    out[k] = typeof v == "object" && !Array.isArray(v) ? sortObj(v) : v;
-  }
-
-  return out;
-}
+const { version } = require("./package.json");
+const chalk = require("chalk");
 
 /**
  * @typedef {Object} ChangeStreamDocument
@@ -38,7 +31,8 @@ function sortObj(obj = {}) {
 
 class MongoRealtime {
   /** @type {import("socket.io").Server} */ static io;
-  /** @type {import("mongoose").Connection} */ static connection;
+  /** @type {import("mongoose").Connection} */ static connection =
+    mongoose.connection;
   /** @type {Record<String, [(change:ChangeStreamDocument)=>void]>} */ static #listeners =
     {};
   /** @type {Record<String, [Object]>} */
@@ -53,13 +47,56 @@ class MongoRealtime {
 
   static #safeListStream = true;
 
+  static version = version;
+
+  static #check(fn, err) {
+    const result = fn();
+    if (!result) {
+      let src = fn.toString().trim();
+
+      let match =
+        src.match(/=>\s*([^{};]+)$/) ||
+        src.match(/return\s+([^;}]*)/) ||
+        src.match(/{([^}]*)}/);
+
+      const expr = err ?? (match ? match[1].trim() : src);
+
+      throw new Error(`MongoRealtime failed to check "${expr}"`);
+    }
+  }
+
+  static #log(message, type = 0) {
+    const text = `[REALTIME] ${message}`;
+    switch (type) {
+      case 1:
+        console.log(chalk.bold.hex('#11AA60FF')(text));
+        break;
+      case 2:
+        console.log(chalk.bold.bgHex("#257993")(text));
+        break;
+      case 3:
+        console.log(chalk.bold.yellow(text));
+        break;
+      case 4:
+        console.log(chalk.bold.red(text));
+        break;
+
+      default:
+        console.log(text);
+        break;
+    }
+  }
+
   /**
    * Initializes the socket system.
    *
    * @param {Object} options
-   * @param {import("mongoose").Connection} options.connection - Active Mongoose connection
+   * @param {String} options.dbUri - Database URI
+   * @param {mongoose.ConnectOptions | undefined} options.dbOptions - Database connect options
    * @param {(token:String, socket: import("socket.io").Socket) => boolean | Promise<boolean>} options.authentify - Auth function that should return true if `token` is valid
    * @param {[( socket: import("socket.io").Socket, next: (err?: ExtendedError) => void) => void]} options.middlewares - Register mmiddlewares on incoming socket
+   * @param {(conn:mongoose.Connection) => void} options.onDbConnect - Callback triggered when a socket connects
+   * @param {(err:Error) => void} options.onDbError - Callback triggered when a socket connects
    * @param {(socket: import("socket.io").Socket) => void} options.onSocket - Callback triggered when a socket connects
    * @param {(socket: import("socket.io").Socket, reason: import("socket.io").DisconnectReason) => void} options.offSocket - Callback triggered when a socket disconnects
    * @param {import("http").Server} options.server - HTTP server to attach Socket.IO to
@@ -69,81 +106,30 @@ class MongoRealtime {
    * @param {bool} options.safeListStream -  If true(default), declaring an existing streamId will throw an error
    *
    */
-  static init({
-    connection,
+  static async init({
+    dbUri,
+    dbOptions,
     server,
+    onDbConnect,
+    onDbError,
     authentify,
-    middlewares = [],
-    autoListStream,
     onSocket,
     offSocket,
     safeListStream = true,
+    autoListStream,
+    middlewares = [],
     watch = [],
     ignore = [],
   }) {
+    console.clear();
+    this.#log(`MongoRealtime version (${this.version})`, 2);
     if (this.io) this.io.close();
-    this.io = new Server(server);
-    this.connection = connection;
-    this.#safeListStream = !!safeListStream;
-
-    watch = watch.map((s) => s.toLowerCase());
-    ignore = ignore.map((s) => s.toLowerCase());
+    this.#check(() => dbUri);
+    this.#check(() => server);
 
-    this.io.use(async (socket, next) => {
-      if (!!authentify) {
-        try {
-          const token =
-            socket.handshake.auth.token ||
-            socket.handshake.headers.authorization;
-          if (!token) return next(new Error("NO_TOKEN_PROVIDED"));
-
-          const authorized = await authentify(token, socket);
-          if (authorized === true) return next(); // exactly returns true
-
-          return next(new Error("UNAUTHORIZED"));
-        } catch (error) {
-          return next(new Error("AUTH_ERROR"));
-        }
-      } else {
-        return next();
-      }
-    });
-
-    for (let middleware of middlewares) {
-      this.io.use(middleware);
-    }
-
-    this.io.on("connection", (socket) => {
-      if (onSocket) onSocket(socket);
-
-      socket.on("db:stream[register]", async (streamId, registerId) => {
-        const stream = this.#streams[streamId];
-        if (!stream) return;
-        const coll = stream.collection;
-
-        if (!this.#cache[coll]) {
-          this.#cache[coll] = await connection.db
-            .collection(coll)
-            .find({})
-            .toArray();
-        }
-        const filterResults = await Promise.allSettled(
-          this.#cache[coll].map((doc) => stream.filter(doc))
-        );
-
-        const filtered = this.#cache[coll].filter(
-          (_, i) => filterResults[i] && filterResults[i].value
-        );
-        this.io.emit(`db:stream[register][${registerId}]`, filtered);
-      });
-
-      socket.on("disconnect", (r) => {
-        if (offSocket) offSocket(socket, r);
-      });
-    });
-
-    connection.once("open", async () => {
-      this.collections = (await connection.listCollections()).map(
+    this.io = new Server(server);
+    this.connection.once("open", async () => {
+      this.collections = (await this.connection.listCollections()).map(
         (c) => c.name
       );
 
@@ -165,7 +151,7 @@ class MongoRealtime {
         ];
       }
 
-      const changeStream = connection.watch(pipeline, {
+      const changeStream = this.connection.watch(pipeline, {
         fullDocument: "updateLookup",
         fullDocumentBeforeChange: "whenAvailable",
       });
@@ -184,14 +170,15 @@ class MongoRealtime {
         const coll = change.ns.coll;
 
         if (!this.#cache[coll]) {
-          this.#cache[coll] = await connection.db
+          this.#cache[coll] = await this.connection.db
             .collection(coll)
             .find({})
+            .sort({ _id: -1 })
             .toArray();
         } else
           switch (change.operationType) {
             case "insert":
-              this.#cache[coll].push(change.fullDocument);
+              this.#cache[coll].unshift(change.fullDocument); // add to top;
               break;
 
             case "update":
@@ -260,6 +247,81 @@ class MongoRealtime {
         }
       });
     });
+
+    try {
+      await mongoose.connect(dbUri, dbOptions);
+      this.#log(`Connected to db '${mongoose.connection.name}'`, 1);
+      onDbConnect?.call(this, mongoose.connection);
+    } catch (error) {
+      onDbError?.call(this, error);
+      this.#log("Failed to init",4);
+      return;
+    }
+
+    this.#check(() => mongoose.connection.db, "No database found");
+
+    this.#safeListStream = !!safeListStream;
+
+    watch = watch.map((s) => s.toLowerCase());
+    ignore = ignore.map((s) => s.toLowerCase());
+
+    this.io.use(async (socket, next) => {
+      if (!!authentify) {
+        try {
+          const token =
+            socket.handshake.auth.token ||
+            socket.handshake.headers.authorization;
+          if (!token) return next(new Error("NO_TOKEN_PROVIDED"));
+
+          const authorized = await authentify(token, socket);
+          if (authorized === true) return next(); // exactly returns true
+
+          return next(new Error("UNAUTHORIZED"));
+        } catch (error) {
+          return next(new Error("AUTH_ERROR"));
+        }
+      } else {
+        return next();
+      }
+    });
+
+    for (let middleware of middlewares) {
+      this.io.use(middleware);
+    }
+
+    this.io.on("connection", (socket) => {
+      socket.emit("version", version);
+      socket.on("db:stream[register]", async (streamId, registerId) => {
+        const stream = this.#streams[streamId];
+        if (!stream) return;
+        const coll = stream.collection;
+        if (!this.#cache[coll]) {
+          this.#cache[coll] = await this.connection.db
+            .collection(coll)
+            .find({})
+            .sort({ _id: -1 })
+            .toArray();
+        }
+        const filterResults = await Promise.allSettled(
+          this.#cache[coll].map((doc) => stream.filter(doc))
+        );
+
+        const filtered = this.#cache[coll].filter(
+          (_, i) => filterResults[i] && filterResults[i].value
+        );
+        this.io.emit(`db:stream[register][${registerId}]`, filtered);
+      });
+
+      socket.on("disconnect", (r) => {
+        if (offSocket) offSocket(socket, r);
+      });
+
+      if (onSocket) onSocket(socket);
+
+    });
+    
+
+    this.#log(`Initialized`,1);
   }
 
   /**

package/package.json

@@ -1,26 +1,27 @@
-{
-  "name": "mongo-realtime",
-  "version": "1.1.3",
-  "main": "index.js",
-  "scripts": {},
-  "keywords": [
-    "mongo",
-    "mongoose",
-    "replica",
-    "stream",
-    "realtime",
-    "mongodb",
-    "socket",
-    "db"
-  ],
-  "author": "D3R50N",
-  "license": "MIT",
-  "repository": {
-    "url": "git+https://github.com/D3R50N/mongo-realtime.git"
-  },
-  "description": "A Node.js package that combines Socket.IO and MongoDB Change Streams to deliver real-time database updates to your WebSocket clients.",
-  "dependencies": {
-    "mongoose": "^8.17.0",
-    "socket.io": "^4.8.1"
-  }
-}
+{
+  "name": "mongo-realtime",
+  "version": "1.2.0",
+  "main": "index.js",
+  "scripts": {},
+  "keywords": [
+    "mongo",
+    "mongoose",
+    "replica",
+    "stream",
+    "realtime",
+    "mongodb",
+    "socket",
+    "db"
+  ],
+  "author": "D3R50N",
+  "license": "MIT",
+  "repository": {
+    "url": "git+https://github.com/D3R50N/mongo-realtime.git"
+  },
+  "description": "A Node.js package that combines Socket.IO and MongoDB Change Streams to deliver real-time database updates to your WebSocket clients.",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "mongoose": "^8.17.0",
+    "socket.io": "^4.8.1"
+  }
+}