@resolveio/server-lib 20.14.16 → 20.14.18

package/managers/subscription.manager.d.ts

@@ -93,6 +93,11 @@ export declare class SubscriptionManager {
     private queueFullResync;
     private fullResyncSubscriptions;
     private tailOpLog;
+    private packCachePayload;
+    private decodeCachePayload;
+    private getCacheBuffer;
+    private shouldCachePayload;
+    private buffersEqual;
     private processSubscription;
     private sendDataToOne;
     private sendDataToAll;

package/managers/subscription.manager.js

@@ -74,6 +74,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubscriptionManager = void 0;
 var NodeCache = require("node-cache");
+var msgpackr_1 = require("msgpackr");
 var flag_collection_1 = require("../collections/flag.collection");
 var logged_in_users_collection_1 = require("../collections/logged-in-users.collection");
 var app_status_1 = require("../publications/app-status");
@@ -1679,6 +1680,108 @@ var SubscriptionManager = /** @class */ (function () {
             });
         });
     };
+    SubscriptionManager.prototype.packCachePayload = function (data) {
+        if (data === undefined) {
+            return null;
+        }
+        try {
+            var packed = (0, msgpackr_1.pack)(data);
+            return Buffer.isBuffer(packed) ? packed : Buffer.from(packed);
+        }
+        catch (err) {
+            if (this._enableDebug) {
+                console.log(new Date(), 'Sub Cache', 'Pack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+            }
+            return null;
+        }
+    };
+    SubscriptionManager.prototype.decodeCachePayload = function (raw) {
+        if (!raw) {
+            return null;
+        }
+        if (Buffer.isBuffer(raw)) {
+            try {
+                return (0, msgpackr_1.unpack)(raw);
+            }
+            catch (err) {
+                if (this._enableDebug) {
+                    console.log(new Date(), 'Sub Cache', 'Unpack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+                }
+                return null;
+            }
+        }
+        if (raw instanceof Uint8Array) {
+            try {
+                return (0, msgpackr_1.unpack)(raw);
+            }
+            catch (err) {
+                if (this._enableDebug) {
+                    console.log(new Date(), 'Sub Cache', 'Unpack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+                }
+                return null;
+            }
+        }
+        if (raw instanceof ArrayBuffer) {
+            try {
+                return (0, msgpackr_1.unpack)(new Uint8Array(raw));
+            }
+            catch (err) {
+                if (this._enableDebug) {
+                    console.log(new Date(), 'Sub Cache', 'Unpack Failed', (err === null || err === void 0 ? void 0 : err.message) || err);
+                }
+                return null;
+            }
+        }
+        // Treat legacy string caches as invalid to avoid JSON parsing in the hot path.
+        if (typeof raw === 'string') {
+            return null;
+        }
+        return raw;
+    };
+    SubscriptionManager.prototype.getCacheBuffer = function (raw) {
+        if (!raw) {
+            return null;
+        }
+        if (Buffer.isBuffer(raw)) {
+            return raw;
+        }
+        if (raw instanceof Uint8Array) {
+            return Buffer.from(raw);
+        }
+        if (raw instanceof ArrayBuffer) {
+            return Buffer.from(new Uint8Array(raw));
+        }
+        return null;
+    };
+    SubscriptionManager.prototype.shouldCachePayload = function (sub, payload) {
+        if (!payload || payload.byteLength >= 1000000) {
+            return false;
+        }
+        if (sub.collections.includes('logs')) {
+            return false;
+        }
+        if (sub.collections.find(function (a) { return a.endsWith('.versions'); })) {
+            return false;
+        }
+        if (sub.collections.find(function (a) { return a.startsWith('monitor-'); })) {
+            return false;
+        }
+        return true;
+    };
+    SubscriptionManager.prototype.buffersEqual = function (a, b) {
+        if (!a || !b) {
+            return false;
+        }
+        if (a.byteLength !== b.byteLength) {
+            return false;
+        }
+        for (var index = 0; index < a.byteLength; index++) {
+            if (a[index] !== b[index]) {
+                return false;
+            }
+        }
+        return true;
+    };
     SubscriptionManager.prototype.processSubscription = function (sub, ws, messageId) {
         return __awaiter(this, void 0, void 0, function () {
             var cacheData, serverRes, _a;
@@ -1690,7 +1793,10 @@ var SubscriptionManager = /** @class */ (function () {
                         _b.label = 1;
                     case 1:
                         _b.trys.push([1, 2, , 4]);
-                        cacheData = JSON.parse(this._nodeCache.get(sub.cacheId), common_1.dateReviver);
+                        cacheData = this.decodeCachePayload(this._nodeCache.get(sub.cacheId));
+                        if (cacheData === null || cacheData === undefined) {
+                            throw new Error('cache-miss');
+                        }
                         serverRes = {
                             messageId: messageId,
                             hasError: false,
@@ -1840,7 +1946,7 @@ var SubscriptionManager = /** @class */ (function () {
     // Fetch pub once, send to all clients linked to this pub
     SubscriptionManager.prototype.sendDataToAll = function (sub, collection, type) {
         return __awaiter(this, void 0, void 0, function () {
-            var subIndex, startMs, monitor, res_1, dependencySnapshot, execution, cacheData, _a, _b, client, ws, serverRes, _c, _d, client, ws, serverRes, nodeCacheSize, deleteCount, subArr, zz, err_2, _e, normalizedError, correlationId, _f, _g, client, ws, serverRes, errorPayload, durationMs;
+            var subIndex, startMs, monitor, res, dependencySnapshot, execution, packedRes, shouldCache, cachedBuffer, isSame, _a, _b, client, ws, serverRes, _c, _d, client, ws, serverRes, nodeCacheSize, deleteCount, subArr, zz, err_2, _e, normalizedError, correlationId, _f, _g, client, ws, serverRes, errorPayload, durationMs;
             var e_6, _h, e_7, _j, e_8, _k;
             var _this = this;
             var _l;
@@ -1860,6 +1966,7 @@ var SubscriptionManager = /** @class */ (function () {
                     case 1:
                         startMs = Date.now();
                         monitor = this._monitorManagerFunction.startMonitorFunction('Publication', sub.publication, '', '', sub.subscriptionData);
+                        res = void 0;
                         dependencySnapshot = void 0;
                         _m.label = 2;
                     case 2:
@@ -1876,69 +1983,51 @@ var SubscriptionManager = /** @class */ (function () {
                             })];
                     case 3:
                         execution = _m.sent();
-                        res_1 = execution.result;
+                        res = execution.result;
                         dependencySnapshot = execution.snapshot;
                         this.updateSubscriptionDependencies(sub, dependencySnapshot);
+                        packedRes = this.packCachePayload(res);
+                        shouldCache = this.shouldCachePayload(sub, packedRes);
                         if (sub.cacheId) {
-                            try {
-                                cacheData = JSON.parse(this._nodeCache.get(sub.cacheId), common_1.dateReviver);
-                                if (JSON.stringify(cacheData) !== JSON.stringify(res_1)) {
-                                    try {
-                                        for (_a = __values(sub.clients), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                            client = _b.value;
-                                            ws = this._websocketManager.getWebSocket(client.id_socket);
-                                            if (ws && ws.readyState === ws.OPEN) {
-                                                serverRes = {
-                                                    messageId: client.messageId,
-                                                    hasError: false,
-                                                    data: res_1
-                                                };
-                                                this.sendWS(ws, serverRes);
-                                            }
-                                        }
-                                    }
-                                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                                    finally {
-                                        try {
-                                            if (_b && !_b.done && (_h = _a.return)) _h.call(_a);
+                            cachedBuffer = this.getCacheBuffer(this._nodeCache.get(sub.cacheId));
+                            isSame = this.buffersEqual(cachedBuffer, packedRes);
+                            if (!isSame) {
+                                try {
+                                    for (_a = __values(sub.clients), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                        client = _b.value;
+                                        ws = this._websocketManager.getWebSocket(client.id_socket);
+                                        if (ws && ws.readyState === ws.OPEN) {
+                                            serverRes = {
+                                                messageId: client.messageId,
+                                                hasError: false,
+                                                data: res
+                                            };
+                                            this.sendWS(ws, serverRes);
                                         }
-                                        finally { if (e_6) throw e_6.error; }
-                                    }
-                                    this._nodeCache.del(sub.cacheId);
-                                    if ((0, common_1.getBinarySize)(JSON.stringify(res_1)) < 1000000 &&
-                                        !sub.collections.includes('logs') &&
-                                        !sub.collections.find(function (a) { return a.endsWith('.versions'); }) &&
-                                        !sub.collections.find(function (a) { return a.startsWith('monitor-'); })) {
-                                        this._nodeCache.set(sub.cacheId, JSON.stringify(res_1));
-                                    }
-                                    else {
-                                        sub.cacheId = 0;
                                     }
                                 }
-                            }
-                            catch (_o) {
-                                sub.clients.map(function (client) {
-                                    var ws = _this._websocketManager.getWebSocket(client.id_socket);
-                                    if (ws && ws.readyState === ws.OPEN) {
-                                        var serverRes = {
-                                            messageId: client.messageId,
-                                            hasError: false,
-                                            data: res_1
-                                        };
-                                        _this.sendWS(ws, serverRes);
+                                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                                finally {
+                                    try {
+                                        if (_b && !_b.done && (_h = _a.return)) _h.call(_a);
                                     }
-                                });
+                                    finally { if (e_6) throw e_6.error; }
+                                }
                                 this._nodeCache.del(sub.cacheId);
-                                if ((0, common_1.getBinarySize)(JSON.stringify(res_1)) < 1000000 &&
-                                    !sub.collections.includes('logs') &&
-                                    !sub.collections.find(function (a) { return a.endsWith('.versions'); }) &&
-                                    !sub.collections.find(function (a) { return a.startsWith('monitor-'); })) {
-                                    this._nodeCache.set(sub.cacheId, JSON.stringify(res_1));
+                                if (shouldCache) {
+                                    this._nodeCache.set(sub.cacheId, packedRes);
                                 }
                                 else {
                                     sub.cacheId = 0;
                                 }
                             }
+                            else if (!cachedBuffer && shouldCache) {
+                                this._nodeCache.set(sub.cacheId, packedRes);
+                            }
+                            else if (!shouldCache) {
+                                this._nodeCache.del(sub.cacheId);
+                                sub.cacheId = 0;
+                            }
                         }
                         else {
                             try {
@@ -1949,7 +2038,7 @@ var SubscriptionManager = /** @class */ (function () {
                                         serverRes = {
                                             messageId: client.messageId,
                                             hasError: false,
-                                            data: res_1
+                                            data: res
                                         };
                                         this.sendWS(ws, serverRes);
                                     }
@@ -1962,12 +2051,9 @@ var SubscriptionManager = /** @class */ (function () {
                                 }
                                 finally { if (e_7) throw e_7.error; }
                             }
-                            if ((0, common_1.getBinarySize)(JSON.stringify(res_1)) < 1000000 &&
-                                !sub.collections.includes('logs') &&
-                                !sub.collections.find(function (a) { return a.endsWith('.versions'); }) &&
-                                !sub.collections.find(function (a) { return a.startsWith('monitor-'); })) {
+                            if (shouldCache) {
                                 sub.cacheId = this._cacheId++;
-                                this._nodeCache.set(sub.cacheId, JSON.stringify(res_1));
+                                this._nodeCache.set(sub.cacheId, packedRes);
                                 nodeCacheSize = this._nodeCache.getStats().vsize;
                                 if (nodeCacheSize > this._heapLimit) {
                                     deleteCount = 0;