@resolveio/server-lib 20.13.1 → 20.13.2

package/managers/subscription.manager.d.ts

@@ -13,6 +13,10 @@ export declare class SubscriptionManager {
     private _mongoQueue;
     private _mongoQueueId;
     private _oplog$;
+    private _oplogMode;
+    private _useLocalOplog;
+    private _localOplogResyncIntervalMs;
+    private _localOplogResyncTimer;
     private _nodeCache;
     private _cacheId;
     private _heapSize;
@@ -69,6 +73,13 @@ export declare class SubscriptionManager {
     getActiveSubscriptions(): ActiveSubscriptionModel[];
     private getPublicationCollections;
     private getWatchedDatabases;
+    private resolveOplogMode;
+    private resolveLocalOplogResyncIntervalMs;
+    private parsePositiveNumber;
+    private isChangeStreamUnsupported;
+    private enableLocalOplogFallback;
+    getUseLocalOplog(): boolean;
+    notifyLocalOplog(collection: string, type?: string): void;
     private getResumeTokenDocId;
     private loadResumeToken;
     private saveResumeToken;

package/managers/subscription.manager.js

@@ -124,6 +124,10 @@ var SubscriptionManager = /** @class */ (function () {
         this._lastRouteBySocket = new Map();
         this._mongoQueue = [];
         this._mongoQueueId = 0;
+        this._oplogMode = 'auto';
+        this._useLocalOplog = false;
+        this._localOplogResyncIntervalMs = 0;
+        this._localOplogResyncTimer = null;
         this._cacheId = 1;
         this._heapSize = resolveHeapLimitBytes();
         this._enableDebug = false;
@@ -204,6 +208,8 @@ var SubscriptionManager = /** @class */ (function () {
                         // }, 10000);
                         this.serverConfig = serverConfig;
                         this._wss = wss;
+                        this._oplogMode = this.resolveOplogMode();
+                        this._localOplogResyncIntervalMs = this.resolveLocalOplogResyncIntervalMs();
                         // Publications
                         (0, super_admin_1.loadSuperAdminPublications)(this);
                         (0, app_status_1.loadAppStatusPublications)(this);
@@ -218,12 +224,19 @@ var SubscriptionManager = /** @class */ (function () {
                         (0, user_groups_1.loadUserGroupPublications)(this);
                         (0, user_guides_1.loadUserGuidePublications)(this);
                         (0, report_builder_dashboard_builders_1.loadReportBuilderDashboardBuilderPublications)(this);
-                        return [4 /*yield*/, this.loadResumeToken()];
+                        if (!(this._oplogMode === 'local')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('config')];
                     case 1:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 2: return [4 /*yield*/, this.loadResumeToken()];
+                    case 3:
                         resumeToken = _a.sent();
                         return [4 /*yield*/, this.tailOpLog(resumeToken || undefined)];
-                    case 2:
+                    case 4:
                         _a.sent();
+                        _a.label = 5;
+                    case 5:
                         setInterval(function () {
                             _this._oplogRetryCount = 0;
                         }, 15000);
@@ -330,10 +343,10 @@ var SubscriptionManager = /** @class */ (function () {
                             });
                         }); }, 30000);
                         return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Debug' })];
-                    case 3:
+                    case 6:
                         flag = _a.sent();
                         return [4 /*yield*/, flag_collection_1.Flags.findOne({ type: 'Enable Dependency Debug' })];
-                    case 4:
+                    case 7:
                         dependencyFlag = _a.sent();
                         if (flag && flag.value) {
                             this._enableDebug = true;
@@ -430,7 +443,7 @@ var SubscriptionManager = /** @class */ (function () {
                         }
                         events = queued.events;
                         // Original invalidation logic
-                        resolveio_server_app_1.ResolveIOServer.getMongoManager().invalidateQueryCache(collection);
+                        resolveio_server_app_1.ResolveIOServer.getMongoManager().invalidateQueryCache(collection, true);
                         collSubs = this._subscriptions.filter(function (sub) { return _this.subscriptionReferencesCollection(sub, collection); });
                         _f.label = 1;
                     case 1:
@@ -937,6 +950,128 @@ var SubscriptionManager = /** @class */ (function () {
         var mainDb = config && typeof config['DATABASE'] === 'string' ? config['DATABASE'] : '';
         return mainDb ? [mainDb] : [];
     };
+    SubscriptionManager.prototype.resolveOplogMode = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.SUBSCRIPTION_OPLOG_MODE || process.env.OPLOG_MODE || config['SUBSCRIPTION_OPLOG_MODE'] || config['OPLOG_MODE'];
+        if (typeof raw !== 'string' || !raw.trim()) {
+            return 'auto';
+        }
+        var normalized = raw.trim().toLowerCase();
+        if (['local', 'single', 'standalone', 'fallback', 'poll'].includes(normalized)) {
+            return 'local';
+        }
+        if (['change-stream', 'changestream', 'oplog', 'replica', 'replicaset', 'rs'].includes(normalized)) {
+            return 'change-stream';
+        }
+        return 'auto';
+    };
+    SubscriptionManager.prototype.resolveLocalOplogResyncIntervalMs = function () {
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = process.env.OPLOG_FALLBACK_RESYNC_MS
+            || process.env.SUBSCRIPTION_OPLOG_RESYNC_MS
+            || config['OPLOG_FALLBACK_RESYNC_MS']
+            || config['SUBSCRIPTION_OPLOG_RESYNC_MS'];
+        return this.parsePositiveNumber(raw);
+    };
+    SubscriptionManager.prototype.parsePositiveNumber = function (value) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            return value;
+        }
+        if (typeof value === 'string' && value.trim().length) {
+            var parsed = parseInt(value, 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                return parsed;
+            }
+        }
+        return 0;
+    };
+    SubscriptionManager.prototype.isChangeStreamUnsupported = function (error) {
+        var code = typeof (error === null || error === void 0 ? void 0 : error.code) === 'number' ? error.code : null;
+        var codeName = typeof (error === null || error === void 0 ? void 0 : error.codeName) === 'string' ? error.codeName.toLowerCase() : '';
+        var message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message.toLowerCase() : '';
+        if (code === 40573) {
+            return true;
+        }
+        if (codeName && codeName.includes('changestream')) {
+            return true;
+        }
+        if (message.includes('change stream') && message.includes('replica')) {
+            return true;
+        }
+        if (message.includes('change stream') && message.includes('not supported')) {
+            return true;
+        }
+        return false;
+    };
+    SubscriptionManager.prototype.enableLocalOplogFallback = function (reason, error) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, message;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this._useLocalOplog) {
+                            return [2 /*return*/];
+                        }
+                        this._useLocalOplog = true;
+                        this._oplogMode = 'local';
+                        this._oplogRetryCount = 0;
+                        if (!(this._oplog$ && !this._oplog$.closed)) return [3 /*break*/, 5];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        this._oplog$.removeAllListeners();
+                        return [4 /*yield*/, this._oplog$.close()];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        this._oplog$ = null;
+                        _b.label = 5;
+                    case 5:
+                        message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message : '';
+                        console.log(new Date(), 'oplog fallback enabled', reason, message ? "(".concat(message, ")") : '');
+                        this.queueFullResync('oplog-fallback-enabled');
+                        if (this._localOplogResyncIntervalMs > 0 && !this._localOplogResyncTimer) {
+                            this._localOplogResyncTimer = setInterval(function () {
+                                _this.queueFullResync('oplog-fallback-poll');
+                            }, this._localOplogResyncIntervalMs);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.getUseLocalOplog = function () {
+        return this._useLocalOplog;
+    };
+    SubscriptionManager.prototype.notifyLocalOplog = function (collection, type) {
+        var _this = this;
+        if (type === void 0) { type = 'update'; }
+        if (!this._useLocalOplog) {
+            return;
+        }
+        setImmediate(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.invalidatePubsCache(collection, type)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
     SubscriptionManager.prototype.getResumeTokenDocId = function () {
         if (process.env.NODE_APP_INSTANCE) {
             return "oplog:".concat(process.env.NODE_APP_INSTANCE);
@@ -1194,11 +1329,14 @@ var SubscriptionManager = /** @class */ (function () {
     // Watch (tail) Mongo's operation log on the entire database (all insert/modify/delete will trigger this function)
     SubscriptionManager.prototype.tailOpLog = function (resumeToken) {
         return __awaiter(this, void 0, void 0, function () {
-            var watchDatabases, pipeline, lastResumeToken_1, startedWithResumeToken, error_6;
+            var watchDatabases, pipeline, lastResumeToken_1, startedWithResumeToken, error_6, innerError_1, error_7;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        if (this._useLocalOplog) {
+                            return [2 /*return*/];
+                        }
                         if (!(this._oplog$ && !this._oplog$.closed)) return [3 /*break*/, 2];
                         this._oplog$.removeAllListeners();
                         return [4 /*yield*/, this._oplog$.close()];
@@ -1212,7 +1350,7 @@ var SubscriptionManager = /** @class */ (function () {
                     case 3:
                         // eslint-disable-next-line no-restricted-syntax
                         _a.sent();
-                        if (!(!this._oplog$ || this._oplog$.closed)) return [3 /*break*/, 12];
+                        if (!(!this._oplog$ || this._oplog$.closed)) return [3 /*break*/, 22];
                         this._oplogRetryCount += 1;
                         if (this._oplogRetryCount > 5) {
                             console.error('****************** TAIL OPLOG ERROR, RETRYING A BUNCH OF TIMES, KILLING PROCESS **************************');
@@ -1243,37 +1381,65 @@ var SubscriptionManager = /** @class */ (function () {
                             },
                         ];
                         startedWithResumeToken = false;
-                        if (!resumeToken) return [3 /*break*/, 10];
+                        if (!resumeToken) return [3 /*break*/, 17];
                         lastResumeToken_1 = resumeToken;
                         _a.label = 4;
                     case 4:
-                        _a.trys.push([4, 5, , 9]);
+                        _a.trys.push([4, 5, , 16]);
                         this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { resumeAfter: resumeToken, fullDocument: 'updateLookup' });
                         startedWithResumeToken = true;
-                        return [3 /*break*/, 9];
+                        return [3 /*break*/, 16];
                     case 5:
                         error_6 = _a.sent();
-                        if (!this._oplog$) return [3 /*break*/, 7];
+                        if (!this.isChangeStreamUnsupported(error_6)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_6)];
+                    case 6:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 7:
+                        if (!this._oplog$) return [3 /*break*/, 9];
                         this._oplog$.removeAllListeners();
                         return [4 /*yield*/, this._oplog$.close()];
-                    case 6:
+                    case 8:
                         _a.sent();
                         this._oplog$ = null;
-                        _a.label = 7;
-                    case 7: return [4 /*yield*/, this.clearResumeToken()];
-                    case 8:
+                        _a.label = 9;
+                    case 9: return [4 /*yield*/, this.clearResumeToken()];
+                    case 10:
                         _a.sent();
                         lastResumeToken_1 = null;
                         console.log(new Date(), 'oplog resumeAfter failed, starting fresh', error_6);
+                        _a.label = 11;
+                    case 11:
+                        _a.trys.push([11, 12, , 15]);
                         this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
                         startedWithResumeToken = false;
+                        return [3 /*break*/, 15];
+                    case 12:
+                        innerError_1 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(innerError_1)) return [3 /*break*/, 14];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', innerError_1)];
+                    case 13:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 14: throw innerError_1;
+                    case 15:
                         this.queueFullResync('oplog-resumeAfter-failed');
-                        return [3 /*break*/, 9];
-                    case 9: return [3 /*break*/, 11];
-                    case 10:
+                        return [3 /*break*/, 16];
+                    case 16: return [3 /*break*/, 21];
+                    case 17:
+                        _a.trys.push([17, 18, , 21]);
                         this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
-                        _a.label = 11;
-                    case 11:
+                        return [3 /*break*/, 21];
+                    case 18:
+                        error_7 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(error_7)) return [3 /*break*/, 20];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_7)];
+                    case 19:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 20: throw error_7;
+                    case 21:
                         console.log(new Date(), 'oplog started', startedWithResumeToken ? '(resumeAfter)' : '');
                         this._oplog$.on('change', function (doc) { return __awaiter(_this, void 0, void 0, function () {
                             var collection, fullDocument, docId, flag, dependencyFlag;
@@ -1365,10 +1531,15 @@ var SubscriptionManager = /** @class */ (function () {
                                 switch (_a.label) {
                                     case 0:
                                         console.log(new Date(), 'oplog error', error);
-                                        return [4 /*yield*/, this._oplog$.close()];
+                                        if (!this.isChangeStreamUnsupported(error)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error)];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
+                                    case 2: return [4 /*yield*/, this._oplog$.close()];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/];
                                 }
                             });
                         }); });
@@ -1399,8 +1570,8 @@ var SubscriptionManager = /** @class */ (function () {
                                 }
                             });
                         }); });
-                        _a.label = 12;
-                    case 12: return [2 /*return*/];
+                        _a.label = 22;
+                    case 22: return [2 /*return*/];
                 }
             });
         });