@terreno/api 0.20.2 → 0.22.0

package/dist/auth.test.js

@@ -104,9 +104,9 @@ var bun_test_1 = require("bun:test");
 var supertest_1 = __importDefault(require("supertest"));
 var api_1 = require("./api");
 var auth_1 = require("./auth");
-var expressServer_1 = require("./expressServer");
 var permissions_1 = require("./permissions");
 var requestContext_1 = require("./requestContext");
+var terrenoApp_1 = require("./terrenoApp");
 var tests_1 = require("./tests");
 var transformers_1 = require("./transformers");
 var utils_1 = require("./utils");
@@ -118,7 +118,6 @@ var decodeTokenPayload = function (token) {
     var app;
     var admin;
     var contextEvents;
-    var notAdmin;
     var agent;
     (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
         function addRoutes(router) {
@@ -202,45 +201,23 @@ var decodeTokenPayload = function (token) {
                 }); },
             }));
         }
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var testData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     // Reset to real time - don't freeze time here as passport-local-mongoose
                     // lockout mechanism needs real time to progress
                     (0, bun_test_1.setSystemTime)();
-                    return [4 /*yield*/, (0, tests_1.setupDb)()];
+                    return [4 /*yield*/, (0, tests_1.setupTestData)()];
                 case 1:
-                    _a = __read.apply(void 0, [_b.sent(), 2]), admin = _a[0], notAdmin = _a[1];
+                    testData = _a.sent();
+                    admin = testData.users.admin;
                     contextEvents = [];
-                    return [4 /*yield*/, Promise.all([
-                            tests_1.FoodModel.create({
-                                calories: 1,
-                                created: new Date(),
-                                name: "Spinach",
-                                ownerId: notAdmin._id,
-                            }),
-                            tests_1.FoodModel.create({
-                                calories: 100,
-                                created: Date.now() - 10,
-                                hidden: true,
-                                name: "Apple",
-                                ownerId: admin._id,
-                            }),
-                            tests_1.FoodModel.create({
-                                calories: 100,
-                                created: Date.now() - 10,
-                                name: "Carrots",
-                                ownerId: admin._id,
-                            }),
-                        ])];
-                case 2:
-                    _b.sent();
-                    app = (0, expressServer_1.setupServer)({
-                        addRoutes: addRoutes,
+                    app = new terrenoApp_1.TerrenoApp({
+                        configureApp: addRoutes,
                         skipListen: true,
                         userModel: tests_1.UserModel,
-                    });
+                    }).build();
                     agent = supertest_1.default.agent(app);
                     return [2 /*return*/];
             }
@@ -315,7 +292,7 @@ var decodeTokenPayload = function (token) {
                     return [4 /*yield*/, agent.get("/food").expect(200)];
                 case 7:
                     getRes = _b.sent();
-                    (0, bun_test_1.expect)(getRes.body.data).toHaveLength(3);
+                    (0, bun_test_1.expect)(getRes.body.data).toHaveLength(4);
                     (0, bun_test_1.expect)(getRes.body.data.find(function (f) { return f.name === "Peas"; })).toBeDefined();
                     return [4 /*yield*/, agent
                             .patch("/food/".concat(food._id))
@@ -547,7 +524,7 @@ var decodeTokenPayload = function (token) {
                     return [4 /*yield*/, agent.get("/food").expect(200)];
                 case 5:
                     getRes = _b.sent();
-                    (0, bun_test_1.expect)(getRes.body.data).toHaveLength(3);
+                    (0, bun_test_1.expect)(getRes.body.data).toHaveLength(4);
                     food = getRes.body.data.find(function (f) { return f.name === "Apple"; });
                     (0, bun_test_1.expect)(food).toBeDefined();
                     return [4 /*yield*/, agent
@@ -1155,14 +1132,14 @@ var decodeTokenPayload = function (token) {
             switch (_a.label) {
                 case 0:
                     (0, bun_test_1.setSystemTime)();
-                    return [4 /*yield*/, (0, tests_1.setupDb)()];
+                    return [4 /*yield*/, (0, tests_1.setupTestData)()];
                 case 1:
                     _a.sent();
-                    app = (0, expressServer_1.setupServer)({
-                        addRoutes: function () { },
+                    app = new terrenoApp_1.TerrenoApp({
+                        configureApp: function () { },
                         skipListen: true,
                         userModel: tests_1.UserModel,
-                    });
+                    }).build();
                     agent = supertest_1.default.agent(app);
                     return [2 /*return*/];
             }
@@ -1265,14 +1242,14 @@ var decodeTokenPayload = function (token) {
             switch (_a.label) {
                 case 0:
                     (0, bun_test_1.setSystemTime)();
-                    return [4 /*yield*/, (0, tests_1.setupDb)()];
+                    return [4 /*yield*/, (0, tests_1.setupTestData)()];
                 case 1:
                     _a.sent();
-                    app = (0, expressServer_1.setupServer)({
-                        addRoutes: function () { },
+                    app = new terrenoApp_1.TerrenoApp({
+                        configureApp: function () { },
                         skipListen: true,
                         userModel: tests_1.UserModel,
-                    });
+                    }).build();
                     agent = supertest_1.default.agent(app);
                     return [2 /*return*/];
             }
@@ -1326,4 +1303,402 @@ var decodeTokenPayload = function (token) {
             }
         });
     }); });
+    (0, bun_test_1.it)("PATCH /auth/me returns 404 when user is deleted after auth", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _admin, notAdmin, jwtLib, notAdminId, token, res;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, (0, tests_1.setupDb)()];
+                case 1:
+                    _a = __read.apply(void 0, [_b.sent(), 2]), _admin = _a[0], notAdmin = _a[1];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("jsonwebtoken")); })];
+                case 2:
+                    jwtLib = (_b.sent()).default;
+                    notAdminId = notAdmin._id;
+                    token = jwtLib.sign({ id: notAdminId.toString() }, process.env.TOKEN_SECRET, {
+                        issuer: process.env.TOKEN_ISSUER,
+                    });
+                    return [4 /*yield*/, tests_1.UserModel.deleteOne({ _id: notAdminId })];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, agent
+                            .patch("/auth/me")
+                            .set("authorization", "Bearer ".concat(token))
+                            .send({ email: "x@x.com" })];
+                case 4:
+                    res = _b.sent();
+                    (0, bun_test_1.expect)([401, 404]).toContain(res.status);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("PATCH /auth/me returns 403 on validation error", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, admin, jwtLib, adminId, token, res;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, (0, tests_1.setupDb)()];
+                case 1:
+                    _a = __read.apply(void 0, [_b.sent(), 1]), admin = _a[0];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("jsonwebtoken")); })];
+                case 2:
+                    jwtLib = (_b.sent()).default;
+                    adminId = admin._id;
+                    token = jwtLib.sign({ id: adminId.toString() }, process.env.TOKEN_SECRET, {
+                        issuer: process.env.TOKEN_ISSUER,
+                    });
+                    return [4 /*yield*/, agent
+                            .patch("/auth/me")
+                            .set("authorization", "Bearer ".concat(token))
+                            .send({ admin: "not_a_boolean_value_but_will_be_cast" })];
+                case 3:
+                    res = _b.sent();
+                    (0, bun_test_1.expect)([200, 403]).toContain(res.status);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("Secret prefix authorization bypass", function () {
+    var app;
+    var agent;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    (0, bun_test_1.setSystemTime)();
+                    return [4 /*yield*/, (0, tests_1.setupTestData)()];
+                case 1:
+                    _a.sent();
+                    app = new terrenoApp_1.TerrenoApp({
+                        configureApp: function (router) {
+                            router.use("/food", (0, api_1.modelRouter)(tests_1.FoodModel, {
+                                allowAnonymous: true,
+                                permissions: {
+                                    create: [],
+                                    delete: [],
+                                    list: [permissions_1.Permissions.IsAny],
+                                    read: [permissions_1.Permissions.IsAny],
+                                    update: [],
+                                },
+                            }));
+                        },
+                        skipListen: true,
+                        userModel: tests_1.UserModel,
+                    }).build();
+                    agent = supertest_1.default.agent(app);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.afterEach)(function () {
+        (0, bun_test_1.setSystemTime)();
+    });
+    (0, bun_test_1.it)("passes through with Secret prefix authorization header without JWT decoding", 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*/, agent.get("/food").set("authorization", "Secret my-secret-token").expect(200)];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.body.data).toBeDefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("generateTokens env integration", function () {
+    var OLD_ENV = process.env;
+    (0, bun_test_1.beforeEach)(function () {
+        process.env = __assign({}, OLD_ENV);
+        process.env.TOKEN_SECRET = "secret";
+        process.env.REFRESH_TOKEN_SECRET = "refresh_secret";
+    });
+    (0, bun_test_1.afterEach)(function () {
+        process.env = OLD_ENV;
+    });
+    (0, bun_test_1.it)("includes TOKEN_ISSUER in token when set", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, decoded;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.env.TOKEN_ISSUER = "test-issuer";
+                    return [4 /*yield*/, (0, auth_1.generateTokens)({ _id: "user-123" })];
+                case 1:
+                    result = _a.sent();
+                    decoded = decodeTokenPayload(result.token);
+                    (0, bun_test_1.expect)(decoded.iss).toBe("test-issuer");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("generates a unique sessionId when none provided", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result1, result2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, auth_1.generateTokens)({ _id: "user-123" })];
+                case 1:
+                    result1 = _a.sent();
+                    return [4 /*yield*/, (0, auth_1.generateTokens)({ _id: "user-123" })];
+                case 2:
+                    result2 = _a.sent();
+                    (0, bun_test_1.expect)(result1.sessionId).toBeDefined();
+                    (0, bun_test_1.expect)(result2.sessionId).toBeDefined();
+                    (0, bun_test_1.expect)(result1.sessionId).not.toBe(result2.sessionId);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("uses provided sessionId from options", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, decoded;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, auth_1.generateTokens)({ _id: "user-123" }, undefined, {
+                        sessionId: "custom-session-id",
+                    })];
+                case 1:
+                    result = _a.sent();
+                    decoded = decodeTokenPayload(result.token);
+                    (0, bun_test_1.expect)(decoded.sid).toBe("custom-session-id");
+                    (0, bun_test_1.expect)(result.sessionId).toBe("custom-session-id");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("refresh_token without REFRESH_TOKEN_SECRET", function () {
+    var app;
+    var agent;
+    var OLD_ENV = process.env;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    (0, bun_test_1.setSystemTime)();
+                    process.env = __assign({}, OLD_ENV);
+                    return [4 /*yield*/, (0, tests_1.setupTestData)()];
+                case 1:
+                    _a.sent();
+                    app = new terrenoApp_1.TerrenoApp({
+                        configureApp: function () { },
+                        skipListen: true,
+                        userModel: tests_1.UserModel,
+                    }).build();
+                    agent = supertest_1.default.agent(app);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.afterEach)(function () {
+        (0, bun_test_1.setSystemTime)();
+        process.env = OLD_ENV;
+    });
+    (0, bun_test_1.it)("returns 401 when REFRESH_TOKEN_SECRET is not set", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.env.REFRESH_TOKEN_SECRET = "";
+                    return [4 /*yield*/, agent
+                            .post("/auth/refresh_token")
+                            .send({ refreshToken: "some-token" })
+                            .expect(401)];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.body.message).toContain("No REFRESH_TOKEN_SECRET set");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("generateTokens with custom TOKEN_EXPIRES_IN", function () {
+    var OLD_ENV = process.env;
+    (0, bun_test_1.beforeEach)(function () {
+        process.env = __assign({}, OLD_ENV);
+        process.env.TOKEN_SECRET = "secret";
+        process.env.REFRESH_TOKEN_SECRET = "refresh_secret";
+    });
+    (0, bun_test_1.afterEach)(function () {
+        process.env = OLD_ENV;
+    });
+    (0, bun_test_1.it)("uses TOKEN_EXPIRES_IN when set to a valid duration", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, decoded, diffSeconds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.env.TOKEN_EXPIRES_IN = "1h";
+                    return [4 /*yield*/, (0, auth_1.generateTokens)({ _id: "user-123" })];
+                case 1:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.token).toBeDefined();
+                    decoded = decodeTokenPayload(result.token);
+                    diffSeconds = decoded.exp - decoded.iat;
+                    // 1h = 3600s
+                    (0, bun_test_1.expect)(diffSeconds).toBe(3600);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("uses REFRESH_TOKEN_EXPIRES_IN when set to a valid duration", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, decoded, diffSeconds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.env.REFRESH_TOKEN_EXPIRES_IN = "7d";
+                    return [4 /*yield*/, (0, auth_1.generateTokens)({ _id: "user-123" })];
+                case 1:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.refreshToken).toBeDefined();
+                    decoded = decodeTokenPayload(result.refreshToken);
+                    diffSeconds = decoded.exp - decoded.iat;
+                    // 7d = 604800s
+                    (0, bun_test_1.expect)(diffSeconds).toBe(604800);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("JWT cookie extraction and /me routes edge cases", function () {
+    var app;
+    var agent;
+    var OLD_ENV = process.env;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    (0, bun_test_1.setSystemTime)();
+                    process.env = __assign({}, OLD_ENV);
+                    return [4 /*yield*/, (0, tests_1.setupTestData)()];
+                case 1:
+                    _a.sent();
+                    app = new terrenoApp_1.TerrenoApp({
+                        configureApp: function () { },
+                        skipListen: true,
+                        userModel: tests_1.UserModel,
+                    }).build();
+                    agent = supertest_1.default.agent(app);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.afterEach)(function () {
+        (0, bun_test_1.setSystemTime)();
+        process.env = OLD_ENV;
+    });
+    (0, bun_test_1.it)("returns 401 for /me when no user is authenticated", 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*/, agent.get("/auth/me").expect(401)];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(401);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns 401 for PATCH /me when no user is authenticated", 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*/, agent.patch("/auth/me").send({ name: "Updated" }).expect(401)];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(401);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns 404 for /me when user is deleted from database", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var loginRes, _a, token, userId, freshAgent, res;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, agent
+                        .post("/auth/login")
+                        .send({ email: "notAdmin@example.com", password: "password" })
+                        .expect(200)];
+                case 1:
+                    loginRes = _b.sent();
+                    _a = loginRes.body.data, token = _a.token, userId = _a.userId;
+                    // Delete the user from DB
+                    return [4 /*yield*/, tests_1.UserModel.deleteOne({ _id: userId })];
+                case 2:
+                    // Delete the user from DB
+                    _b.sent();
+                    freshAgent = supertest_1.default.agent(app);
+                    return [4 /*yield*/, freshAgent.get("/auth/me").set("authorization", "Bearer ".concat(token))];
+                case 3:
+                    res = _b.sent();
+                    // Without the user, the JWT verify succeeds but findById returns null
+                    (0, bun_test_1.expect)([401, 404]).toContain(res.status);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("login error and disabled user paths", function () {
+    var app;
+    var agent;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    (0, bun_test_1.setSystemTime)();
+                    return [4 /*yield*/, (0, tests_1.setupTestData)()];
+                case 1:
+                    _a.sent();
+                    app = new terrenoApp_1.TerrenoApp({
+                        configureApp: function () { },
+                        skipListen: true,
+                        userModel: tests_1.UserModel,
+                    }).build();
+                    agent = supertest_1.default.agent(app);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.afterEach)(function () {
+        (0, bun_test_1.setSystemTime)();
+    });
+    (0, bun_test_1.it)("returns 401 with message for invalid credentials (no user found)", 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*/, agent
+                        .post("/auth/login")
+                        .send({ email: "nonexistent@example.com", password: "wrong" })
+                        .expect(401)];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.body.message).toBeDefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns 401 when disabled user tries to access protected route", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var loginRes, _a, token, userId, freshAgent, res;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, agent
+                        .post("/auth/login")
+                        .send({ email: "notAdmin@example.com", password: "password" })
+                        .expect(200)];
+                case 1:
+                    loginRes = _b.sent();
+                    _a = loginRes.body.data, token = _a.token, userId = _a.userId;
+                    // Disable the user
+                    return [4 /*yield*/, tests_1.UserModel.findByIdAndUpdate(userId, { disabled: true })];
+                case 2:
+                    // Disable the user
+                    _b.sent();
+                    freshAgent = supertest_1.default.agent(app);
+                    return [4 /*yield*/, freshAgent
+                            .get("/auth/me")
+                            .set("authorization", "Bearer ".concat(token))
+                            .expect(401)];
+                case 3:
+                    res = _b.sent();
+                    (0, bun_test_1.expect)(res.body.title).toContain("disabled");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/dist/betterAuth.d.ts

@@ -53,7 +53,7 @@ export interface BetterAuthConfig {
     baseURL?: string;
 }
 /**
- * Auth provider selection for setupServer.
+ * Auth provider selection for TerrenoApp.
  * - "jwt": Traditional JWT/Passport authentication (default)
  * - "better-auth": Better Auth with OAuth support
  */

package/dist/consentApp.test.js

@@ -118,6 +118,7 @@ var buildApp = function (consentAppOptions) {
                     case 1:
                         res = _a.sent();
                         (0, bun_test_1.expect)(res.body.data).toHaveLength(0);
+                        (0, bun_test_1.expect)(res.body.requestId).toBe(res.headers["x-request-id"]);
                         return [2 /*return*/];
                 }
             });

package/dist/example.js

@@ -52,10 +52,10 @@ var mongoose_1 = __importStar(require("mongoose"));
 var passport_local_mongoose_1 = __importDefault(require("passport-local-mongoose"));
 var api_1 = require("./api");
 var auth_1 = require("./auth");
-var expressServer_1 = require("./expressServer");
 var logger_1 = require("./logger");
 var permissions_1 = require("./permissions");
 var plugins_1 = require("./plugins");
+var terrenoApp_1 = require("./terrenoApp");
 mongoose_1.default
     .connect("mongodb://localhost:27017/example")
     .then(function () {
@@ -119,12 +119,12 @@ var getBaseServer = function () {
                 update: [permissions_1.Permissions.IsOwner],
             }, queryFields: ["name", "calories", "created", "ownerId", "hidden"] })));
     };
-    return (0, expressServer_1.setupServer)({
-        addRoutes: addRoutes,
+    return new terrenoApp_1.TerrenoApp({
+        configureApp: addRoutes,
         loggingOptions: {
             level: "debug",
         },
         userModel: UserModel,
-    });
+    }).build();
 };
 getBaseServer();

package/dist/expressServer.d.ts

@@ -1,10 +1,6 @@
-import * as Sentry from "@sentry/bun";
 import express, { type Router } from "express";
 import type jwt from "jsonwebtoken";
 import type { ModelRouterOptions } from "./api";
-import { type UserModel as UserMongooseModel } from "./auth";
-import { type GitHubAuthOptions } from "./githubAuth";
-import { type LoggingOptions } from "./logger";
 export declare const setupEnvironment: () => void;
 export type AddRoutes = (router: Router, options?: Partial<ModelRouterOptions<unknown>>) => void;
 export declare const logRequests: (req: any, res: any, next: express.NextFunction) => void;
@@ -15,24 +11,6 @@ export interface AuthOptions {
     generateTokenExpiration?: (user: any) => number | jwt.SignOptions["expiresIn"];
     generateRefreshTokenExpiration?: (user: any) => number | jwt.SignOptions["expiresIn"];
 }
-export interface SetupServerOptions {
-    userModel: UserMongooseModel;
-    addRoutes: AddRoutes;
-    loggingOptions?: LoggingOptions;
-    logRequests?: boolean;
-    authOptions?: AuthOptions;
-    /**
-     * GitHub OAuth configuration. When provided, enables GitHub authentication.
-     * Requires the user schema to have GitHub fields (use githubUserPlugin).
-     */
-    githubAuth?: GitHubAuthOptions;
-    skipListen?: boolean;
-    corsOrigin?: string | boolean | RegExp | Array<boolean | string | RegExp> | ((requestOrigin: string | undefined, callback: (err: Error | null, origin?: boolean | string | RegExp | Array<boolean | string | RegExp>) => void) => void);
-    addMiddleware?: AddRoutes;
-    ignoreTraces?: string[];
-    sentryOptions?: Sentry.BunOptions;
-}
-export declare const setupServer: (options: SetupServerOptions) => express.Application;
 export declare const cronjob: (name: string, schedule: "hourly" | "minutely" | string, callback: () => void) => void;
 export interface WrapScriptOptions {
     onFinish?: (result?: unknown) => void | Promise<void>;