@resolveio/server-lib 20.9.6 → 20.9.8

package/managers/subscription.manager.d.ts

@@ -35,6 +35,7 @@ export declare class SubscriptionManager {
     private readonly LATENCY_UPDATE_THRESHOLD_MS;
     private _invalidationDebounceTimers;
     private _invalidationPendingTimestamps;
+    private _pendingInvalidations;
     private readonly DEBOUNCE_DELAY;
     private readonly MAX_WAIT_TIME;
     constructor();
@@ -66,8 +67,11 @@ export declare class SubscriptionManager {
     private convertDocumentIdForQuery;
     private documentMatchesFilter;
     private shouldInvalidateSubscription;
+    private shouldInvalidateSubscriptionForEvents;
+    private shouldForceRequeryOnInsert;
     private sendWS;
     getEnableDebug(): boolean;
     private dependencyDebug;
+    private summarizeEvents;
     private logDependencySnapshot;
 }

package/managers/subscription.manager.js

@@ -139,6 +139,7 @@ var SubscriptionManager = /** @class */ (function () {
         // private performanceThread;
         this._invalidationDebounceTimers = new Map();
         this._invalidationPendingTimestamps = new Map();
+        this._pendingInvalidations = new Map();
         this.DEBOUNCE_DELAY = 100; // 100ms debounce window
         this.MAX_WAIT_TIME = 500; // 500ms maximum delay
     }
@@ -341,11 +342,17 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.invalidatePubsCache = function (collection, type, documentId) {
         return __awaiter(this, void 0, void 0, function () {
-            var debounceKey, now, firstInvalidationTime, waitedTooLong;
+            var queue, debounceKey, now, firstInvalidationTime, waitedTooLong;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        queue = this._pendingInvalidations.get(collection);
+                        if (!queue) {
+                            queue = { events: [] };
+                            this._pendingInvalidations.set(collection, queue);
+                        }
+                        queue.events.push({ type: type, documentId: documentId });
                         debounceKey = collection;
                         now = Date.now();
                         firstInvalidationTime = this._invalidationPendingTimestamps.get(debounceKey) || now;
@@ -358,7 +365,7 @@ var SubscriptionManager = /** @class */ (function () {
                         if (!waitedTooLong) return [3 /*break*/, 2];
                         // Immediate execution path
                         this._invalidationPendingTimestamps.delete(debounceKey);
-                        return [4 /*yield*/, this._executeInvalidation(collection, type, documentId)];
+                        return [4 /*yield*/, this._executeInvalidation(collection)];
                     case 1:
                         _a.sent();
                         return [3 /*break*/, 3];
@@ -369,7 +376,7 @@ var SubscriptionManager = /** @class */ (function () {
                                 switch (_a.label) {
                                     case 0:
                                         this._invalidationPendingTimestamps.delete(debounceKey);
-                                        return [4 /*yield*/, this._executeInvalidation(collection, type, documentId)];
+                                        return [4 /*yield*/, this._executeInvalidation(collection)];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -382,9 +389,9 @@ var SubscriptionManager = /** @class */ (function () {
             });
         });
     };
-    SubscriptionManager.prototype._executeInvalidation = function (collection, type, documentId) {
+    SubscriptionManager.prototype._executeInvalidation = function (collection) {
         return __awaiter(this, void 0, void 0, function () {
-            var collSubs, normalizedDocumentId, collSubs_1, collSubs_1_1, sub, _a, _b, client, ws, _c, e_1_1, e_2_1;
+            var queued, events, collSubs, collSubs_1, collSubs_1_1, sub, batchType, _a, _b, client, ws, _c, e_1_1, e_2_1;
             var e_2, _d, e_1, _e;
             return __generator(this, function (_f) {
                 switch (_f.label) {
@@ -394,10 +401,15 @@ var SubscriptionManager = /** @class */ (function () {
                             clearTimeout(this._invalidationDebounceTimers.get(collection));
                             this._invalidationDebounceTimers.delete(collection);
                         }
+                        queued = this._pendingInvalidations.get(collection);
+                        this._pendingInvalidations.delete(collection);
+                        if (!queued || !queued.events.length) {
+                            return [2 /*return*/];
+                        }
+                        events = queued.events;
                         // Original invalidation logic
                         resolveio_server_app_1.ResolveIOServer.getMongoManager().invalidateQueryCache(collection);
                         collSubs = this._subscriptions.filter(function (a) { return a.collections.includes(collection); });
-                        normalizedDocumentId = this.normalizeDocumentId(documentId);
                         _f.label = 1;
                     case 1:
                         _f.trys.push([1, 18, 19, 20]);
@@ -409,18 +421,19 @@ var SubscriptionManager = /** @class */ (function () {
                         if (this._enableDebug) {
                             console.log(new Date(), 'Invalidate Sub', sub.publication, sub.running, sub.runAgain);
                         }
-                        return [4 /*yield*/, this.shouldInvalidateSubscription(sub, collection, type, normalizedDocumentId)];
+                        return [4 /*yield*/, this.shouldInvalidateSubscriptionForEvents(sub, collection, events)];
                     case 3:
                         if (!(_f.sent())) {
                             return [3 /*break*/, 16];
                         }
                         if (sub.running) {
                             sub.runAgain = true;
-                            this.dependencyDebug('Subscription busy, scheduling rerun', { publication: sub.publication, collection: collection, type: type });
+                            this.dependencyDebug('Subscription busy, scheduling rerun', { publication: sub.publication, collection: collection, events: this.summarizeEvents(events) });
                             return [3 /*break*/, 16];
                         }
+                        batchType = events.length === 1 ? events[0].type : events.map(function (event) { return event.type; }).join(',');
                         if (!this._publications[sub.publication].user_specific) return [3 /*break*/, 14];
-                        this.dependencyDebug('Triggering user-specific invalidation', { publication: sub.publication, collection: collection, type: type, documentId: normalizedDocumentId, clientCount: sub.clients.length });
+                        this.dependencyDebug('Triggering user-specific invalidation', { publication: sub.publication, collection: collection, events: this.summarizeEvents(events), clientCount: sub.clients.length });
                         _f.label = 4;
                     case 4:
                         _f.trys.push([4, 11, 12, 13]);
@@ -434,7 +447,7 @@ var SubscriptionManager = /** @class */ (function () {
                         _f.label = 6;
                     case 6:
                         _f.trys.push([6, 8, , 9]);
-                        return [4 /*yield*/, this.sendDataToOneWithRetry(ws, client.messageId, sub, collection, type)];
+                        return [4 /*yield*/, this.sendDataToOneWithRetry(ws, client.messageId, sub, collection, batchType)];
                     case 7:
                         _f.sent();
                         return [3 /*break*/, 9];
@@ -457,8 +470,8 @@ var SubscriptionManager = /** @class */ (function () {
                         return [7 /*endfinally*/];
                     case 13: return [3 /*break*/, 16];
                     case 14:
-                        this.dependencyDebug('Triggering broadcast invalidation', { publication: sub.publication, collection: collection, type: type, documentId: normalizedDocumentId, clientCount: sub.clients.length });
-                        return [4 /*yield*/, this.sendDataToAllWithRetry(sub, collection, type)];
+                        this.dependencyDebug('Triggering broadcast invalidation', { publication: sub.publication, collection: collection, events: this.summarizeEvents(events), clientCount: sub.clients.length });
+                        return [4 /*yield*/, this.sendDataToAllWithRetry(sub, collection, batchType)];
                     case 15:
                         _f.sent();
                         _f.label = 16;
@@ -719,7 +732,8 @@ var SubscriptionManager = /** @class */ (function () {
                                 runAgain: false,
                                 collectionDependencies: new Map(),
                                 collectionFilters: new Map(),
-                                watchAllCollections: new Set()
+                                watchAllCollections: new Set(),
+                                collectionQueryMeta: new Map()
                             });
                         }
                         if (!sub) {
@@ -1355,6 +1369,9 @@ var SubscriptionManager = /** @class */ (function () {
         if (!sub.watchAllCollections) {
             sub.watchAllCollections = new Set();
         }
+        if (!sub.collectionQueryMeta) {
+            sub.collectionQueryMeta = new Map();
+        }
     };
     SubscriptionManager.prototype.updateSubscriptionDependencies = function (sub, snapshot) {
         this.ensureDependencyContainers(sub);
@@ -1362,12 +1379,14 @@ var SubscriptionManager = /** @class */ (function () {
             sub.collectionDependencies.clear();
             sub.collectionFilters.clear();
             sub.watchAllCollections.clear();
+            sub.collectionQueryMeta.clear();
             this.dependencyDebug('Cleared dependency snapshot', { publication: sub.publication });
             return;
         }
         sub.collectionDependencies = snapshot.dependencies;
         sub.collectionFilters = snapshot.filters;
         sub.watchAllCollections = snapshot.watchAllCollections;
+        sub.collectionQueryMeta = snapshot.queryMetadata;
         this.logDependencySnapshot(sub, 'Snapshot updated');
     };
     SubscriptionManager.prototype.normalizeDocumentId = function (rawId) {
@@ -1491,6 +1510,81 @@ var SubscriptionManager = /** @class */ (function () {
             });
         });
     };
+    SubscriptionManager.prototype.shouldInvalidateSubscriptionForEvents = function (sub, collection, events) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sawInsert, events_1, events_1_1, event_1, normalizedDocumentId, e_7_1, relevantMeta;
+            var e_7, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        sawInsert = false;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        events_1 = __values(events), events_1_1 = events_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!events_1_1.done) return [3 /*break*/, 5];
+                        event_1 = events_1_1.value;
+                        normalizedDocumentId = this.normalizeDocumentId(event_1.documentId);
+                        if (event_1.type === 'insert') {
+                            sawInsert = true;
+                        }
+                        return [4 /*yield*/, this.shouldInvalidateSubscription(sub, collection, event_1.type, normalizedDocumentId)];
+                    case 3:
+                        if (_b.sent()) {
+                            return [2 /*return*/, true];
+                        }
+                        _b.label = 4;
+                    case 4:
+                        events_1_1 = events_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_7_1 = _b.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        if (sawInsert) {
+                            relevantMeta = this.shouldForceRequeryOnInsert(sub, collection);
+                            if (relevantMeta === null || relevantMeta === void 0 ? void 0 : relevantMeta.length) {
+                                this.dependencyDebug('Invalidate due to pagination metadata', {
+                                    publication: sub.publication,
+                                    collection: collection,
+                                    events: this.summarizeEvents(events),
+                                    queryMeta: relevantMeta.slice(0, 5)
+                                });
+                                return [2 /*return*/, true];
+                            }
+                        }
+                        return [2 /*return*/, false];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.shouldForceRequeryOnInsert = function (sub, collection) {
+        var _a;
+        this.ensureDependencyContainers(sub);
+        var metaList = (_a = sub.collectionQueryMeta) === null || _a === void 0 ? void 0 : _a.get(collection);
+        if (!metaList || !metaList.length) {
+            return null;
+        }
+        var relevantMeta = metaList.filter(function (meta) {
+            if (!meta) {
+                return false;
+            }
+            var limitUsed = typeof meta.limit === 'number' && meta.limit > 0;
+            var skipUsed = typeof meta.skip === 'number' && meta.skip > 0;
+            return limitUsed || skipUsed;
+        });
+        return relevantMeta.length ? relevantMeta : null;
+    };
     SubscriptionManager.prototype.sendWS = function (ws, data) {
         this._websocketManager.send(ws, data);
     };
@@ -1508,6 +1602,13 @@ var SubscriptionManager = /** @class */ (function () {
             console.log(new Date(), '[Dependency Debug]', message);
         }
     };
+    SubscriptionManager.prototype.summarizeEvents = function (events) {
+        var _this = this;
+        return events.map(function (event) { return ({
+            type: event.type,
+            documentId: _this.normalizeDocumentId(event.documentId)
+        }); });
+    };
     SubscriptionManager.prototype.logDependencySnapshot = function (sub, context) {
         if (!this._enableDependencyDebug) {
             return;
@@ -1528,12 +1629,21 @@ var SubscriptionManager = /** @class */ (function () {
                 count: filters.length
             });
         });
+        var queryMetaSummary = Array.from(sub.collectionQueryMeta.entries()).map(function (_a) {
+            var _b = __read(_a, 2), collectionName = _b[0], metaList = _b[1];
+            return ({
+                collection: collectionName,
+                count: metaList.length,
+                meta: metaList.slice(0, 5)
+            });
+        });
         var watchAll = Array.from(sub.watchAllCollections || []);
         this.dependencyDebug('Dependency snapshot updated', {
             context: context,
             publication: sub.publication,
             dependencies: dependencySummary,
             collectionsWithFilters: filterSummary,
+            collectionsWithMeta: queryMetaSummary,
             watchAll: watchAll
         });
     };