@terreno/api 0.13.2 → 0.14.0

package/dist/realtime/changeStreamWatcher.js

@@ -0,0 +1,720 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopChangeStreamWatcher = exports.startChangeStreamWatcher = exports.emitToDocumentAndQueryRooms = exports.emitToAuthorizedRoom = exports.serializeDoc = exports.ensureApiId = exports.resolveRooms = exports.mapOperationType = void 0;
+// biome-ignore-all lint/suspicious/noExplicitAny: change stream and socket handlers use dynamic document shapes
+var Sentry = __importStar(require("@sentry/bun"));
+var luxon_1 = require("luxon");
+var mongoose_1 = __importDefault(require("mongoose"));
+var logger_1 = require("../logger");
+var permissions_1 = require("../permissions");
+var queryMatcher_1 = require("./queryMatcher");
+var queryStore_1 = require("./queryStore");
+var registry_1 = require("./registry");
+var socketUser_1 = require("./socketUser");
+var changeWatcher = null;
+var DEFAULT_IGNORED_COLLECTIONS = ["socketio", "sessions"];
+/**
+ * Map MongoDB change stream operation types to our method names.
+ *
+ * Soft deletes (an `update` that sets `deleted: true`) are reclassified as
+ * `"delete"` only when the model has `"delete"` enabled in its realtime
+ * methods. Otherwise they fall back to `"update"` so models that subscribe
+ * to updates (but not deletes) still see the change — without this fallback,
+ * a model configured with `methods: ["create", "update"]` would silently
+ * drop soft-delete events.
+ *
+ * Exported for testing.
+ */
+var mapOperationType = function (operationType, change, enabledMethods) {
+    var _a, _b;
+    if (enabledMethods === void 0) { enabledMethods = ["create", "update", "delete"]; }
+    if (operationType === "insert") {
+        return "create";
+    }
+    if (operationType === "update" || operationType === "replace") {
+        // Soft delete on an update event: the document was patched with deleted=true.
+        // `change` is typed as the full union (without operationType narrowing) because
+        // callers/tests pass change objects without setting `operationType` on the change.
+        var updateChange = change;
+        var isSoftDelete = operationType === "update" && ((_b = (_a = updateChange.updateDescription) === null || _a === void 0 ? void 0 : _a.updatedFields) === null || _b === void 0 ? void 0 : _b.deleted) === true;
+        if (isSoftDelete && enabledMethods.includes("delete")) {
+            return "delete";
+        }
+        return "update";
+    }
+    if (operationType === "delete") {
+        return "delete";
+    }
+    return null;
+};
+exports.mapOperationType = mapOperationType;
+/**
+ * Get the collection tag from a route path (strips leading "/").
+ * E.g. "/todos" -> "todos"
+ */
+var getCollectionTag = function (routePath) { return routePath.replace(/^\//, ""); };
+var getSocketsInRoom = function (io, room) {
+    var e_1, _a;
+    var socketIds = io.sockets.adapter.rooms.get(room);
+    if (!socketIds) {
+        return [];
+    }
+    var sockets = [];
+    try {
+        for (var socketIds_1 = __values(socketIds), socketIds_1_1 = socketIds_1.next(); !socketIds_1_1.done; socketIds_1_1 = socketIds_1.next()) {
+            var socketId = socketIds_1_1.value;
+            var socket = io.sockets.sockets.get(socketId);
+            if (socket) {
+                sockets.push(socket);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (socketIds_1_1 && !socketIds_1_1.done && (_a = socketIds_1.return)) _a.call(socketIds_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return sockets;
+};
+var canReadDocument = function (entry, user, doc) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, (0, permissions_1.checkPermissions)("read", entry.options.permissions.read, user, doc)];
+    });
+}); };
+/**
+ * Determine which Socket.io rooms to emit to based on the room strategy.
+ * Exported for testing.
+ */
+var resolveRooms = function (entry, doc, method) {
+    var _a, _b, _c;
+    var roomStrategy = entry.config.roomStrategy;
+    // Use the collection tag (e.g. "todos") for model rooms, matching what the frontend subscribes to
+    var collectionTag = getCollectionTag(entry.routePath);
+    if (typeof roomStrategy === "function") {
+        // Custom room resolver — pass a minimal pseudo-request. The strategy only inspects
+        // doc/method; we never read fields off req here, so an empty cast is safe.
+        return roomStrategy(doc, method, {});
+    }
+    switch (roomStrategy) {
+        case "owner": {
+            var ownerId = (_c = (_b = (_a = doc === null || doc === void 0 ? void 0 : doc.ownerId) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : doc === null || doc === void 0 ? void 0 : doc.ownerId;
+            if (ownerId) {
+                return ["user:".concat(ownerId)];
+            }
+            // If no ownerId, fall back to model room
+            return ["model:".concat(collectionTag)];
+        }
+        case "model":
+            return ["model:".concat(collectionTag)];
+        case "broadcast":
+            return ["authenticated"];
+        default:
+            return ["model:".concat(collectionTag)];
+    }
+};
+exports.resolveRooms = resolveRooms;
+/**
+ * Ensure serialized documents include `id` to match REST API responses.
+ * Change stream fullDocument payloads are raw BSON objects with `_id` only.
+ */
+var ensureApiId = function (data) {
+    if (data == null || typeof data !== "object" || Array.isArray(data)) {
+        return data;
+    }
+    var serialized = data;
+    if (serialized._id != null && serialized.id == null) {
+        return __assign(__assign({}, serialized), { id: serialized._id });
+    }
+    return data;
+};
+exports.ensureApiId = ensureApiId;
+/**
+ * Serialize a document for emission.
+ *
+ * Precedence:
+ *   1. `realtimeResponseHandler` if provided (full control over what's emitted).
+ *   2. modelRouter `responseHandler` if provided — invoked with a synthetic request
+ *      so the same stripping logic used for REST responses (e.g. removing `hash`/`salt`)
+ *      applies to realtime events. This prevents accidental leaks when an app only
+ *      configures sanitization in the REST `responseHandler`.
+ *   3. `toJSON()` fallback.
+ *
+ * If a user-supplied handler throws, we re-throw so the caller's outer try/catch
+ * records the failure and the event is dropped. Falling back to `toJSON()` here
+ * would risk leaking unsanitized fields (e.g. `hash`/`salt`) that the handler
+ * was supposed to strip.
+ */
+var serializeDoc = function (entry, doc, method, user) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, error_1, responseHandler, restMethod, syntheticReq, _b, error_2;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                if (!entry.config.realtimeResponseHandler) return [3 /*break*/, 4];
+                _d.label = 1;
+            case 1:
+                _d.trys.push([1, 3, , 4]);
+                _a = exports.ensureApiId;
+                return [4 /*yield*/, entry.config.realtimeResponseHandler(doc, method)];
+            case 2: return [2 /*return*/, _a.apply(void 0, [_d.sent()])];
+            case 3:
+                error_1 = _d.sent();
+                logger_1.logger.error("[realtime] realtimeResponseHandler threw for ".concat(entry.modelName, "/").concat(method, ": ").concat(error_1, ". ") +
+                    "Dropping event to avoid leaking unsanitized data.");
+                throw error_1;
+            case 4:
+                responseHandler = (_c = entry.options) === null || _c === void 0 ? void 0 : _c.responseHandler;
+                if (!responseHandler) return [3 /*break*/, 8];
+                _d.label = 5;
+            case 5:
+                _d.trys.push([5, 7, , 8]);
+                restMethod = method === "delete" ? "read" : method;
+                syntheticReq = { params: {}, query: {}, user: user };
+                _b = exports.ensureApiId;
+                return [4 /*yield*/, responseHandler(doc, restMethod, syntheticReq, entry.options)];
+            case 6: return [2 /*return*/, _b.apply(void 0, [_d.sent()])];
+            case 7:
+                error_2 = _d.sent();
+                logger_1.logger.error("[realtime] modelRouter responseHandler threw during realtime serialization for " +
+                    "".concat(entry.modelName, "/").concat(method, ": ").concat(error_2, ". Dropping event to avoid leaking unsanitized data."));
+                throw error_2;
+            case 8: return [2 /*return*/, (0, exports.ensureApiId)(typeof doc.toJSON === "function" ? doc.toJSON() : doc)];
+        }
+    });
+}); };
+exports.serializeDoc = serializeDoc;
+var emitToAuthorizedRoom = function (io, room, event, entry, fullDocument, logDebug) { return __awaiter(void 0, void 0, void 0, function () {
+    var sockets, sockets_1, sockets_1_1, socket, user, permissionDocument, canRead, data, error_3, e_2_1;
+    var e_2, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                sockets = getSocketsInRoom(io, room);
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, 9, 10, 11]);
+                sockets_1 = __values(sockets), sockets_1_1 = sockets_1.next();
+                _b.label = 2;
+            case 2:
+                if (!!sockets_1_1.done) return [3 /*break*/, 8];
+                socket = sockets_1_1.value;
+                user = (0, socketUser_1.getSocketUser)(socket);
+                _b.label = 3;
+            case 3:
+                _b.trys.push([3, 6, , 7]);
+                permissionDocument = fullDocument !== null && fullDocument !== void 0 ? fullDocument : {};
+                return [4 /*yield*/, canReadDocument(entry, user, permissionDocument)];
+            case 4:
+                canRead = _b.sent();
+                if (!canRead) {
+                    logDebug("[realtime] Skipped ".concat(room, " for ").concat(socket.id, ": read permission denied"));
+                    return [3 /*break*/, 7];
+                }
+                if (!fullDocument) {
+                    socket.emit("sync", event);
+                    return [3 /*break*/, 7];
+                }
+                return [4 /*yield*/, (0, exports.serializeDoc)(entry, fullDocument, event.method, user)];
+            case 5:
+                data = _b.sent();
+                socket.emit("sync", __assign(__assign({}, event), { data: data }));
+                return [3 /*break*/, 7];
+            case 6:
+                error_3 = _b.sent();
+                logger_1.logger.error("[realtime] Failed to emit ".concat(entry.modelName, "/").concat(event.method, " to socket ").concat(socket.id, ": ").concat(error_3));
+                Sentry.captureException(error_3);
+                return [3 /*break*/, 7];
+            case 7:
+                sockets_1_1 = sockets_1.next();
+                return [3 /*break*/, 2];
+            case 8: return [3 /*break*/, 11];
+            case 9:
+                e_2_1 = _b.sent();
+                e_2 = { error: e_2_1 };
+                return [3 /*break*/, 11];
+            case 10:
+                try {
+                    if (sockets_1_1 && !sockets_1_1.done && (_a = sockets_1.return)) _a.call(sockets_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+                return [7 /*endfinally*/];
+            case 11: return [2 /*return*/];
+        }
+    });
+}); };
+exports.emitToAuthorizedRoom = emitToAuthorizedRoom;
+/**
+ * Emit a sync event to document-specific and query rooms.
+ *
+ * Document rooms: `document:{collection}:{docId}` — clients subscribed to a single document.
+ * Query rooms: `query:{queryId}` — clients subscribed to a query filter. The change stream
+ * watcher evaluates whether the document matches each active query for the collection.
+ *
+ * For deletes, we are careful not to leak cross-user activity:
+ *   - Soft deletes (fullDocument present) are matched against each query like updates so
+ *     query subscribers only see deletes for docs that matched their filter.
+ *   - Hard deletes (fullDocument absent) on owner-strategy collections are NOT forwarded
+ *     to query rooms — subscribers will reconcile on their next fetch. Other strategies
+ *     forward the delete because the model/broadcast rooms are not user-scoped.
+ *
+ * Exported for testing.
+ */
+var emitToDocumentAndQueryRooms = function (io, collection, event, fullDocument, logDebug, entry) { return __awaiter(void 0, void 0, void 0, function () {
+    var docRoom, isOwnerStrategy, querySubscriptions, querySubscriptions_1, querySubscriptions_1_1, _a, queryId, query, queryRoom, docMatches, removeEvent, e_3_1;
+    var e_3, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                docRoom = "document:".concat(collection, ":").concat(event.id);
+                if (!entry) return [3 /*break*/, 2];
+                return [4 /*yield*/, (0, exports.emitToAuthorizedRoom)(io, docRoom, event, entry, fullDocument, logDebug)];
+            case 1:
+                _c.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                io.to(docRoom).emit("sync", event);
+                _c.label = 3;
+            case 3:
+                logDebug("[realtime] Emitted ".concat(event.method, " to ").concat(docRoom));
+                isOwnerStrategy = (entry === null || entry === void 0 ? void 0 : entry.config.roomStrategy) === "owner";
+                querySubscriptions = (0, queryStore_1.getQuerySubscriptionsForCollection)(collection);
+                _c.label = 4;
+            case 4:
+                _c.trys.push([4, 28, 29, 30]);
+                querySubscriptions_1 = __values(querySubscriptions), querySubscriptions_1_1 = querySubscriptions_1.next();
+                _c.label = 5;
+            case 5:
+                if (!!querySubscriptions_1_1.done) return [3 /*break*/, 27];
+                _a = querySubscriptions_1_1.value, queryId = _a.queryId, query = _a.query;
+                queryRoom = "query:".concat(queryId);
+                if (!(event.method === "delete")) return [3 /*break*/, 14];
+                if (!!fullDocument) return [3 /*break*/, 9];
+                // Hard delete with no document context. For owner-strategy collections we can't
+                // tell which query rooms belong to the owner without leaking activity to others,
+                // so skip query fanout entirely — subscribers will reconcile on next fetch.
+                if (isOwnerStrategy) {
+                    logDebug("[realtime] Skipping hard delete fanout to ".concat(queryRoom, " (owner strategy, no fullDocument)"));
+                    return [3 /*break*/, 26];
+                }
+                if (!entry) return [3 /*break*/, 7];
+                return [4 /*yield*/, (0, exports.emitToAuthorizedRoom)(io, queryRoom, event, entry, fullDocument, logDebug)];
+            case 6:
+                _c.sent();
+                return [3 /*break*/, 8];
+            case 7:
+                io.to(queryRoom).emit("sync", event);
+                _c.label = 8;
+            case 8:
+                logDebug("[realtime] Emitted hard delete to ".concat(queryRoom));
+                return [3 /*break*/, 26];
+            case 9:
+                if (!(0, queryMatcher_1.matchesQuery)(fullDocument, query)) return [3 /*break*/, 13];
+                if (!entry) return [3 /*break*/, 11];
+                return [4 /*yield*/, (0, exports.emitToAuthorizedRoom)(io, queryRoom, event, entry, fullDocument, logDebug)];
+            case 10:
+                _c.sent();
+                return [3 /*break*/, 12];
+            case 11:
+                io.to(queryRoom).emit("sync", event);
+                _c.label = 12;
+            case 12:
+                logDebug("[realtime] Emitted soft delete to ".concat(queryRoom, " (query matched)"));
+                _c.label = 13;
+            case 13: return [3 /*break*/, 26];
+            case 14:
+                if (!fullDocument) {
+                    return [3 /*break*/, 26];
+                }
+                docMatches = (0, queryMatcher_1.matchesQuery)(fullDocument, query);
+                if (!(event.method === "create" && docMatches)) return [3 /*break*/, 18];
+                if (!entry) return [3 /*break*/, 16];
+                return [4 /*yield*/, (0, exports.emitToAuthorizedRoom)(io, queryRoom, event, entry, fullDocument, logDebug)];
+            case 15:
+                _c.sent();
+                return [3 /*break*/, 17];
+            case 16:
+                io.to(queryRoom).emit("sync", event);
+                _c.label = 17;
+            case 17:
+                logDebug("[realtime] Emitted create to ".concat(queryRoom, " (query matched)"));
+                return [3 /*break*/, 26];
+            case 18:
+                if (!(event.method === "update")) return [3 /*break*/, 26];
+                if (!docMatches) return [3 /*break*/, 22];
+                if (!entry) return [3 /*break*/, 20];
+                return [4 /*yield*/, (0, exports.emitToAuthorizedRoom)(io, queryRoom, event, entry, fullDocument, logDebug)];
+            case 19:
+                _c.sent();
+                return [3 /*break*/, 21];
+            case 20:
+                io.to(queryRoom).emit("sync", event);
+                _c.label = 21;
+            case 21:
+                logDebug("[realtime] Emitted update to ".concat(queryRoom, " (query matched)"));
+                return [3 /*break*/, 26];
+            case 22:
+                removeEvent = __assign(__assign({}, event), { method: "delete" });
+                if (!entry) return [3 /*break*/, 24];
+                return [4 /*yield*/, (0, exports.emitToAuthorizedRoom)(io, queryRoom, removeEvent, entry, fullDocument, logDebug)];
+            case 23:
+                _c.sent();
+                return [3 /*break*/, 25];
+            case 24:
+                io.to(queryRoom).emit("sync", removeEvent);
+                _c.label = 25;
+            case 25:
+                logDebug("[realtime] Emitted delete to ".concat(queryRoom, " (query no longer matched)"));
+                _c.label = 26;
+            case 26:
+                querySubscriptions_1_1 = querySubscriptions_1.next();
+                return [3 /*break*/, 5];
+            case 27: return [3 /*break*/, 30];
+            case 28:
+                e_3_1 = _c.sent();
+                e_3 = { error: e_3_1 };
+                return [3 /*break*/, 30];
+            case 29:
+                try {
+                    if (querySubscriptions_1_1 && !querySubscriptions_1_1.done && (_b = querySubscriptions_1.return)) _b.call(querySubscriptions_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+                return [7 /*endfinally*/];
+            case 30: return [2 /*return*/];
+        }
+    });
+}); };
+exports.emitToDocumentAndQueryRooms = emitToDocumentAndQueryRooms;
+/**
+ * Start watching MongoDB change streams and emitting real-time events.
+ */
+var startChangeStreamWatcher = function (io, config, debug) {
+    var _a, _b, _c, _d;
+    if (config === void 0) { config = {}; }
+    if (debug === void 0) { debug = false; }
+    var logInfo = function (message) {
+        if (debug) {
+            logger_1.logger.info(message);
+        }
+    };
+    var logDebug = function (message) {
+        if (debug) {
+            logger_1.logger.debug(message);
+        }
+    };
+    try {
+        logInfo("[realtime] Initializing change stream watcher...");
+        var ignored = new Set(__spreadArray(__spreadArray([], __read(DEFAULT_IGNORED_COLLECTIONS), false), __read(((_a = config.ignoredCollections) !== null && _a !== void 0 ? _a : [])), false));
+        var ignoredOps_1 = new Set((_b = config.ignoredOperations) !== null && _b !== void 0 ? _b : []);
+        // Build the change stream pipeline
+        var pipeline = [
+            {
+                $match: {
+                    "ns.coll": { $nin: Array.from(ignored) },
+                    operationType: { $in: ["insert", "update", "replace", "delete"] },
+                },
+            },
+            {
+                $project: {
+                    documentKey: 1,
+                    fullDocument: 1,
+                    ns: 1,
+                    operationType: 1,
+                    updateDescription: 1,
+                },
+            },
+        ];
+        var nativeDb = mongoose_1.default.connection.db;
+        if (!nativeDb) {
+            throw new Error("MongoDB connection not available for change stream");
+        }
+        var options = {
+            batchSize: (_c = config.batchSize) !== null && _c !== void 0 ? _c : 50,
+            fullDocument: (_d = config.fullDocument) !== null && _d !== void 0 ? _d : "updateLookup",
+            fullDocumentBeforeChange: "off",
+            // How long the cursor waits for new events before yielding control.
+            // Lower values give more responsive updates at the cost of more frequent driver round-trips.
+            maxAwaitTimeMS: 1000,
+        };
+        changeWatcher = nativeDb.watch(pipeline, options);
+        if (!changeWatcher) {
+            throw new Error("Failed to create change stream watcher");
+        }
+        changeWatcher.on("change", function (rawChange) { return __awaiter(void 0, void 0, void 0, function () {
+            var change, collectionName, docId, entry, method, fullDocument, isHardDelete, rooms, collectionTag, collection, event_1, rooms_1, rooms_1_1, room, e_4_1, metadata, error_4;
+            var e_4, _a;
+            var _b, _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        _f.trys.push([0, 10, , 11]);
+                        // The pipeline restricts operationType to a subset that always has ns/documentKey;
+                        // narrow once here so downstream code doesn't need repeated casts.
+                        if (rawChange.operationType !== "insert" &&
+                            rawChange.operationType !== "update" &&
+                            rawChange.operationType !== "replace" &&
+                            rawChange.operationType !== "delete") {
+                            return [2 /*return*/];
+                        }
+                        change = rawChange;
+                        collectionName = (_b = change.ns) === null || _b === void 0 ? void 0 : _b.coll;
+                        docId = (_d = (_c = change.documentKey) === null || _c === void 0 ? void 0 : _c._id) === null || _d === void 0 ? void 0 : _d.toString();
+                        if (!collectionName || !docId) {
+                            return [2 /*return*/];
+                        }
+                        // Check if this operation type is ignored
+                        if (ignoredOps_1.has(change.operationType)) {
+                            return [2 /*return*/];
+                        }
+                        entry = (0, registry_1.findRegistryEntryByCollection)(collectionName);
+                        if (!entry) {
+                            // Not a registered realtime model — skip
+                            logDebug("[realtime] No registry entry for collection: ".concat(collectionName));
+                            return [2 /*return*/];
+                        }
+                        method = (0, exports.mapOperationType)(change.operationType, change, entry.config.methods);
+                        if (!method) {
+                            return [2 /*return*/];
+                        }
+                        // Check if this method is enabled for this model
+                        if (!entry.config.methods.includes(method)) {
+                            logDebug("[realtime] Method ".concat(method, " not enabled for ").concat(entry.modelName));
+                            return [2 /*return*/];
+                        }
+                        fullDocument = change.operationType === "delete" ? undefined : change.fullDocument;
+                        isHardDelete = method === "delete" && !fullDocument;
+                        rooms = void 0;
+                        if (isHardDelete) {
+                            // Hard delete: no fullDocument, so we can't resolve owner/custom rooms.
+                            // For owner strategy we cannot safely fan out to a model room without
+                            // leaking deletes across users — admins still receive the event via the
+                            // admin room and any document-specific subscribers via document rooms.
+                            if (entry.config.roomStrategy === "owner") {
+                                rooms = ["admin"];
+                            }
+                            else if (entry.config.roomStrategy === "broadcast") {
+                                rooms = ["authenticated"];
+                            }
+                            else {
+                                collectionTag = getCollectionTag(entry.routePath);
+                                rooms = ["model:".concat(collectionTag)];
+                            }
+                        }
+                        else {
+                            rooms = (0, exports.resolveRooms)(entry, fullDocument, method);
+                        }
+                        collection = getCollectionTag(entry.routePath);
+                        event_1 = __assign({ collection: collection, id: docId, method: method, model: entry.modelName, timestamp: luxon_1.DateTime.now().toMillis() }, (change.operationType === "update" && ((_e = change.updateDescription) === null || _e === void 0 ? void 0 : _e.updatedFields)
+                            ? { updatedFields: Object.keys(change.updateDescription.updatedFields) }
+                            : {}));
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 6, 7, 8]);
+                        rooms_1 = __values(rooms), rooms_1_1 = rooms_1.next();
+                        _f.label = 2;
+                    case 2:
+                        if (!!rooms_1_1.done) return [3 /*break*/, 5];
+                        room = rooms_1_1.value;
+                        return [4 /*yield*/, (0, exports.emitToAuthorizedRoom)(io, room, event_1, entry, fullDocument, logDebug)];
+                    case 3:
+                        _f.sent();
+                        _f.label = 4;
+                    case 4:
+                        rooms_1_1 = rooms_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_4_1 = _f.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (rooms_1_1 && !rooms_1_1.done && (_a = rooms_1.return)) _a.call(rooms_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 8: 
+                    // Emit to document-specific and query rooms
+                    return [4 /*yield*/, (0, exports.emitToDocumentAndQueryRooms)(io, collection, event_1, fullDocument, logDebug, entry)];
+                    case 9:
+                        // Emit to document-specific and query rooms
+                        _f.sent();
+                        logDebug("[realtime] Emitted ".concat(method, " for ").concat(entry.modelName, "/").concat(docId, " to rooms: ").concat(rooms.join(", ")));
+                        metadata = {
+                            collection: event_1.collection,
+                            id: event_1.id,
+                            method: event_1.method,
+                            model: event_1.model,
+                            timestamp: event_1.timestamp,
+                        };
+                        if (event_1.updatedFields) {
+                            metadata.updatedFields = event_1.updatedFields;
+                        }
+                        logInfo("[realtime] sync event: ".concat(JSON.stringify(metadata)));
+                        return [3 /*break*/, 11];
+                    case 10:
+                        error_4 = _f.sent();
+                        logger_1.logger.error("[realtime] Error processing change event: ".concat(error_4));
+                        Sentry.captureException(error_4);
+                        return [3 /*break*/, 11];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        }); });
+        changeWatcher.on("error", function (err) {
+            Sentry.captureException(err);
+            logger_1.logger.error("[realtime] Change stream error: ".concat((err === null || err === void 0 ? void 0 : err.message) || err));
+        });
+        changeWatcher.on("close", function () {
+            logger_1.logger.warn("[realtime] Change stream closed");
+        });
+        changeWatcher.on("end", function () {
+            logger_1.logger.warn("[realtime] Change stream ended");
+        });
+        logInfo("[realtime] Change stream watcher initialized successfully");
+    }
+    catch (error) {
+        logger_1.logger.error("[realtime] Failed to initialize change stream watcher: ".concat(error));
+        Sentry.captureException(error);
+        throw error;
+    }
+};
+exports.startChangeStreamWatcher = startChangeStreamWatcher;
+/**
+ * Stop the change stream watcher.
+ */
+var stopChangeStreamWatcher = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!changeWatcher) return [3 /*break*/, 2];
+                return [4 /*yield*/, changeWatcher.close()];
+            case 1:
+                _a.sent();
+                changeWatcher = null;
+                _a.label = 2;
+            case 2: return [2 /*return*/];
+        }
+    });
+}); };
+exports.stopChangeStreamWatcher = stopChangeStreamWatcher;