@terreno/api 0.9.3 → 0.11.0

package/dist/githubAuth.test.js

@@ -74,6 +74,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var bun_test_1 = require("bun:test");
 var mongoose_1 = __importStar(require("mongoose"));
+var passport_1 = __importDefault(require("passport"));
 var passport_local_mongoose_1 = __importDefault(require("passport-local-mongoose"));
 var supertest_1 = __importDefault(require("supertest"));
 var expressServer_1 = require("./expressServer");
@@ -349,3 +350,382 @@ var connectDb = function () { return __awaiter(void 0, void 0, void 0, function
         });
     }); });
 });
+// Helper to extract the strategy verify callback and invoke it directly
+var invokeGitHubVerify = function (req, accessToken, refreshToken, profile) {
+    var _a;
+    var strategy = (_a = passport_1.default._strategies) === null || _a === void 0 ? void 0 : _a.github;
+    if (!strategy) {
+        throw new Error("github strategy not registered");
+    }
+    return new Promise(function (resolve) {
+        var done = function (err, user) { return resolve({ err: err, user: user }); };
+        strategy._verify(req, accessToken, refreshToken, profile, done);
+    });
+};
+(0, bun_test_1.describe)("GitHub strategy verify callback", function () {
+    var testApp = { get: function () { }, use: function () { } };
+    (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: return [4 /*yield*/, connectDb()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, GitHubTestUserModel.deleteMany({})];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("uses custom findOrCreateUser when provided", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var customUser, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    customUser = { _id: "custom-user-id", email: "custom@example.com" };
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                        findOrCreateUser: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, customUser];
+                        }); }); },
+                    });
+                    return [4 /*yield*/, invokeGitHubVerify({}, "access", "refresh", { id: "123" })];
+                case 1:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeNull();
+                    (0, bun_test_1.expect)(result.user).toEqual(customUser);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("creates a new user when no existing GitHub or email user", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var profile, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                    });
+                    profile = {
+                        emails: [{ value: "new@example.com" }],
+                        id: "gh-new-1",
+                        photos: [{ value: "http://avatar" }],
+                        profileUrl: "http://profile",
+                        username: "newghuser",
+                    };
+                    return [4 /*yield*/, invokeGitHubVerify({}, "access", "refresh", profile)];
+                case 1:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeNull();
+                    (0, bun_test_1.expect)(result.user).toBeDefined();
+                    (0, bun_test_1.expect)(result.user.githubId).toBe("gh-new-1");
+                    (0, bun_test_1.expect)(result.user.githubUsername).toBe("newghuser");
+                    (0, bun_test_1.expect)(result.user.email).toBe("new@example.com");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("logs in existing GitHub user", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var existingUser, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, GitHubTestUserModel.create({
+                        email: "gh@example.com",
+                        githubId: "gh-existing-1",
+                        githubUsername: "ghuser",
+                        name: "GH User",
+                    })];
+                case 1:
+                    existingUser = _a.sent();
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                    });
+                    return [4 /*yield*/, invokeGitHubVerify({}, "access", "refresh", {
+                            id: "gh-existing-1",
+                            username: "ghuser",
+                        })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeNull();
+                    (0, bun_test_1.expect)(result.user._id.toString()).toBe(existingUser._id.toString());
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("links GitHub to authenticated user when allowAccountLinking=true", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var existingUser, req, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, GitHubTestUserModel.create({
+                        email: "link@example.com",
+                        name: "Link User",
+                    })];
+                case 1:
+                    existingUser = _a.sent();
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        allowAccountLinking: true,
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                    });
+                    req = { user: existingUser };
+                    return [4 /*yield*/, invokeGitHubVerify(req, "access", "refresh", {
+                            id: "gh-link-1",
+                            photos: [{ value: "http://avatar" }],
+                            profileUrl: "http://profile",
+                            username: "linkedghuser",
+                        })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeNull();
+                    (0, bun_test_1.expect)(result.user.githubId).toBe("gh-link-1");
+                    (0, bun_test_1.expect)(result.user.githubUsername).toBe("linkedghuser");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("rejects linking when allowAccountLinking=false", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var existingUser, req, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, GitHubTestUserModel.create({
+                        email: "nolink@example.com",
+                    })];
+                case 1:
+                    existingUser = _a.sent();
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        allowAccountLinking: false,
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                    });
+                    req = { user: existingUser };
+                    return [4 /*yield*/, invokeGitHubVerify(req, "access", "refresh", { id: "gh-nolink-1" })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeDefined();
+                    (0, bun_test_1.expect)(result.err.status).toBe(400);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("rejects linking when GitHub account belongs to another user", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var userA, req, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, GitHubTestUserModel.create({
+                        email: "a@example.com",
+                    })];
+                case 1:
+                    userA = _a.sent();
+                    return [4 /*yield*/, GitHubTestUserModel.create({
+                            email: "b@example.com",
+                            githubId: "gh-other-1",
+                        })];
+                case 2:
+                    _a.sent();
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        allowAccountLinking: true,
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                    });
+                    req = { user: userA };
+                    return [4 /*yield*/, invokeGitHubVerify(req, "access", "refresh", { id: "gh-other-1" })];
+                case 3:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeDefined();
+                    (0, bun_test_1.expect)(result.err.status).toBe(400);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("links GitHub to existing email user when allowAccountLinking is not false", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, GitHubTestUserModel.create({
+                        email: "emailuser@example.com",
+                    })];
+                case 1:
+                    _a.sent();
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                    });
+                    return [4 /*yield*/, invokeGitHubVerify({}, "access", "refresh", {
+                            emails: [{ value: "emailuser@example.com" }],
+                            id: "gh-email-link-1",
+                            username: "emailuserghuser",
+                        })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeNull();
+                    (0, bun_test_1.expect)(result.user.githubId).toBe("gh-email-link-1");
+                    (0, bun_test_1.expect)(result.user.email).toBe("emailuser@example.com");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("rejects email-link when allowAccountLinking=false", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, GitHubTestUserModel.create({
+                        email: "emailnolink@example.com",
+                    })];
+                case 1:
+                    _a.sent();
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        allowAccountLinking: false,
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                    });
+                    return [4 /*yield*/, invokeGitHubVerify({}, "access", "refresh", {
+                            emails: [{ value: "emailnolink@example.com" }],
+                            id: "gh-email-nolink-1",
+                        })];
+                case 2:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeDefined();
+                    (0, bun_test_1.expect)(result.err.status).toBe(400);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns error when thrown during lookup", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // Set up strategy with findOrCreateUser that throws
+                    (0, githubAuth_1.setupGitHubAuth)(testApp, GitHubTestUserModel, {
+                        callbackURL: "http://localhost:9000/auth/github/callback",
+                        clientId: "id",
+                        clientSecret: "secret",
+                        findOrCreateUser: function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                throw new Error("boom");
+                            });
+                        }); },
+                    });
+                    return [4 /*yield*/, invokeGitHubVerify({}, "access", "refresh", { id: "gh-err-1" })];
+                case 1:
+                    result = _a.sent();
+                    (0, bun_test_1.expect)(result.err).toBeDefined();
+                    (0, bun_test_1.expect)(result.err.message).toBe("boom");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+(0, bun_test_1.describe)("addGitHubAuthRoutes link endpoints", function () {
+    var app;
+    var agent;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        function addRoutes(router) {
+            router.get("/test", function (_req, res) { return res.json({ ok: true }); });
+        }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    (0, bun_test_1.setSystemTime)();
+                    return [4 /*yield*/, connectDb()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, GitHubTestUserModel.deleteMany({})];
+                case 2:
+                    _a.sent();
+                    app = (0, expressServer_1.setupServer)({
+                        addRoutes: addRoutes,
+                        githubAuth: {
+                            allowAccountLinking: true,
+                            callbackURL: "http://localhost:9000/auth/github/callback",
+                            clientId: "test-client-id",
+                            clientSecret: "test-client-secret",
+                        },
+                        skipListen: true,
+                        userModel: GitHubTestUserModel,
+                    });
+                    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)("GET /auth/github/link requires JWT authentication", 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/github/link").expect(401)];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.body.message).toContain("Authentication required");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("GET /auth/github with returnTo stores it in session", 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/github?returnTo=https://example.com/cb").expect(302)];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.headers.location).toContain("github.com");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("DELETE /auth/github/unlink clears GitHub fields", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var user, loginRes, updatedUser;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, GitHubTestUserModel.create({
+                        email: "unlinkme@example.com",
+                        githubAvatarUrl: "http://avatar",
+                        githubId: "77777",
+                        githubProfileUrl: "http://profile",
+                        githubUsername: "ghunlink",
+                    })];
+                case 1:
+                    user = _a.sent();
+                    return [4 /*yield*/, user.setPassword("password123")];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, user.save()];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, agent
+                            .post("/auth/login")
+                            .send({ email: "unlinkme@example.com", password: "password123" })
+                            .expect(200)];
+                case 4:
+                    loginRes = _a.sent();
+                    return [4 /*yield*/, agent
+                            .delete("/auth/github/unlink")
+                            .set("authorization", "Bearer ".concat(loginRes.body.data.token))
+                            .expect(200)];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, GitHubTestUserModel.findOne({ email: "unlinkme@example.com" })];
+                case 6:
+                    updatedUser = _a.sent();
+                    (0, bun_test_1.expect)(updatedUser.githubId).toBeUndefined();
+                    (0, bun_test_1.expect)(updatedUser.githubAvatarUrl).toBeUndefined();
+                    (0, bun_test_1.expect)(updatedUser.githubProfileUrl).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/dist/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/logger.test.js

@@ -0,0 +1,143 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __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 node_fs_1 = __importDefault(require("node:fs"));
+var node_os_1 = __importDefault(require("node:os"));
+var node_path_1 = __importDefault(require("node:path"));
+var winston_1 = __importDefault(require("winston"));
+var logger_1 = require("./logger");
+(0, bun_test_1.describe)("logger", function () {
+    var OLD_ENV = process.env;
+    (0, bun_test_1.beforeEach)(function () {
+        process.env = __assign({}, OLD_ENV);
+    });
+    (0, bun_test_1.afterEach)(function () {
+        process.env = OLD_ENV;
+    });
+    (0, bun_test_1.it)("logger.info writes a log entry", function () {
+        (0, bun_test_1.expect)(function () { return logger_1.logger.info("test info message"); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("logger.warn writes a log entry", function () {
+        (0, bun_test_1.expect)(function () { return logger_1.logger.warn("test warn message"); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("logger.error writes a log entry", function () {
+        (0, bun_test_1.expect)(function () { return logger_1.logger.error("test error message"); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("logger.debug writes a log entry", function () {
+        (0, bun_test_1.expect)(function () { return logger_1.logger.debug("test debug message"); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("logger.catch handles Error instance", function () {
+        (0, bun_test_1.expect)(function () { return logger_1.logger.catch(new Error("caught error")); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("logger.catch handles non-Error value", function () {
+        (0, bun_test_1.expect)(function () { return logger_1.logger.catch("string error"); }).not.toThrow();
+    });
+    (0, bun_test_1.it)("logger.catch with Sentry logging enabled and Error", function () {
+        process.env.USE_SENTRY_LOGGING = "true";
+        (0, bun_test_1.expect)(function () { return logger_1.logger.catch(new Error("captured")); }).not.toThrow();
+    });
+});
+(0, bun_test_1.describe)("setupLogging", function () {
+    var tempDir;
+    (0, bun_test_1.beforeEach)(function () {
+        tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), "logger-test-"));
+    });
+    (0, bun_test_1.afterEach)(function () {
+        try {
+            node_fs_1.default.rmSync(tempDir, { force: true, recursive: true });
+        }
+        catch (_a) { }
+        // Restore a default logger config
+        (0, logger_1.setupLogging)({ disableFileLogging: true });
+    });
+    (0, bun_test_1.it)("disables console logging when disableConsoleLogging is true", function () {
+        (0, bun_test_1.expect)(function () {
+            return (0, logger_1.setupLogging)({
+                disableConsoleLogging: true,
+                disableFileLogging: true,
+            });
+        }).not.toThrow();
+    });
+    (0, bun_test_1.it)("disables console colors when disableConsoleColors is true", function () {
+        (0, bun_test_1.expect)(function () {
+            return (0, logger_1.setupLogging)({
+                disableConsoleColors: true,
+                disableFileLogging: true,
+            });
+        }).not.toThrow();
+    });
+    (0, bun_test_1.it)("adds timestamps when showConsoleTimestamps is true", function () {
+        (0, bun_test_1.expect)(function () {
+            return (0, logger_1.setupLogging)({
+                disableFileLogging: true,
+                showConsoleTimestamps: true,
+            });
+        }).not.toThrow();
+    });
+    (0, bun_test_1.it)("respects logLevel option", function () {
+        (0, bun_test_1.expect)(function () {
+            return (0, logger_1.setupLogging)({
+                disableFileLogging: true,
+                level: "info",
+            });
+        }).not.toThrow();
+    });
+    (0, bun_test_1.it)("creates log directory if it does not exist", function () {
+        var nonExistentDir = node_path_1.default.join(tempDir, "nested", "logs");
+        (0, logger_1.setupLogging)({
+            disableConsoleLogging: true,
+            logDirectory: nonExistentDir,
+        });
+        (0, bun_test_1.expect)(node_fs_1.default.existsSync(nonExistentDir)).toBe(true);
+    });
+    (0, bun_test_1.it)("uses existing log directory if it exists", function () {
+        var existingDir = node_path_1.default.join(tempDir, "existing");
+        node_fs_1.default.mkdirSync(existingDir);
+        (0, bun_test_1.expect)(function () {
+            return (0, logger_1.setupLogging)({
+                disableConsoleLogging: true,
+                logDirectory: existingDir,
+            });
+        }).not.toThrow();
+    });
+    (0, bun_test_1.it)("adds custom transports when provided", function () {
+        var customTransport = new winston_1.default.transports.Console({ level: "error" });
+        (0, bun_test_1.expect)(function () {
+            return (0, logger_1.setupLogging)({
+                disableConsoleLogging: true,
+                disableFileLogging: true,
+                transports: [customTransport],
+            });
+        }).not.toThrow();
+    });
+    (0, bun_test_1.it)("uses file logging at info level when level is info (no debug file)", function () {
+        (0, logger_1.setupLogging)({
+            disableConsoleLogging: true,
+            level: "info",
+            logDirectory: tempDir,
+        });
+        // No assertion needed - just verifying branch coverage with level=info
+        (0, bun_test_1.expect)(true).toBe(true);
+    });
+    (0, bun_test_1.it)("uses file logging at debug level by default (with debug file)", function () {
+        (0, logger_1.setupLogging)({
+            disableConsoleLogging: true,
+            logDirectory: tempDir,
+        });
+        (0, bun_test_1.expect)(true).toBe(true);
+    });
+});

package/dist/notifiers/googleChatNotifier.test.js

@@ -257,4 +257,41 @@ var googleChatNotifier_1 = require("./googleChatNotifier");
             }
         });
     }); });
+    (0, bun_test_1.it)("returns early when webhook url is missing for channel and no default exists", function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+                        ops: "https://chat.example/ops",
+                    });
+                    return [4 /*yield*/, (0, googleChatNotifier_1.sendToGoogleChat)("no default", { channel: "missing" })];
+                case 1:
+                    _a.sent();
+                    (0, bun_test_1.expect)(mockAxiosPost.mock.calls.length).toBe(0);
+                    (0, bun_test_1.expect)(Sentry.captureException).toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("prefixes message with [ENV] and posts when channel matches", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var callArgs, _a, url, payload;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+                        default: "https://chat.example/default",
+                        ops: "https://chat.example/ops",
+                    });
+                    mockAxiosPost.mockResolvedValue({ status: 200 });
+                    return [4 /*yield*/, (0, googleChatNotifier_1.sendToGoogleChat)("deploy complete", { channel: "ops", env: "staging" })];
+                case 1:
+                    _b.sent();
+                    callArgs = mockAxiosPost.mock.calls[0];
+                    _a = __read(callArgs, 2), url = _a[0], payload = _a[1];
+                    (0, bun_test_1.expect)(url).toBe("https://chat.example/ops");
+                    (0, bun_test_1.expect)(payload).toEqual({ text: "[STAGING] deploy complete" });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/dist/openApi.js

@@ -150,7 +150,7 @@ function getOpenApiMiddleware(model, options) {
     createAPIErrorComponent(options.openApi);
     if (!((_c = options.openApi) === null || _c === void 0 ? void 0 : _c.path)) {
         // Just log this once rather than for each middleware.
-        logger_1.logger.debug("No options.openApi provided, skipping *OpenApiMiddleware");
+        logger_1.logger.debug("No options.openApi provided for model \"".concat(model.modelName, "\" in getOpenApiMiddleware, skipping *OpenApiMiddleware"));
         return noop;
     }
     if (((_e = (_d = options.permissions) === null || _d === void 0 ? void 0 : _d.read) === null || _e === void 0 ? void 0 : _e.length) === 0) {
@@ -416,7 +416,7 @@ function readOpenApiMiddleware(options, properties, required, queryParameters) {
     var _c, _d, _e, _f, _g;
     if (!((_c = options.openApi) === null || _c === void 0 ? void 0 : _c.path)) {
         // Just log this once rather than for each middleware.
-        logger_1.logger.debug("No options.openApi provided, skipping *OpenApiMiddleware");
+        logger_1.logger.debug("No options.openApi provided in readOpenApiMiddleware, skipping *OpenApiMiddleware");
         return noop;
     }
     if (((_e = (_d = options.permissions) === null || _d === void 0 ? void 0 : _d.read) === null || _e === void 0 ? void 0 : _e.length) === 0) {