@terreno/api 0.14.1 → 0.15.0

package/dist/realtime/realtime.test.js

@@ -125,12 +125,24 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var bun_test_1 = require("bun:test");
 var express_1 = __importDefault(require("express"));
+var mongoose_1 = __importDefault(require("mongoose"));
 var changeStreamWatcher_1 = require("./changeStreamWatcher");
 var queryMatcher_1 = require("./queryMatcher");
 var queryStore_1 = require("./queryStore");
@@ -2141,6 +2153,868 @@ var createMockSocket = function (decodedToken) {
 // redactCredentials — Redis URL logging
 // ─────────────────────────────────────────────────────────────────────────────
 // ─────────────────────────────────────────────────────────────────────────────
+// startChangeStreamWatcher / stopChangeStreamWatcher — MongoDB change stream
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("startChangeStreamWatcher", function () {
+    var originalDb;
+    (0, bun_test_1.beforeEach)(function () {
+        originalDb = mongoose_1.default.connection.db;
+        (0, registry_1.clearRealtimeRegistry)();
+    });
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var stop;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mongoose_1.default.connection.db = originalDb;
+                    (0, registry_1.clearRealtimeRegistry)();
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    stop = (_a.sent()).stopChangeStreamWatcher;
+                    return [4 /*yield*/, stop()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    var createMockChangeStream = function () {
+        var listeners = new Map();
+        return {
+            close: (0, bun_test_1.mock)(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/];
+            }); }); }),
+            listeners: listeners,
+            on: function (event, handler) {
+                listeners.set(event, handler);
+                return this;
+            },
+            trigger: function (event) {
+                var args = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    args[_i - 1] = arguments[_i];
+                }
+                var handler = listeners.get(event);
+                if (handler) {
+                    handler.apply(void 0, __spreadArray([], __read(args), false));
+                }
+            },
+        };
+    };
+    var createMockIo = function () {
+        var rooms = new Map();
+        var sockets = new Map();
+        return {
+            sockets: {
+                adapter: { rooms: rooms },
+                sockets: sockets,
+            },
+            to: function (_room) { return ({
+                emit: function (_event, _data) { },
+            }); },
+        };
+    };
+    (0, bun_test_1.it)("initializes and registers change/error/close/end listeners", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    (0, bun_test_1.expect)(mockDb.watch).toHaveBeenCalled();
+                    (0, bun_test_1.expect)(mockStream.listeners.has("change")).toBe(true);
+                    (0, bun_test_1.expect)(mockStream.listeners.has("error")).toBe(true);
+                    (0, bun_test_1.expect)(mockStream.listeners.has("close")).toBe(true);
+                    (0, bun_test_1.expect)(mockStream.listeners.has("end")).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("throws when mongoose connection db is unavailable", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mongoose_1.default.connection.db = undefined;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    (0, bun_test_1.expect)(function () { return startChangeStreamWatcher(io); }).toThrow("MongoDB connection not available for change stream");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("throws when watch returns null", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockDb, startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return null; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    (0, bun_test_1.expect)(function () { return startChangeStreamWatcher(io); }).toThrow("Failed to create change stream watcher");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles change events for registered models", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    (0, bun_test_1.expect)(changeHandler).toBeDefined();
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Test Todo" },
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips events for unregistered collections", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Trigger for an unregistered collection — should not throw
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1" },
+                            ns: { coll: "unknown_collection" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // Trigger for an unregistered collection — should not throw
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips events when method is not enabled for the model", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create"], // only create enabled
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Update event should be skipped because "update" not in methods
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Updated" },
+                            ns: { coll: "todos" },
+                            operationType: "update",
+                            updateDescription: { updatedFields: { name: "Updated" } },
+                        })];
+                case 2:
+                    // Update event should be skipped because "update" not in methods
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles delete events for owner-strategy models", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "owner",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Hard delete (no fullDocument)
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            ns: { coll: "todos" },
+                            operationType: "delete",
+                        })];
+                case 2:
+                    // Hard delete (no fullDocument)
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles delete events for broadcast-strategy models", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "broadcasts",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "broadcast",
+                        },
+                        modelName: "Broadcast",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/broadcasts",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Hard delete for broadcast strategy
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            ns: { coll: "broadcasts" },
+                            operationType: "delete",
+                        })];
+                case 2:
+                    // Hard delete for broadcast strategy
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("includes updatedFields in event for update operations", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Updated", status: "done" },
+                            ns: { coll: "todos" },
+                            operationType: "update",
+                            updateDescription: { updatedFields: { name: "Updated", status: "done" } },
+                        })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("respects ignoredCollections config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, pipeline, matchStage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, { ignoredCollections: ["audit_logs"] }, true);
+                    pipeline = mockDb.watch.mock.calls[0][0];
+                    matchStage = pipeline[0].$match;
+                    (0, bun_test_1.expect)(matchStage["ns.coll"].$nin).toContain("audit_logs");
+                    (0, bun_test_1.expect)(matchStage["ns.coll"].$nin).toContain("socketio");
+                    (0, bun_test_1.expect)(matchStage["ns.coll"].$nin).toContain("sessions");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("respects ignoredOperations config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [function () { return true; }],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, { ignoredOperations: ["insert"] }, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // This insert should be skipped because "insert" is ignored
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1" },
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // This insert should be skipped because "insert" is ignored
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips events with no collectionName or docId", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Missing ns.coll
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            ns: {},
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // Missing ns.coll
+                    _a.sent();
+                    // Missing documentKey
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: {},
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 3:
+                    // Missing documentKey
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("skips non-CRUD operation types", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // "drop" is not in our pipeline filter, should be skipped
+                    return [4 /*yield*/, changeHandler({
+                            operationType: "drop",
+                        })];
+                case 2:
+                    // "drop" is not in our pipeline filter, should be skipped
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles error/close/end events gracefully", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, {}, true);
+                    // Trigger error, close, end — should not throw
+                    mockStream.trigger("error", new Error("test error"));
+                    mockStream.trigger("close");
+                    mockStream.trigger("end");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("uses custom batchSize and fullDocument config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, io, options;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    io = createMockIo();
+                    startChangeStreamWatcher(io, { batchSize: 100, fullDocument: "whenAvailable" }, true);
+                    options = mockDb.watch.mock.calls[0][1];
+                    (0, bun_test_1.expect)(options.batchSize).toBe(100);
+                    (0, bun_test_1.expect)(options.fullDocument).toBe("whenAvailable");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("catches errors thrown in the change handler", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, startChangeStreamWatcher, emissions, mockSocket, rooms, sockets, io, changeHandler;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStream = createMockChangeStream();
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    mongoose_1.default.connection.db = mockDb;
+                    // Register with a model that will throw during permission check
+                    (0, registry_1.registerRealtime)({
+                        collectionName: "todos",
+                        config: {
+                            methods: ["create", "update", "delete"],
+                            roomStrategy: "model",
+                        },
+                        modelName: "Todo",
+                        options: {
+                            permissions: {
+                                create: [function () { return true; }],
+                                delete: [function () { return true; }],
+                                list: [function () { return true; }],
+                                read: [
+                                    function () {
+                                        throw new Error("permission check error");
+                                    },
+                                ],
+                                update: [function () { return true; }],
+                            },
+                        },
+                        routePath: "/todos",
+                    });
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    startChangeStreamWatcher = (_a.sent()).startChangeStreamWatcher;
+                    emissions = [];
+                    mockSocket = {
+                        decodedToken: { id: "user-1" },
+                        emit: function (_event, _data) {
+                            emissions.push({ _data: _data, _event: _event });
+                        },
+                        id: "sock-1",
+                    };
+                    rooms = new Map();
+                    rooms.set("model:todos", new Set(["sock-1"]));
+                    sockets = new Map();
+                    sockets.set("sock-1", mockSocket);
+                    io = {
+                        sockets: {
+                            adapter: { rooms: rooms },
+                            sockets: sockets,
+                        },
+                        to: function () { return ({ emit: function () { } }); },
+                    };
+                    startChangeStreamWatcher(io, {}, true);
+                    changeHandler = mockStream.listeners.get("change");
+                    // Should not throw even though permission check throws
+                    return [4 /*yield*/, changeHandler({
+                            documentKey: { _id: "doc-1" },
+                            fullDocument: { _id: "doc-1", name: "Test" },
+                            ns: { coll: "todos" },
+                            operationType: "insert",
+                        })];
+                case 2:
+                    // Should not throw even though permission check throws
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("stopChangeStreamWatcher", function () {
+    (0, bun_test_1.it)("closes and nullifies the active watcher", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStream, mockDb, originalDb, _a, startChangeStreamWatcher, stopChangeStreamWatcher, io;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    mockStream = {
+                        close: (0, bun_test_1.mock)(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }),
+                        on: function () { },
+                    };
+                    mockDb = {
+                        watch: (0, bun_test_1.mock)(function () { return mockStream; }),
+                    };
+                    originalDb = mongoose_1.default.connection.db;
+                    mongoose_1.default.connection.db = mockDb;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("./changeStreamWatcher")); })];
+                case 1:
+                    _a = _b.sent(), startChangeStreamWatcher = _a.startChangeStreamWatcher, stopChangeStreamWatcher = _a.stopChangeStreamWatcher;
+                    io = {
+                        sockets: {
+                            adapter: { rooms: new Map() },
+                            sockets: new Map(),
+                        },
+                        to: function () { return ({ emit: function () { } }); },
+                    };
+                    startChangeStreamWatcher(io);
+                    return [4 /*yield*/, stopChangeStreamWatcher()];
+                case 2:
+                    _b.sent();
+                    (0, bun_test_1.expect)(mockStream.close).toHaveBeenCalled();
+                    // Calling again should be a no-op
+                    return [4 /*yield*/, stopChangeStreamWatcher()];
+                case 3:
+                    // Calling again should be a no-op
+                    _b.sent();
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// RealtimeApp.onServerCreated / setupAdapter
+// ─────────────────────────────────────────────────────────────────────────────
+(0, bun_test_1.describe)("RealtimeApp.onServerCreated", function () {
+    var servers = [];
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var servers_1, servers_1_1, s;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            try {
+                for (servers_1 = __values(servers), servers_1_1 = servers_1.next(); !servers_1_1.done; servers_1_1 = servers_1.next()) {
+                    s = servers_1_1.value;
+                    s.close();
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (servers_1_1 && !servers_1_1.done && (_a = servers_1.return)) _a.call(servers_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            servers.length = 0;
+            return [2 /*return*/];
+        });
+    }); });
+    var makeServer = function () {
+        var http = require("http");
+        var server = http.createServer();
+        servers.push(server);
+        return server;
+    };
+    (0, bun_test_1.it)("throws when TOKEN_SECRET is missing", function () {
+        var originalSecret = process.env.TOKEN_SECRET;
+        process.env.TOKEN_SECRET = "";
+        var app = new realtimeApp_1.RealtimeApp({ tokenSecret: undefined });
+        var server = makeServer();
+        (0, bun_test_1.expect)(function () { return app.onServerCreated(server); }).toThrow("TOKEN_SECRET is required");
+        process.env.TOKEN_SECRET = originalSecret;
+    });
+    (0, bun_test_1.it)("sets up Socket.io with valid config", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var app, server, originalDb, mockStream;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "none",
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    originalDb = mongoose_1.default.connection.db;
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).toBeDefined();
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("RealtimeApp.setupAdapter (private, via onServerCreated config)", function () {
+    var servers = [];
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var servers_2, servers_2_1, s;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            try {
+                for (servers_2 = __values(servers), servers_2_1 = servers_2.next(); !servers_2_1.done; servers_2_1 = servers_2.next()) {
+                    s = servers_2_1.value;
+                    s.close();
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (servers_2_1 && !servers_2_1.done && (_a = servers_2.return)) _a.call(servers_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            servers.length = 0;
+            return [2 /*return*/];
+        });
+    }); });
+    var makeServer = function () {
+        var http = require("http");
+        var server = http.createServer();
+        servers.push(server);
+        return server;
+    };
+    (0, bun_test_1.it)("logs warning when redis adapter requested but no URL found", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var originalValkey, originalRedis, originalDb, mockStream, app, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    originalValkey = process.env.VALKEY_URL;
+                    originalRedis = process.env.REDIS_URL;
+                    originalDb = mongoose_1.default.connection.db;
+                    process.env.VALKEY_URL = "";
+                    process.env.REDIS_URL = "";
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "redis",
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    app.onServerCreated(server);
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    process.env.VALKEY_URL = originalValkey;
+                    process.env.REDIS_URL = originalRedis;
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("logs info when redis adapter has a URL", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var originalValkey, originalDb, mockStream, app, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    originalValkey = process.env.VALKEY_URL;
+                    originalDb = mongoose_1.default.connection.db;
+                    process.env.VALKEY_URL = "redis://user:pass@localhost:6379/0";
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "redis",
+                        debug: true,
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    app.onServerCreated(server);
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    process.env.VALKEY_URL = originalValkey;
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("no-op adapter mode 'none'", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var originalDb, mockStream, app, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    originalDb = mongoose_1.default.connection.db;
+                    mockStream = { close: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/];
+                        }); }); }, on: function () { return mockStream; } };
+                    mongoose_1.default.connection.db = { watch: function () { return mockStream; } };
+                    app = new realtimeApp_1.RealtimeApp({
+                        adapter: "none",
+                        tokenSecret: "test-secret",
+                    });
+                    server = makeServer();
+                    app.onServerCreated(server);
+                    (0, bun_test_1.expect)(app.getIo()).toBeDefined();
+                    return [4 /*yield*/, app.close()];
+                case 1:
+                    _a.sent();
+                    mongoose_1.default.connection.db = originalDb;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// ─────────────────────────────────────────────────────────────────────────────
 // ensureApiId
 // ─────────────────────────────────────────────────────────────────────────────
 (0, bun_test_1.describe)("ensureApiId", function () {
@@ -2278,13 +3152,13 @@ var createMockSocket = function (decodedToken) {
 // Change streams require a MongoDB replica set. CI (api-ci.yml) runs standalone MongoDB,
 // so these tests are skipped when replica sets are not available.
 var hasReplicaSet = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var mongoose, admin, status_1, _a;
+    var mongoose_2, admin, status_1, _a;
     return __generator(this, function (_b) {
         switch (_b.label) {
             case 0:
                 _b.trys.push([0, 2, , 3]);
-                mongoose = require("mongoose");
-                admin = mongoose.connection.db.admin();
+                mongoose_2 = require("mongoose");
+                admin = mongoose_2.connection.db.admin();
                 return [4 /*yield*/, admin.command({ replSetGetStatus: 1 })];
             case 1:
                 status_1 = _b.sent();
@@ -3048,6 +3922,9 @@ var hasReplicaSet = function () { return __awaiter(void 0, void 0, void 0, funct
         });
     }); });
 });
+// ─────────────────────────────────────────────────────────────────────────────
+// redactCredentials — Redis URL logging
+// ─────────────────────────────────────────────────────────────────────────────
 (0, bun_test_1.describe)("redactCredentials", function () {
     (0, bun_test_1.it)("redacts user:password@ in a redis URL", function () {
         (0, bun_test_1.expect)((0, realtimeApp_1.redactCredentials)("redis://user:secret@host:6379/0")).toBe("redis://***@host:6379/0");