mongo-realtime 2.0.0 → 2.0.2

package/index.js

@@ -35,7 +35,7 @@ class MongoRealtime {
     mongoose.connection;
   /** @type {Record<String, [(change:ChangeStreamDocument)=>void]>} */ static #listeners =
     {};
-  
+
   static sockets = () => [...this.io.sockets.sockets.values()];
 
   /**@type {Record<String, {collection:String,filter: (doc:Object)=>Promise<boolean>}>} */
@@ -114,6 +114,8 @@ class MongoRealtime {
    * @param {[String]} options.watch - Collections to watch. If empty, will watch all collections
    * @param {[String]} options.ignore - Collections to ignore. Can override `watch`
    * @param {bool} options.debug -  Enable debug mode
+   * @param {number} options.cacheDelay - Cache delay in minutes. Put 0 if no cache
+   * @param {number} options.allowDbOperations - If true, you can use find and update operations.
    *
    */
   static async init({
@@ -130,6 +132,8 @@ class MongoRealtime {
     middlewares = [],
     watch = [],
     ignore = [],
+    cacheDelay = 5,
+    allowDbOperations = true,
   }) {
     this.#log(`MongoRealtime version (${this.version})`, 2);
 
@@ -188,14 +192,15 @@ class MongoRealtime {
       changeStream.on("change", async (change) => {
         const coll = change.ns.coll;
         const colName = coll.toLowerCase();
-        const doc = change.fullDocument;
+        const id = change.documentKey?._id.toString();
+        const doc = change.fullDocument??{_id:id};
+        
 
         this.#debugLog(`Collection '${colName}' changed`);
 
         change.col = colName;
 
         const type = change.operationType;
-        const id = change.documentKey?._id.toString();
 
         for (const k in this.#streams) {
           const stream = this.#streams[k];
@@ -203,24 +208,23 @@ class MongoRealtime {
 
           Promise.resolve(stream.filter(doc)).then((ok) => {
             if (ok) {
-              this.io.emit(`realtime:${k}`, {
-                results: [doc],
-                coll: coll,
-                count: 1,
-                total: 1,
-                remaining: 0,
-              });
+              const data = { added: [], removed: [] };
+              if (change.operationType == "delete") data.removed.push(doc);
+              else data.added.push(doc);
+
+
+              this.io.emit(`realtime:${k}`, data);
             }
           });
         }
         for (let k in this.#data) {
           if (!k.startsWith(`${coll}-`) || !this.#data[k].result[id]) continue;
-          doc._id = doc._id.toString();
           switch (change.operationType) {
             case "delete":
               delete this.#data[k].result[id];
               break;
-            default:
+              default:
+              doc._id = id;
               this.#data[k].result[id] = doc;
           }
         }
@@ -322,6 +326,7 @@ class MongoRealtime {
               .collection(coll)
               .estimatedDocumentCount();
 
+
             const length = ids.length;
             const range = [length, Math.min(total, length + limit)];
             const now = new Date();
@@ -350,7 +355,7 @@ class MongoRealtime {
 
             ids.push(...result.map((d) => d._id));
 
-            const delayInMin = 1;
+            const delayInMin = cacheDelay;
             const expiration = new Date(now.getTime() + delayInMin * 60 * 1000);
             const resultMap = result.reduce((acc, item) => {
               item._id = item._id.toString();
@@ -386,17 +391,105 @@ class MongoRealtime {
               .map((item) => item.doc);
 
             const data = {
-              results: filtered,
-              coll,
-              count: filtered.length,
-              total,
-              remaining: total - ids.length,
+              added: filtered,
+              removed: [],
             };
 
             socket.emit(`realtime:${streamId}:${registerId}`, data);
           } while (ids.length < total);
         }
       );
+      if (allowDbOperations) {
+        socket.on("realtime:count", async ({ coll, query }, ack) => {
+          if (!coll) return ack(0);
+          query ??= {};
+          const c = this.connection.db.collection(coll);
+          const hasQuery = notEmpty(query);
+          const count = hasQuery
+            ? await c.countDocuments(query)
+            : await c.estimatedDocumentCount();
+          ack(count);
+        });
+
+        socket.on(
+          "realtime:find",
+          async (
+            { coll, query, limit, sortBy, project, one, skip, id },
+            ack
+          ) => {
+            if (!coll) return ack(null);
+            const c = this.connection.db.collection(coll);
+
+            if (id) {
+              ack(await c.findOne({ _id: toObjectId(id) }));
+              return;
+            }
+
+            query ??= {};
+            one = one == true;
+
+            if (query["_id"]) {
+              query["_id"] = toObjectId(query["_id"]);
+            }
+
+            const options = {
+              sort: sortBy,
+              projection: project,
+              skip: skip,
+              limit: limit,
+            };
+
+            if (one) {
+              ack(await c.findOne(query, options));
+              return;
+            }
+
+            let cursor = c.find(query, options);
+            ack(await cursor.toArray());
+          }
+        );
+
+        socket.on(
+          "realtime:update",
+          async (
+            { coll, query, limit, sortBy, project, one, skip, id, update },
+            ack
+          ) => {
+            if (!coll || !notEmpty(update)) return ack(0);
+            const c = this.connection.db.collection(coll);
+
+            if (id) {
+              ack(
+                (await c.updateOne({ _id: toObjectId(id) }, update))
+                  .modifiedCount
+              );
+              return;
+            }
+
+            query ??= {};
+            one = one == true;
+
+            if (query["_id"]) {
+              query["_id"] = toObjectId(query["_id"]);
+            }
+
+            const options = {
+              sort: sortBy,
+              projection: project,
+              skip: skip,
+              limit: limit,
+            };
+
+            if (one) {
+              ack((await c.updateOne(query, update, options)).modifiedCount);
+              return;
+            }
+
+            let cursor = await c.updateMany(query, update, options);
+            ack(cursor.modifiedCount);
+          }
+        );
+      }
 
       socket.on("disconnect", (r) => {
         if (offSocket) offSocket(socket, r);
@@ -483,4 +576,19 @@ class MongoRealtime {
   }
 }
 
+// utils
+function notEmpty(obj) {
+  obj ??= {};
+  return Object.keys(obj).length > 0;
+}
+/** @param {String} id  */
+function toObjectId(id) {
+  if (typeof id != "string") return id;
+  try {
+    return mongoose.Types.ObjectId.createFromHexString(id);
+  } catch (_) {
+    return new mongoose.Types.ObjectId(id); //use deprecated if fail
+  }
+}
+
 module.exports = MongoRealtime;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongo-realtime",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "main": "index.js",
   "scripts": {},
   "keywords": [