@terreno/api 0.14.0 → 0.14.2

package/dist/__tests__/versionCheckPlugin.test.js

@@ -291,6 +291,65 @@ var versionCheckPlugin_1 = require("../versionCheckPlugin");
             }
         });
     }); });
+    (0, bun_test_1.it)("handles numeric version parameter directly", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 100,
+                        webWarningVersion: 150,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check?version=50&platform=web")];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body.status).toBe("required");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns default warning message when warningMessage not set", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 0,
+                        webWarningVersion: 100,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 50 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body.status).toBe("warning");
+                    (0, bun_test_1.expect)(res.body.message).toBe("A new version is available. Please update for the best experience.");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns default required message when requiredMessage not set", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 100,
+                        webWarningVersion: 150,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 50 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body.status).toBe("required");
+                    (0, bun_test_1.expect)(res.body.message).toBe("This version is no longer supported. Please update to continue.");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     (0, bun_test_1.it)("version equal to required returns warning not required", function () { return __awaiter(void 0, void 0, void 0, function () {
         var res;
         return __generator(this, function (_a) {
@@ -310,4 +369,64 @@ var versionCheckPlugin_1 = require("../versionCheckPlugin");
             }
         });
     }); });
+    (0, bun_test_1.it)("uses default messages when warningMessage/requiredMessage are not set", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var warningRes, requiredRes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 100,
+                        webWarningVersion: 200,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 150 })];
+                case 2:
+                    warningRes = _a.sent();
+                    (0, bun_test_1.expect)(warningRes.body.status).toBe("warning");
+                    (0, bun_test_1.expect)(warningRes.body.message).toBe("A new version is available. Please update for the best experience.");
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 50 })];
+                case 3:
+                    requiredRes = _a.sent();
+                    (0, bun_test_1.expect)(requiredRes.body.status).toBe("required");
+                    (0, bun_test_1.expect)(requiredRes.body.message).toBe("This version is no longer supported. Please update to continue.");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("handles numeric version parameter", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, app.get("/version-check?version=50&platform=web")];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("VersionCheckPlugin direct usage", function () {
+    (0, bun_test_1.it)("can be instantiated and register called directly on an express app", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var express, plugin, expressApp, testApp, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    express = require("express");
+                    plugin = new versionCheckPlugin_1.VersionCheckPlugin();
+                    (0, bun_test_1.expect)(plugin).toBeDefined();
+                    (0, bun_test_1.expect)(plugin).toBeInstanceOf(versionCheckPlugin_1.VersionCheckPlugin);
+                    (0, bun_test_1.expect)(typeof plugin.register).toBe("function");
+                    expressApp = express();
+                    plugin.register(expressApp);
+                    testApp = (0, supertest_1.default)(expressApp);
+                    return [4 /*yield*/, testApp.get("/version-check")];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body.status).toBe("ok");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/dist/betterAuthSetup.js

@@ -61,6 +61,7 @@ var better_auth_1 = require("better-auth");
 var mongodb_1 = require("better-auth/adapters/mongodb");
 var node_1 = require("better-auth/node");
 var mongoose_1 = __importDefault(require("mongoose"));
+var errors_1 = require("./errors");
 var logger_1 = require("./logger");
 var plugins_1 = require("./plugins");
 var requestContext_1 = require("./requestContext");
@@ -72,11 +73,17 @@ var createBetterAuth = function (options) {
     var config = options.config, mongoClient = options.mongoClient;
     var secret = config.secret || process.env.BETTER_AUTH_SECRET;
     if (!secret) {
-        throw new Error("BETTER_AUTH_SECRET must be set in env or config.secret must be provided.");
+        throw new errors_1.APIError({
+            status: 500,
+            title: "BETTER_AUTH_SECRET must be set in env or config.secret must be provided.",
+        });
     }
     var baseURL = config.baseURL || process.env.BETTER_AUTH_URL;
     if (!baseURL) {
-        throw new Error("BETTER_AUTH_URL must be set in env or config.baseURL must be provided.");
+        throw new errors_1.APIError({
+            status: 500,
+            title: "BETTER_AUTH_URL must be set in env or config.baseURL must be provided.",
+        });
     }
     var basePath = (_a = config.basePath) !== null && _a !== void 0 ? _a : "/api/auth";
     var socialProviders = {};
@@ -258,7 +265,10 @@ var getMongoClientFromMongoose = function () {
     var connection = mongoose_1.default.connection;
     var client = connection.client;
     if (!client) {
-        throw new Error("Mongoose is not connected. Ensure MongoDB connection is established first.");
+        throw new errors_1.APIError({
+            status: 500,
+            title: "Mongoose is not connected. Ensure MongoDB connection is established first.",
+        });
     }
     return client;
 };

package/dist/config.js

@@ -70,6 +70,7 @@ var __values = (this && this.__values) || function(o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = void 0;
+var errors_1 = require("./errors");
 var overrides = new Map();
 var cachedEnv = null;
 var envLoader = null;
@@ -83,7 +84,7 @@ var REGISTRY = Object.create(null);
 var register = function (key, registration) {
     if (registration === void 0) { registration = {}; }
     if (REGISTRY[key]) {
-        throw new Error("Config key \"".concat(key, "\" registered more than once"));
+        throw new errors_1.APIError({ status: 500, title: "Config key \"".concat(key, "\" registered more than once") });
     }
     REGISTRY[key] = registration;
 };
@@ -124,7 +125,11 @@ var getNumber = function (key) {
     // whereas parseFloat would silently truncate to 5000.
     var parsed = Number(raw);
     if (!Number.isFinite(parsed)) {
-        throw new Error("Config key \"".concat(key, "\" is not a valid number: ").concat(JSON.stringify(raw)));
+        throw new errors_1.APIError({
+            error: new Error("Config key \"".concat(key, "\" is not a valid number: ").concat(JSON.stringify(raw))),
+            status: 500,
+            title: "Config key \"".concat(key, "\" is not a valid number"),
+        });
     }
     return parsed;
 };
@@ -150,7 +155,11 @@ var getJSON = function (key) {
         return JSON.parse(raw);
     }
     catch (error) {
-        throw new Error("Config key \"".concat(key, "\" is not valid JSON: ").concat(error.message));
+        throw new errors_1.APIError({
+            error: new Error("Config key \"".concat(key, "\" is not valid JSON: ").concat(error.message)),
+            status: 500,
+            title: "Config key \"".concat(key, "\" is not valid JSON"),
+        });
     }
 };
 /**

package/dist/errors.js

@@ -150,7 +150,10 @@ var errorsPlugin = function (schema) {
             about: { description: "Link to documentation about this error", type: String },
             type: { description: "Link describing the error type", type: String },
         },
-        meta: { description: "Non-standard meta information about the error", type: mongoose_1.Schema.Types.Mixed },
+        meta: {
+            description: "Non-standard meta information about the error",
+            type: mongoose_1.Schema.Types.Mixed,
+        },
         source: {
             header: { description: "HTTP header that caused the error", type: String },
             parameter: { description: "Query parameter that caused the error", type: String },
@@ -161,7 +164,7 @@ var errorsPlugin = function (schema) {
         },
         status: { description: "HTTP status code for this error", type: Number },
         title: { description: "Short summary of the error", required: true, type: String },
-    });
+    }, { _id: false, strict: "throw" });
     schema.add({ apiErrors: errorSchema });
 };
 exports.errorsPlugin = errorsPlugin;

package/dist/example.js

@@ -71,6 +71,9 @@ var userSchema = new mongoose_1.Schema({
 // biome-ignore lint/suspicious/noExplicitAny: passport-local-mongoose's plugin type is incompatible with mongoose Schema generics
 userSchema.plugin(passport_local_mongoose_1.default, { usernameField: "email" });
 userSchema.plugin(plugins_1.createdUpdatedPlugin);
+userSchema.plugin(plugins_1.isDeletedPlugin);
+userSchema.plugin(plugins_1.findOneOrNone);
+userSchema.plugin(plugins_1.findExactlyOne);
 userSchema.plugin(plugins_1.baseUserPlugin);
 var UserModel = (0, mongoose_1.model)("User", userSchema);
 var schema = new mongoose_1.Schema({

package/dist/expressServer.test.js

@@ -10,6 +10,39 @@ var __assign = (this && this.__assign) || function () {
     };
     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) {
@@ -965,6 +998,204 @@ var tests_1 = require("./tests");
                 }
             });
         }); });
+        (0, bun_test_1.it)("fires warning timeout callback when script is slow", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var func, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        func = (0, bun_test_1.mock)(function () { return new Promise(function (resolve) { return originalSetTimeout(function () { return resolve("done"); }, 200); }); });
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, (0, expressServer_1.wrapScript)(func, { terminateTimeout: 0.3 })];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        (0, bun_test_1.expect)(process.exit).toHaveBeenCalledWith(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, bun_test_1.describe)("setupServer with listen (skipListen false)", function () {
+        var originalEnv = process.env;
+        (0, bun_test_1.beforeEach)(function () {
+            process.env = __assign(__assign({}, originalEnv), { PORT: "0", REFRESH_TOKEN_SECRET: "test-refresh-secret", SESSION_SECRET: "test-session-secret", TOKEN_EXPIRES_IN: "1h", TOKEN_ISSUER: "test-issuer", TOKEN_SECRET: "test-secret" });
+        });
+        (0, bun_test_1.afterEach)(function () {
+            process.env = originalEnv;
+        });
+        (0, bun_test_1.it)("starts the server when skipListen is false", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var addRoutes, express, originalListen, app;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        addRoutes = function () { };
+                        return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("express")); })];
+                    case 1:
+                        express = _a.sent();
+                        originalListen = express.default.application.listen;
+                        // biome-ignore lint/suspicious/noExplicitAny: mocking Express internals requires type escape
+                        express.default.application.listen = (0, bun_test_1.mock)(function () {
+                            var args = [];
+                            for (var _i = 0; _i < arguments.length; _i++) {
+                                args[_i] = arguments[_i];
+                            }
+                            var cb = args.find(function (a) { return typeof a === "function"; });
+                            if (cb) {
+                                cb();
+                            }
+                            return this;
+                        });
+                        try {
+                            app = (0, expressServer_1.setupServer)({
+                                addRoutes: addRoutes,
+                                skipListen: false,
+                                userModel: tests_1.UserModel,
+                            });
+                            (0, bun_test_1.expect)(app).toBeDefined();
+                        }
+                        finally {
+                            express.default.application.listen = originalListen;
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("handles listen error with invalid port", function () {
+            process.env.PORT = "-1";
+            var addRoutes = function () { };
+            // Using an invalid port should trigger the catch block and process.exit(1)
+            var originalExit = process.exit;
+            process.exit = (function () { });
+            try {
+                (0, expressServer_1.setupServer)({
+                    addRoutes: addRoutes,
+                    skipListen: false,
+                    userModel: tests_1.UserModel,
+                });
+            }
+            catch (_a) {
+                // May throw
+            }
+            process.exit = originalExit;
+        });
+    });
+    (0, bun_test_1.describe)("setupServer with listen", function () {
+        var originalEnv = process.env;
+        var http = require("node:http");
+        var activeServer = null;
+        var originalListen = null;
+        (0, bun_test_1.beforeEach)(function () {
+            process.env = __assign(__assign({}, originalEnv), { PORT: "0", REFRESH_TOKEN_SECRET: "test-refresh-secret", SESSION_SECRET: "test-session-secret", TOKEN_EXPIRES_IN: "1h", TOKEN_ISSUER: "test-issuer", TOKEN_SECRET: "test-secret" });
+            originalListen = http.Server.prototype.listen;
+            http.Server.prototype.listen = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                activeServer = this;
+                return originalListen.apply(this, args);
+            };
+        });
+        (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        process.env = originalEnv;
+                        http.Server.prototype.listen = originalListen;
+                        if (!activeServer) return [3 /*break*/, 2];
+                        return [4 /*yield*/, new Promise(function (resolve) { return activeServer.close(function () { return resolve(); }); })];
+                    case 1:
+                        _a.sent();
+                        activeServer = null;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("starts listening on a port when skipListen is false", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var addRoutes, app;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        addRoutes = function () { };
+                        app = (0, expressServer_1.setupServer)({
+                            addRoutes: addRoutes,
+                            skipListen: false,
+                            userModel: tests_1.UserModel,
+                        });
+                        (0, bun_test_1.expect)(app).toBeDefined();
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, bun_test_1.describe)("wrapScript timeout callbacks", function () {
+        var originalEnv = process.env;
+        var originalExit = process.exit;
+        var originalSetTimeout = globalThis.setTimeout;
+        var timerIds = [];
+        var timerCallbacks = [];
+        (0, bun_test_1.beforeEach)(function () {
+            process.env = __assign(__assign({}, process.env), { REFRESH_TOKEN_SECRET: "test-refresh-secret", SESSION_SECRET: "test-session-secret", TOKEN_EXPIRES_IN: "1h", TOKEN_ISSUER: "test-issuer", TOKEN_SECRET: "test-secret" });
+            process.exit = (0, bun_test_1.mock)(function () {
+                throw new Error("__EXIT__");
+            });
+            timerCallbacks.length = 0;
+            timerIds.length = 0;
+            globalThis.setTimeout = (function (cb, delay) {
+                timerCallbacks.push({ callback: cb, delay: delay });
+                var id = originalSetTimeout(cb, delay);
+                timerIds.push(id);
+                return id;
+            });
+        });
+        (0, bun_test_1.afterEach)(function () {
+            var e_2, _a;
+            try {
+                for (var timerIds_2 = __values(timerIds), timerIds_2_1 = timerIds_2.next(); !timerIds_2_1.done; timerIds_2_1 = timerIds_2.next()) {
+                    var id = timerIds_2_1.value;
+                    clearTimeout(id);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (timerIds_2_1 && !timerIds_2_1.done && (_a = timerIds_2.return)) _a.call(timerIds_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            globalThis.setTimeout = originalSetTimeout;
+            process.exit = originalExit;
+            process.env = originalEnv;
+        });
+        (0, bun_test_1.it)("registers warn and terminate timeouts with correct delays", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var func, warnTimer, closeTimer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        func = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, "ok"];
+                        }); }); };
+                        return [4 /*yield*/, (0, bun_test_1.expect)((0, expressServer_1.wrapScript)(func, { terminateTimeout: 100 })).rejects.toThrow("__EXIT__")];
+                    case 1:
+                        _a.sent();
+                        warnTimer = timerCallbacks.find(function (t) { return t.delay === 50000; });
+                        closeTimer = timerCallbacks.find(function (t) { return t.delay === 100000; });
+                        (0, bun_test_1.expect)(warnTimer).toBeDefined();
+                        (0, bun_test_1.expect)(closeTimer).toBeDefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     (0, bun_test_1.describe)("setupServer error handling", function () {
         var originalEnv = process.env;

package/dist/realtime/changeStreamWatcher.js

@@ -124,6 +124,7 @@ exports.stopChangeStreamWatcher = exports.startChangeStreamWatcher = exports.emi
 var Sentry = __importStar(require("@sentry/bun"));
 var luxon_1 = require("luxon");
 var mongoose_1 = __importDefault(require("mongoose"));
+var errors_1 = require("../errors");
 var logger_1 = require("../logger");
 var permissions_1 = require("../permissions");
 var queryMatcher_1 = require("./queryMatcher");
@@ -546,7 +547,10 @@ var startChangeStreamWatcher = function (io, config, debug) {
         ];
         var nativeDb = mongoose_1.default.connection.db;
         if (!nativeDb) {
-            throw new Error("MongoDB connection not available for change stream");
+            throw new errors_1.APIError({
+                status: 500,
+                title: "MongoDB connection not available for change stream",
+            });
         }
         var options = {
             batchSize: (_c = config.batchSize) !== null && _c !== void 0 ? _c : 50,
@@ -558,7 +562,7 @@ var startChangeStreamWatcher = function (io, config, debug) {
         };
         changeWatcher = nativeDb.watch(pipeline, options);
         if (!changeWatcher) {
-            throw new Error("Failed to create change stream watcher");
+            throw new errors_1.APIError({ status: 500, title: "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;