@terreno/api 0.13.3 → 0.14.1

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";

package/src/openApi.ts

@@ -199,7 +199,7 @@ export function listOpenApiMiddleware<T>(
       // Remove _id from queryFields, we handle that above.
       ?.filter((field) => field !== "_id")
       .map((field) => {
-        const params: {name: string; in: "query"; schema: any}[] = [];
+        const params: {name: string; in: "query"; schema: Record<string, unknown>}[] = [];
 
         // Check for datetime/number to support gt/gte/lt/lte
         if (
@@ -462,10 +462,10 @@ export function deleteOpenApiMiddleware<T>(
 // Useful for endpoints that don't directly map to a model.
 export function readOpenApiMiddleware<T>(
   options: Partial<ModelRouterOptions<T>>,
-  properties: any,
+  properties: Record<string, unknown>,
   required: string[],
-  queryParameters: any
-): any {
+  queryParameters: Array<Record<string, unknown>>
+): express.RequestHandler {
   if (!options.openApi?.path) {
     // Just log this once rather than for each middleware.
     logger.debug(

package/src/openApiBuilder.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";

package/src/openApiBuilder.ts

@@ -29,6 +29,7 @@
  * router.get("/stats", middleware, statsHandler);
  * ```
  */
+import type express from "express";
 import merge from "lodash/merge";
 
 import type {ModelRouterOptions} from "./api";
@@ -111,7 +112,7 @@ export interface OpenApiSchemaProperty {
  * };
  * ```
  */
-export type OpenApiSchema = {
+export interface OpenApiSchema {
   /** The JSON Schema type (typically "object" or "array") */
   type: string;
   /** Property definitions for object types */
@@ -122,7 +123,8 @@ export type OpenApiSchema = {
   items?: OpenApiSchemaProperty;
   /** Schema for additional properties or boolean to allow/disallow them */
   additionalProperties?: OpenApiSchemaProperty | boolean;
-};
+  [key: string]: unknown;
+}
 
 /**
  * Defines a parameter in an OpenAPI operation.
@@ -246,7 +248,7 @@ interface ValidationConfig {
  */
 export interface OpenApiBuildResult {
   /** The OpenAPI documentation middleware */
-  middleware: any;
+  middleware: express.RequestHandler;
   /** Request body schema if defined */
   bodySchema?: Record<string, OpenApiSchemaProperty>;
   /** Query parameter schemas if defined */
@@ -397,7 +399,7 @@ export class OpenApiMiddlewareBuilder {
    * });
    * ```
    */
-  withRequestBody<T extends Record<string, any>>(
+  withRequestBody<T extends Record<string, unknown>>(
     schema: {
       [K in keyof T]: OpenApiSchemaProperty;
     },
@@ -454,7 +456,7 @@ export class OpenApiMiddlewareBuilder {
    * builder.withResponse(204, "No content");
    * ```
    */
-  withResponse<T extends Record<string, any>>(
+  withResponse<T extends Record<string, unknown>>(
     statusCode: number,
     schema:
       | {
@@ -508,7 +510,7 @@ export class OpenApiMiddlewareBuilder {
    * }, {description: "List of users"});
    * ```
    */
-  withArrayResponse<T extends Record<string, any>>(
+  withArrayResponse<T extends Record<string, unknown>>(
     statusCode: number,
     itemSchema: {
       [K in keyof T]: OpenApiSchemaProperty;
@@ -671,10 +673,10 @@ export class OpenApiMiddlewareBuilder {
    * ```
    */
   buildWithSchemas(): OpenApiBuildResult {
-    const noop = (_a: any, _b: any, next: () => void): void => next();
+    const noop: express.RequestHandler = (_a, _b, next) => next();
 
     // Build the OpenAPI documentation middleware only (no validation middleware)
-    let openApiMiddleware: any = noop;
+    let openApiMiddleware: express.RequestHandler = noop;
     if (this.options.openApi?.path) {
       openApiMiddleware = this.options.openApi.path(
         merge(
@@ -733,11 +735,12 @@ export class OpenApiMiddlewareBuilder {
    * router.get("/users/:id", middleware, getUserHandler);
    * ```
    */
+  // biome-ignore lint/suspicious/noExplicitAny: returns either a single RequestHandler or an array depending on validation config — callers spread or invoke
   build(): any {
-    const noop = (_a: any, _b: any, next: () => void): void => next();
+    const noop: express.RequestHandler = (_a, _b, next) => next();
 
     // Build the OpenAPI documentation middleware
-    let openApiMiddleware: any = noop;
+    let openApiMiddleware: express.RequestHandler = noop;
     if (this.options.openApi?.path) {
       openApiMiddleware = this.options.openApi.path(
         merge(
@@ -768,7 +771,7 @@ export class OpenApiMiddlewareBuilder {
     }
 
     // Build validation middleware
-    const validators: any[] = [openApiMiddleware];
+    const validators: express.RequestHandler[] = [openApiMiddleware];
 
     // Add body validation if we have a request body schema
     if (this.validationConfig.validateBody && this.requestBodySchema) {

package/src/openApiValidator.test.ts

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

package/src/openApiValidator.ts

@@ -184,6 +184,7 @@ const getAjvInstance = (): Ajv => {
       useDefaults: true,
       validateSchema: false,
     });
+    // biome-ignore lint/suspicious/noExplicitAny: ajv-formats has a known type compat issue with AJV instances
     addFormats(instance as any);
     ajvCache.set(key, instance);
   }
@@ -644,7 +645,7 @@ export const createValidator = (
   return (req: Request, res: Response, next: NextFunction): void => {
     // Run body validation first
     if (bodyValidator) {
-      bodyValidator(req, res, ((err?: any) => {
+      bodyValidator(req, res, ((err?: unknown) => {
         if (err) {
           next(err);
           return;
@@ -714,7 +715,7 @@ const m2sOptions = {
  */
 export const getSchemaFromModel = <T>(model: Model<T>): Record<string, OpenApiSchemaProperty> => {
   const modelSwagger = m2s(model, m2sOptions);
-  fixMixedFields((model as any).schema, modelSwagger.properties);
+  fixMixedFields(model.schema, modelSwagger.properties);
   return modelSwagger.properties as Record<string, OpenApiSchemaProperty>;
 };
 

package/src/permissions.middleware.test.ts

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

package/src/permissions.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 supertest from "supertest";