@terreno/api 0.13.2 → 0.14.0

package/src/githubAuth.ts

@@ -1,8 +1,9 @@
 import type express from "express";
 import {Router} from "express";
+import type {Schema} from "mongoose";
 import passport from "passport";
 import {Strategy as GitHubStrategy, type Profile} from "passport-github2";
-import {generateTokens, type UserModel} from "./auth";
+import {generateTokens, type User, type UserModel} from "./auth";
 import {APIError} from "./errors";
 import type {AuthOptions} from "./expressServer";
 import {logger} from "./logger";
@@ -32,7 +33,9 @@ export interface GitHubAuthOptions {
     profile: Profile,
     accessToken: string,
     refreshToken: string,
+    // biome-ignore lint/suspicious/noExplicitAny: user shape varies per consumer's User model
     existingUser?: any
+    // biome-ignore lint/suspicious/noExplicitAny: passport user value remains untyped
   ) => Promise<any>;
 }
 
@@ -59,12 +62,19 @@ export interface GitHubUserFields {
  * userSchema.plugin(githubUserPlugin);
  * ```
  */
-export const githubUserPlugin = (schema: any): void => {
+// biome-ignore lint/suspicious/noExplicitAny: Schema generics must be loose to accept arbitrary consumer schemas
+export const githubUserPlugin = (schema: Schema<any, any, any, any>): void => {
   schema.add({
-    githubAvatarUrl: {type: String},
-    githubId: {index: true, sparse: true, type: String, unique: true},
-    githubProfileUrl: {type: String},
-    githubUsername: {type: String},
+    githubAvatarUrl: {description: "GitHub avatar image URL", type: String},
+    githubId: {
+      description: "GitHub user ID",
+      index: true,
+      sparse: true,
+      type: String,
+      unique: true,
+    },
+    githubProfileUrl: {description: "GitHub profile URL", type: String},
+    githubUsername: {description: "GitHub username", type: String},
   });
 };
 
@@ -81,6 +91,7 @@ export const setupGitHubAuth = (
 
   passport.use(
     "github",
+    // biome-ignore lint/suspicious/noExplicitAny: passport-github2's typed constructor overloads don't match passReqToCallback variant
     new (GitHubStrategy as any)(
       {
         callbackURL: githubOptions.callbackURL,
@@ -89,12 +100,12 @@ export const setupGitHubAuth = (
         passReqToCallback: true,
         scope,
       },
-      (async (
-        req: any,
+      async (
+        req: express.Request,
         accessToken: string,
         refreshToken: string,
         profile: Profile,
-        done: (error: any, user?: any) => void
+        done: (error: unknown, user?: unknown) => void
       ) => {
         try {
           const existingUser = req.user;
@@ -137,10 +148,11 @@ export const setupGitHubAuth = (
             // Link GitHub to existing user
             const user = await userModel.findById(existingUser._id);
             if (user) {
-              (user as any).githubId = githubId;
-              (user as any).githubUsername = profile.username;
-              (user as any).githubProfileUrl = profile.profileUrl;
-              (user as any).githubAvatarUrl = profile.photos?.[0]?.value;
+              const userWithGitHub = user as unknown as GitHubUserFields;
+              userWithGitHub.githubId = githubId;
+              userWithGitHub.githubUsername = profile.username;
+              userWithGitHub.githubProfileUrl = profile.profileUrl;
+              userWithGitHub.githubAvatarUrl = profile.photos?.[0]?.value;
               await user.save();
               return done(null, user);
             }
@@ -161,10 +173,11 @@ export const setupGitHubAuth = (
             if (existingEmailUser) {
               // If account linking is allowed, link GitHub to existing email account
               if (githubOptions.allowAccountLinking !== false) {
-                (existingEmailUser as any).githubId = githubId;
-                (existingEmailUser as any).githubUsername = profile.username;
-                (existingEmailUser as any).githubProfileUrl = profile.profileUrl;
-                (existingEmailUser as any).githubAvatarUrl = profile.photos?.[0]?.value;
+                const emailUserWithGitHub = existingEmailUser as unknown as GitHubUserFields;
+                emailUserWithGitHub.githubId = githubId;
+                emailUserWithGitHub.githubUsername = profile.username;
+                emailUserWithGitHub.githubProfileUrl = profile.profileUrl;
+                emailUserWithGitHub.githubAvatarUrl = profile.photos?.[0]?.value;
                 await existingEmailUser.save();
                 return done(null, existingEmailUser);
               }
@@ -186,7 +199,7 @@ export const setupGitHubAuth = (
             githubId,
             githubProfileUrl: profile.profileUrl,
             githubUsername: profile.username,
-          } as any);
+          } as unknown as Partial<User>);
 
           await newUser.save();
           return done(null, newUser);
@@ -194,7 +207,7 @@ export const setupGitHubAuth = (
           logger.error(`GitHub auth error: ${error}`);
           return done(error);
         }
-      }) as any
+      }
     ) as passport.Strategy
   );
 };
@@ -223,8 +236,9 @@ export const addGitHubAuthRoutes = (
       // Store the return URL in session or query for redirect after auth
       const returnTo = req.query.returnTo as string | undefined;
       if (returnTo) {
-        (req as any).session = (req as any).session || {};
-        (req as any).session.returnTo = returnTo;
+        const reqWithSession = req as express.Request & {session?: {returnTo?: string}};
+        reqWithSession.session = reqWithSession.session ?? {};
+        reqWithSession.session.returnTo = returnTo;
       }
       next();
     },
@@ -241,16 +255,17 @@ export const addGitHubAuthRoutes = (
     async (req: express.Request, res: express.Response) => {
       try {
         const tokens = await generateTokens(req.user, authOptions);
-        const returnTo = (req as any).session?.returnTo;
+        const returnTo = (req as express.Request & {session?: {returnTo?: string}}).session
+          ?.returnTo;
 
         // If there's a return URL, redirect with tokens as query params
         if (returnTo) {
           const url = new URL(returnTo);
-          url.searchParams.set("token", tokens.token || "");
+          url.searchParams.set("token", tokens.token ?? "");
           if (tokens.refreshToken) {
             url.searchParams.set("refreshToken", tokens.refreshToken);
           }
-          url.searchParams.set("userId", (req.user as any)?._id?.toString() || "");
+          url.searchParams.set("userId", req.user?._id ? String(req.user._id) : "");
           return res.redirect(url.toString());
         }
 
@@ -259,7 +274,7 @@ export const addGitHubAuthRoutes = (
           data: {
             refreshToken: tokens.refreshToken,
             token: tokens.token,
-            userId: (req.user as any)?._id,
+            userId: req.user?._id,
           },
         });
       } catch (error) {
@@ -280,14 +295,18 @@ export const addGitHubAuthRoutes = (
       "/github/link",
       (req: express.Request, res: express.Response, next: express.NextFunction): void => {
         // Require JWT authentication for linking
-        passport.authenticate("jwt", {session: false}, (err: any, user: any) => {
-          if (err || !user) {
-            res.status(401).json({message: "Authentication required to link GitHub account"});
-            return;
+        passport.authenticate(
+          "jwt",
+          {session: false},
+          (err: unknown, user: User | false | null) => {
+            if (err || !user) {
+              res.status(401).json({message: "Authentication required to link GitHub account"});
+              return;
+            }
+            req.user = user as unknown as express.Request["user"];
+            next();
           }
-          req.user = user;
-          next();
-        })(req, res, next);
+        )(req, res, next);
       },
       passport.authenticate("github", {session: false})
     );
@@ -303,14 +322,15 @@ export const addGitHubAuthRoutes = (
 
         try {
           // Explicitly select hash and salt fields which may be hidden by default
-          const user = await userModel.findById((req.user as any)._id).select("+hash +salt");
+          const user = await userModel.findById(req.user._id).select("+hash +salt");
           if (!user) {
             return res.status(404).json({message: "User not found"});
           }
 
           // Check if user has other authentication methods before unlinking
           // passport-local-mongoose stores password in hash and salt fields
-          const hasPassword = !!(user as any).hash || !!(user as any).salt;
+          const userWithAuth = user as unknown as {hash?: string; salt?: string};
+          const hasPassword = !!userWithAuth.hash || !!userWithAuth.salt;
           if (!hasPassword) {
             return res.status(400).json({
               message:
@@ -318,10 +338,11 @@ export const addGitHubAuthRoutes = (
             });
           }
 
-          (user as any).githubId = undefined;
-          (user as any).githubUsername = undefined;
-          (user as any).githubProfileUrl = undefined;
-          (user as any).githubAvatarUrl = undefined;
+          const userWithGitHub = user as unknown as GitHubUserFields;
+          userWithGitHub.githubId = undefined;
+          userWithGitHub.githubUsername = undefined;
+          userWithGitHub.githubProfileUrl = undefined;
+          userWithGitHub.githubAvatarUrl = undefined;
           await user.save();
 
           return res.json({data: {message: "GitHub account unlinked successfully"}});

package/src/index.ts

@@ -3,9 +3,11 @@ export * from "./auth";
 export * from "./betterAuth";
 export * from "./betterAuthApp";
 export * from "./betterAuthSetup";
+export * from "./config";
 export * from "./configurationApp";
 export * from "./configurationPlugin";
 export * from "./consentApp";
+export * from "./envConfigurationPlugin";
 export * from "./errors";
 export * from "./expressServer";
 export * from "./githubAuth";
@@ -22,6 +24,8 @@ export * from "./openApiValidator";
 export * from "./permissions";
 export * from "./plugins";
 export * from "./populate";
+export * from "./realtime";
+export * from "./requestContext";
 export * from "./scriptRunner";
 export * from "./secretProviders";
 export * from "./syncConsents";

package/src/logger.ts

@@ -2,38 +2,62 @@ import fs from "node:fs";
 import {inspect} from "node:util";
 import * as Sentry from "@sentry/bun";
 import winston from "winston";
+import {getCurrentLogContext} from "./requestContext";
 
-function isPrimitive(val: any) {
+const isPrimitive = (val: unknown) => {
   return val === null || (typeof val !== "object" && typeof val !== "function");
-}
+};
 
-function formatWithInspect(val: any) {
+const formatWithInspect = (val: unknown) => {
   const prefix = isPrimitive(val) ? "" : "\n";
   const shouldFormat = typeof val !== "string";
 
   return prefix + (shouldFormat ? inspect(val, {colors: true, depth: null}) : val);
-}
+};
+
+const addRequestContextFormat = winston.format((info) => {
+  const context = getCurrentLogContext();
+  return {...context, ...info};
+});
+
+const formatContext = (info: winston.Logform.TransformableInfo): string => {
+  const contextParts = [
+    info.requestId ? `requestId=${info.requestId}` : undefined,
+    info.jobId ? `jobId=${info.jobId}` : undefined,
+    info.sessionId ? `sessionId=${info.sessionId}` : undefined,
+    info.userId ? `userId=${info.userId}` : undefined,
+    info.traceId ? `traceId=${info.traceId}` : undefined,
+  ].filter(Boolean);
+
+  if (contextParts.length === 0) {
+    return "";
+  }
+  return ` ${contextParts.join(" ")}`;
+};
 
 // Winston doesn't operate like console.log by default, e.g. `logger.error('error',
 // error)` only prints the message and no args. Add handling for all the args,
 // while also supporting splat logging.
-function printf(timestamp = false) {
+const printf = (timestamp = false) => {
   return (info: winston.Logform.TransformableInfo) => {
     const msg = formatWithInspect(info.message);
-    const splatArgs = (info[Symbol.for("splat") as any] || []) as any[];
-    const rest = splatArgs.map((data: any) => formatWithInspect(data)).join(" ");
+    const splatKey = Symbol.for("splat") as unknown as keyof winston.Logform.TransformableInfo;
+    const splatArgs = (info[splatKey] || []) as unknown[];
+    const rest = splatArgs.map((data) => formatWithInspect(data)).join(" ");
+    const context = formatContext(info);
     if (timestamp) {
-      return `${info.timestamp} - ${info.level}: ${msg} ${rest}`;
+      return `${info.timestamp} - ${info.level}: ${msg}${context} ${rest}`;
     }
-    return `${info.level}: ${msg} ${rest}`;
+    return `${info.level}: ${msg}${context} ${rest}`;
   };
-}
+};
 
 // Setup a global, default rejection handler.
 winston.add(
   new winston.transports.Console({
     debugStdout: true,
     format: winston.format.combine(
+      addRequestContextFormat(),
       winston.format.colorize(),
       winston.format.simple(),
       winston.format.printf(printf(false))
@@ -46,11 +70,13 @@ winston.add(
 
 // Setup a default console logger.
 export const winstonLogger = winston.createLogger({
+  format: addRequestContextFormat(),
   level: "debug",
   transports: [
     new winston.transports.Console({
       debugStdout: true,
       format: winston.format.combine(
+        addRequestContextFormat(),
         winston.format.colorize(),
         winston.format.simple(),
         winston.format.printf(printf(false))
@@ -63,11 +89,15 @@ export const winstonLogger = winston.createLogger({
 });
 
 // Helper function to send logs to Sentry if enabled
-function sendToSentry(message: string, level: "debug" | "info" | "warn" | "error") {
+const sendToSentry = (message: string, level: "debug" | "info" | "warn" | "error"): void => {
   if (process.env.USE_SENTRY_LOGGING === "true" && Sentry.logger) {
-    Sentry.logger[level](message);
+    const logWithContext = Sentry.logger[level] as (
+      message: string,
+      attributes?: Record<string, unknown>
+    ) => void;
+    logWithContext(message, getCurrentLogContext());
   }
-}
+};
 
 export const logger = {
   // simple way to log a caught exception. e.g. promise().catch(logger.catch)
@@ -117,10 +147,10 @@ export interface LoggingOptions {
   logSlowRequestsWriteMs?: number;
 }
 
-export function setupLogging(options?: LoggingOptions) {
+export const setupLogging = (options?: LoggingOptions): void => {
   winstonLogger.clear();
   if (!options?.disableConsoleLogging) {
-    const formats: any[] = [winston.format.simple()];
+    const formats: winston.Logform.Format[] = [addRequestContextFormat(), winston.format.simple()];
     if (!options?.disableConsoleColors) {
       formats.push(winston.format.colorize());
     }
@@ -143,7 +173,7 @@ export function setupLogging(options?: LoggingOptions) {
       colorize: false,
       compress: true,
       dirname: logDirectory,
-      format: winston.format.simple(),
+      format: winston.format.combine(addRequestContextFormat(), winston.format.simple()),
       // 30 days of retention
       maxFiles: 30,
       // 50MB max file size
@@ -187,4 +217,4 @@ export function setupLogging(options?: LoggingOptions) {
       winstonLogger.add(transport);
     }
   }
-}
+};

package/src/models/versionConfig.ts

@@ -1,7 +1,7 @@
 import mongoose, {type Document} from "mongoose";
 
 import type {APIErrorConstructor} from "../errors";
-import {createdUpdatedPlugin, findOneOrNone} from "../plugins";
+import {createdUpdatedPlugin, findExactlyOne, findOneOrNone, isDeletedPlugin} from "../plugins";
 
 export interface VersionConfigDocument extends mongoose.Document {
   webWarningVersion: number;
@@ -11,6 +11,8 @@ export interface VersionConfigDocument extends mongoose.Document {
   warningMessage: string;
   requiredMessage: string;
   updateUrl?: string;
+  /** How often clients should poll for version updates, in minutes. Defaults to 1440 (24 hours). */
+  pollingIntervalMinutes: number;
   created?: Date;
   updated?: Date;
 }
@@ -22,7 +24,7 @@ export interface VersionConfigModel extends mongoose.Model<VersionConfigDocument
   ): Promise<(Document & VersionConfigDocument) | null>;
 }
 
-const versionConfigSchema = new mongoose.Schema<VersionConfigDocument>(
+const versionConfigSchema = new mongoose.Schema<VersionConfigDocument, VersionConfigModel>(
   {
     mobileRequiredVersion: {
       default: 0,
@@ -36,6 +38,13 @@ const versionConfigSchema = new mongoose.Schema<VersionConfigDocument>(
       min: 0,
       type: Number,
     },
+    pollingIntervalMinutes: {
+      default: 1440,
+      description:
+        "How often clients poll for version updates, in minutes (default: 1440 = 24 hours)",
+      min: 1,
+      type: Number,
+    },
     requiredMessage: {
       default: "This version is no longer supported. Please update to continue.",
       description: "Message shown on the blocking screen",
@@ -84,7 +93,9 @@ const versionConfigSchema = new mongoose.Schema<VersionConfigDocument>(
 versionConfigSchema.index({_singleton: 1}, {unique: true});
 
 versionConfigSchema.plugin(createdUpdatedPlugin);
+versionConfigSchema.plugin(isDeletedPlugin);
 versionConfigSchema.plugin(findOneOrNone);
+versionConfigSchema.plugin(findExactlyOne);
 
 export const VersionConfig = mongoose.model<VersionConfigDocument, VersionConfigModel>(
   "VersionConfig",

package/src/notifiers/googleChatNotifier.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {afterAll, afterEach, beforeEach, describe, expect, it, type Mock, spyOn} from "bun:test";
 import * as Sentry from "@sentry/bun";
 import axios from "axios";

package/src/notifiers/googleChatNotifier.ts

@@ -1,18 +1,17 @@
 import * as Sentry from "@sentry/bun";
 import axios from "axios";
 
-import {APIError} from "../errors";
+import {APIError, errorMessage} from "../errors";
 import {logger} from "../logger";
 
 export const sendToGoogleChat = async (
   messageText: string,
   {channel, shouldThrow = false, env}: {channel?: string; shouldThrow?: boolean; env?: string} = {}
-) => {
+): Promise<void> => {
   const chatWebhooksString = process.env.GOOGLE_CHAT_WEBHOOKS;
   if (!chatWebhooksString) {
     const msg = "GOOGLE_CHAT_WEBHOOKS not set. Google Chat message not sent";
-    Sentry.captureException(new Error(msg));
-    logger.error(msg);
+    Sentry.captureException(new APIError({status: 500, title: msg}));
     return;
   }
   const chatWebhooks = JSON.parse(chatWebhooksString ?? "{}");
@@ -22,8 +21,7 @@ export const sendToGoogleChat = async (
 
   if (!chatWebhookUrl) {
     const msg = `No webhook url set in env for ${chatChannel}. Google Chat message not sent`;
-    Sentry.captureException(new Error(msg));
-    logger.error(msg);
+    Sentry.captureException(new APIError({status: 500, title: msg}));
     return;
   }
 
@@ -35,13 +33,13 @@ export const sendToGoogleChat = async (
   try {
     await axios.post(chatWebhookUrl, {text: formattedMessageText});
   } catch (error: unknown) {
-    const errorObj = error as {text?: string; message?: string};
-    logger.error(`Error posting to Google Chat: ${errorObj.text ?? errorObj.message}`);
+    const message = errorMessage(error);
+    logger.error(`Error posting to Google Chat: ${message}`);
     Sentry.captureException(error);
     if (shouldThrow) {
       throw new APIError({
         status: 500,
-        title: `Error posting to Google Chat: ${errorObj.text ?? errorObj.message}`,
+        title: `Error posting to Google Chat: ${message}`,
       });
     }
   }

package/src/notifiers/slackNotifier.test.ts

@@ -2,6 +2,7 @@ import {afterAll, afterEach, beforeEach, describe, expect, it, type Mock, spyOn}
 import * as Sentry from "@sentry/bun";
 import axios from "axios";
 
+import {APIError} from "../errors";
 import {sendToSlack} from "./slackNotifier";
 
 describe("sendToSlack", () => {
@@ -10,7 +11,7 @@ describe("sendToSlack", () => {
   const ORIGINAL_ENV = process.env;
 
   beforeEach(() => {
-    mockAxiosPost = spyOn(axios, "post").mockResolvedValue({status: 200} as any);
+    mockAxiosPost = spyOn(axios, "post").mockResolvedValue({status: 200});
     process.env = {...ORIGINAL_ENV};
     process.env.SLACK_WEBHOOKS = undefined;
     (Sentry.captureException as Mock<typeof Sentry.captureException>).mockClear();
@@ -85,6 +86,30 @@ describe("sendToSlack", () => {
     expect(payload).toEqual({text: "[STG] status ok"});
   });
 
+  it("reports to Sentry and returns early when channel has no webhook and no default", async () => {
+    process.env.SLACK_WEBHOOKS = JSON.stringify({ops: "https://slack.example/ops"});
+
+    await sendToSlack("orphan message", {slackChannel: "alerts"});
+    expect(mockAxiosPost.mock.calls.length).toBe(0);
+    expect(
+      (Sentry.captureException as Mock<typeof Sentry.captureException>).mock.calls.length
+    ).toBe(1);
+    const captured = (Sentry.captureException as Mock<typeof Sentry.captureException>).mock
+      .calls[0][0] as APIError;
+    expect(captured).toBeInstanceOf(APIError);
+    expect(captured.title).toContain("alerts");
+  });
+
+  it("posts directly using the url parameter without env lookup", async () => {
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToSlack("direct msg", {url: "https://direct.example/hook"});
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+    const [url, payload] = mockAxiosPost.mock.calls[0];
+    expect(url).toBe("https://direct.example/hook");
+    expect(payload).toEqual({text: "direct msg"});
+  });
+
   it("captures error and throws APIError when shouldThrow=true", async () => {
     process.env.SLACK_WEBHOOKS = JSON.stringify({
       default: "https://slack.example/default",
@@ -95,8 +120,9 @@ describe("sendToSlack", () => {
       await sendToSlack("err", {shouldThrow: true});
       throw new Error("Expected sendToSlack to throw APIError");
     } catch (error) {
-      expect((error as any).name).toBe("APIError");
-      expect((error as any).title).toMatch(/Error posting to slack/i);
+      const apiError = error as APIError;
+      expect(apiError.name).toBe("APIError");
+      expect(apiError.title).toMatch(/Error posting to slack/i);
     }
     expect(mockAxiosPost.mock.calls.length).toBe(1);
   });

package/src/notifiers/slackNotifier.ts

@@ -1,7 +1,7 @@
 import * as Sentry from "@sentry/bun";
 import axios from "axios";
 
-import {APIError} from "../errors";
+import {APIError, errorMessage} from "../errors";
 import {logger} from "../logger";
 // Convenience method to send data to a Slack webhook.
 // If `url` is provided, it will be used directly instead of looking up from environment.
@@ -15,7 +15,7 @@ export const sendToSlack = async (
     env,
     url,
   }: {slackChannel?: string; shouldThrow?: boolean; env?: string; url?: string} = {}
-) => {
+): Promise<void> => {
   let slackWebhookUrl = url;
 
   if (!slackWebhookUrl) {
@@ -37,9 +37,11 @@ export const sendToSlack = async (
 
     if (!slackWebhookUrl) {
       Sentry.captureException(
-        new Error(`No webhook url set in env for ${channel}. Slack message not sent`)
+        new APIError({
+          status: 500,
+          title: `No webhook url set in env for ${channel}. Slack message not sent`,
+        })
       );
-      logger.debug(`No webhook url set in env for ${channel}.`);
       return;
     }
   }
@@ -54,13 +56,13 @@ export const sendToSlack = async (
       text: formattedText,
     });
   } catch (error: unknown) {
-    const errorObj = error as {text?: string; message?: string};
-    logger.error(`Error posting to slack: ${errorObj.text ?? errorObj.message}`);
+    const message = errorMessage(error);
+    logger.error(`Error posting to slack: ${message}`);
     Sentry.captureException(error);
     if (shouldThrow) {
       throw new APIError({
         status: 500,
-        title: `Error posting to slack: ${errorObj.text ?? errorObj.message}`,
+        title: `Error posting to slack: ${message}`,
       });
     }
   }

package/src/notifiers/zoomNotifier.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {afterAll, afterEach, beforeEach, describe, expect, it, type Mock, spyOn} from "bun:test";
 import * as Sentry from "@sentry/bun";
 import axios from "axios";

package/src/notifiers/zoomNotifier.ts

@@ -1,7 +1,7 @@
 import * as Sentry from "@sentry/bun";
 import axios from "axios";
 
-import {APIError} from "../errors";
+import {APIError, errorMessage} from "../errors";
 import {logger} from "../logger";
 
 /**
@@ -32,12 +32,11 @@ import {logger} from "../logger";
 export const sendToZoom = async (
   {header, body, subheader}: {header: string; body: string; subheader?: string},
   {channel, shouldThrow = false, env}: {channel: string; shouldThrow?: boolean; env?: string}
-) => {
+): Promise<void> => {
   const zoomWebhooksString = process.env.ZOOM_CHAT_WEBHOOKS;
   if (!zoomWebhooksString) {
     const msg = "ZOOM_CHAT_WEBHOOKS not set. Zoom message not sent";
-    Sentry.captureException(new Error(msg));
-    logger.error(msg);
+    Sentry.captureException(new APIError({status: 500, title: msg}));
     return;
   }
   const zoomWebhooks: Record<string, {channel: string; verificationToken: string}> = JSON.parse(
@@ -49,8 +48,7 @@ export const sendToZoom = async (
 
   if (!zoomWebhookUrl) {
     const msg = `No webhook url set in env for ${zoomChannel}. Zoom message not sent`;
-    Sentry.captureException(new Error(msg));
-    logger.error(msg);
+    Sentry.captureException(new APIError({status: 500, title: msg}));
     return;
   }
 
@@ -58,8 +56,7 @@ export const sendToZoom = async (
     zoomWebhooks[zoomChannel]?.verificationToken ?? zoomWebhooks.default?.verificationToken;
   if (!zoomToken) {
     const msg = `No verification token set in env for ${zoomChannel}. Zoom message not sent`;
-    Sentry.captureException(new Error(msg));
-    logger.error(msg);
+    Sentry.captureException(new APIError({status: 500, title: msg}));
     return;
   }
 
@@ -96,13 +93,13 @@ export const sendToZoom = async (
       }
     );
   } catch (error: unknown) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error(`Error posting to Zoom: ${errorMessage}`);
+    const message = errorMessage(error);
+    logger.error(`Error posting to Zoom: ${message}`);
     Sentry.captureException(error);
     if (shouldThrow) {
       throw new APIError({
         status: 500,
-        title: `Error posting to Zoom: ${errorMessage}`,
+        title: `Error posting to Zoom: ${message}`,
       });
     }
   }

package/src/openApi.test.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {beforeEach, describe, expect, it} from "bun:test";
 import type express from "express";
 import type {Router} from "express";