@terreno/api 0.11.7 → 0.11.9

package/src/githubAuth.ts

@@ -5,6 +5,7 @@ import {generateTokens, type UserModel} from "./auth";
 import {APIError} from "./errors";
 import type {AuthOptions} from "./expressServer";
 import {logger} from "./logger";
+import {findOneOrNoneFor} from "./plugins";
 
 /** Options for configuring GitHub OAuth authentication */
 export interface GitHubAuthOptions {
@@ -57,24 +58,24 @@ export interface GitHubUserFields {
  * userSchema.plugin(githubUserPlugin);
  * ```
  */
-export function githubUserPlugin(schema: any) {
+export const githubUserPlugin = (schema: any): void => {
   schema.add({
     githubAvatarUrl: {type: String},
     githubId: {index: true, sparse: true, type: String, unique: true},
     githubProfileUrl: {type: String},
     githubUsername: {type: String},
   });
-}
+};
 
 /**
  * Sets up GitHub OAuth authentication strategy.
  * Call this after setupAuth() in your server initialization.
  */
-export function setupGitHubAuth(
+export const setupGitHubAuth = (
   _app: express.Application,
   userModel: UserModel,
   githubOptions: GitHubAuthOptions
-) {
+): void => {
   const scope = githubOptions.scope ?? ["user:email"];
 
   passport.use(
@@ -112,7 +113,7 @@ export function setupGitHubAuth(
           const githubId = profile.id;
 
           // Check if user with this GitHub ID already exists
-          const existingGitHubUser = await userModel.findOne({githubId} as any);
+          const existingGitHubUser = await findOneOrNoneFor(userModel, {githubId});
 
           // Case 1: User is authenticated and wants to link GitHub account
           if (existingUser) {
@@ -155,7 +156,7 @@ export function setupGitHubAuth(
 
           // Check if user with this email already exists
           if (email) {
-            const existingEmailUser = await userModel.findOne({email} as any);
+            const existingEmailUser = await findOneOrNoneFor(userModel, {email});
             if (existingEmailUser) {
               // If account linking is allowed, link GitHub to existing email account
               if (githubOptions.allowAccountLinking !== false) {
@@ -195,7 +196,7 @@ export function setupGitHubAuth(
       }) as any
     ) as passport.Strategy
   );
-}
+};
 
 /**
  * Adds GitHub OAuth routes to the Express application.
@@ -206,12 +207,12 @@ export function setupGitHubAuth(
  * - POST /auth/github/link - Links GitHub account to authenticated user (requires JWT auth)
  * - DELETE /auth/github/unlink - Unlinks GitHub account from authenticated user (requires JWT auth)
  */
-export function addGitHubAuthRoutes(
+export const addGitHubAuthRoutes = (
   app: express.Application,
   userModel: UserModel,
   githubOptions: GitHubAuthOptions,
   authOptions?: AuthOptions
-): void {
+): void => {
   const router = require("express").Router();
 
   // Initiate GitHub OAuth flow
@@ -332,4 +333,4 @@ export function addGitHubAuthRoutes(
   }
 
   app.use("/auth", router);
-}
+};

package/src/middleware.test.ts

@@ -0,0 +1,71 @@
+import {beforeEach, describe, expect, it, type Mock, mock} from "bun:test";
+import * as Sentry from "@sentry/bun";
+import type {NextFunction, Request, Response} from "express";
+
+import {sentryAppVersionMiddleware} from "./middleware";
+
+const buildReq = (headers: Record<string, string | undefined>): Request => {
+  return {
+    get: (name: string) => headers[name],
+  } as unknown as Request;
+};
+
+const buildNext = (): Mock<() => void> => mock(() => {});
+
+describe("sentryAppVersionMiddleware", () => {
+  let setTagMock: Mock<(key: string, value: string) => void>;
+
+  beforeEach(() => {
+    // bunSetup.ts mocks @sentry/bun so that getCurrentScope() returns a scope
+    // with a Bun mock setTag. Clear that mock between tests so each assertion
+    // sees only its own calls.
+    setTagMock = Sentry.getCurrentScope().setTag as unknown as Mock<
+      (key: string, value: string) => void
+    >;
+    setTagMock.mockClear();
+  });
+
+  it("sets the app_version tag when the App-Version header is present", () => {
+    const next = buildNext();
+    const req = buildReq({"App-Version": "1.2.3"});
+
+    sentryAppVersionMiddleware(req, {} as Response, next as unknown as NextFunction);
+
+    expect(setTagMock).toHaveBeenCalledTimes(1);
+    expect(setTagMock.mock.calls[0]).toEqual(["app_version", "1.2.3"]);
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not set a tag when the App-Version header is missing", () => {
+    const next = buildNext();
+    const req = buildReq({});
+
+    sentryAppVersionMiddleware(req, {} as Response, next as unknown as NextFunction);
+
+    expect(setTagMock).not.toHaveBeenCalled();
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not set a tag when the App-Version header is an empty string", () => {
+    const next = buildNext();
+    const req = buildReq({"App-Version": ""});
+
+    sentryAppVersionMiddleware(req, {} as Response, next as unknown as NextFunction);
+
+    expect(setTagMock).not.toHaveBeenCalled();
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls next exactly once with no arguments when the header is present", () => {
+    const next = buildNext();
+
+    sentryAppVersionMiddleware(
+      buildReq({"App-Version": "9.9.9"}),
+      {} as Response,
+      next as unknown as NextFunction
+    );
+
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(next.mock.calls[0]).toHaveLength(0);
+  });
+});

package/src/middleware.ts

@@ -9,10 +9,14 @@ import type {NextFunction, Request, Response} from "express";
  *
  * Expected header: `App-Version`
  */
-export function sentryAppVersionMiddleware(req: Request, _res: Response, next: NextFunction): void {
+export const sentryAppVersionMiddleware = (
+  req: Request,
+  _res: Response,
+  next: NextFunction
+): void => {
   const appVersion = req.get("App-Version");
   if (appVersion) {
     Sentry.getCurrentScope().setTag("app_version", appVersion);
   }
   next();
-}
+};

package/src/notifiers/googleChatNotifier.ts

@@ -34,13 +34,14 @@ export const sendToGoogleChat = async (
 
   try {
     await axios.post(chatWebhookUrl, {text: formattedMessageText});
-  } catch (error: any) {
-    logger.error(`Error posting to Google Chat: ${error.text ?? error.message}`);
+  } catch (error: unknown) {
+    const errorObj = error as {text?: string; message?: string};
+    logger.error(`Error posting to Google Chat: ${errorObj.text ?? errorObj.message}`);
     Sentry.captureException(error);
     if (shouldThrow) {
       throw new APIError({
         status: 500,
-        title: `Error posting to Google Chat: ${error.text ?? error.message}`,
+        title: `Error posting to Google Chat: ${errorObj.text ?? errorObj.message}`,
       });
     }
   }

package/src/notifiers/zoomNotifier.ts

@@ -95,13 +95,14 @@ export const sendToZoom = async (
         },
       }
     );
-  } catch (error: any) {
-    logger.error(`Error posting to Zoom: ${error.text ?? error.message}`);
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Error posting to Zoom: ${errorMessage}`);
     Sentry.captureException(error);
     if (shouldThrow) {
       throw new APIError({
         status: 500,
-        title: `Error posting to Zoom: ${error.text ?? error.message}`,
+        title: `Error posting to Zoom: ${errorMessage}`,
       });
     }
   }

package/src/openApiCompat.ts

@@ -110,7 +110,7 @@ const patchRouterStack = (stack: any[]): void => {
  */
 export const patchAppUse = (app: any): void => {
   const originalUse = app.use.bind(app);
-  app.use = function patchedUse(...args: any[]) {
+  const patchedUse = (...args: any[]): unknown => {
     // Track stack length before the call
     const router = app._router || app.router;
     const stackBefore = router?.stack?.length ?? 0;
@@ -132,6 +132,7 @@ export const patchAppUse = (app: any): void => {
 
     return result;
   };
+  app.use = patchedUse;
 };
 
 /**

package/src/openApiEtag.ts

@@ -6,7 +6,7 @@ import type {NextFunction, Request, Response} from "express";
  * This middleware should be added before the @wesleytodd/openapi middleware
  * to intercept requests to /openapi.json and add conditional request support.
  */
-export function openApiEtagMiddleware(req: Request, res: Response, next: NextFunction): void {
+export const openApiEtagMiddleware = (req: Request, res: Response, next: NextFunction): void => {
   // Only handle GET requests to /openapi.json
   if (req.method !== "GET" || req.path !== "/openapi.json") {
     next();
@@ -37,4 +37,4 @@ export function openApiEtagMiddleware(req: Request, res: Response, next: NextFun
   };
 
   next();
-}
+};

package/src/openApiValidator.ts

@@ -110,9 +110,9 @@ let globalConfig: OpenApiValidatorConfig = {
  * Check whether `configureOpenApiValidator()` has been called.
  * Validation middleware is a no-op when this returns false.
  */
-export function isOpenApiValidatorConfigured(): boolean {
+export const isOpenApiValidatorConfigured = (): boolean => {
   return isConfigured;
-}
+};
 
 /**
  * Configure the global OpenAPI validator settings.
@@ -131,28 +131,28 @@ export function isOpenApiValidatorConfigured(): boolean {
  * });
  * ```
  */
-export function configureOpenApiValidator(config: Partial<OpenApiValidatorConfig> = {}): void {
+export const configureOpenApiValidator = (config: Partial<OpenApiValidatorConfig> = {}): void => {
   isConfigured = true;
   globalConfig = {...globalConfig, ...config};
   // Clear cached AJV instances so new config takes effect
   ajvCache.clear();
   validatorCache.clear();
   logger.debug(`OpenAPI validator configured: ${JSON.stringify(globalConfig)}`);
-}
+};
 
 /**
  * Get the current global validator configuration.
  */
-export function getOpenApiValidatorConfig(): OpenApiValidatorConfig {
+export const getOpenApiValidatorConfig = (): OpenApiValidatorConfig => {
   return {...globalConfig};
-}
+};
 
 /**
  * Reset the global validator configuration to defaults.
  * Also resets `isConfigured` to false.
  * Useful for testing.
  */
-export function resetOpenApiValidatorConfig(): void {
+export const resetOpenApiValidatorConfig = (): void => {
   isConfigured = false;
   globalConfig = {
     coerceTypes: true,
@@ -163,7 +163,7 @@ export function resetOpenApiValidatorConfig(): void {
   };
   ajvCache.clear();
   validatorCache.clear();
-}
+};
 
 // Lazy AJV instance cache keyed by coerceTypes + removeAdditional
 const ajvCache = new Map<string, Ajv>();
@@ -171,7 +171,7 @@ const ajvCache = new Map<string, Ajv>();
 /**
  * Get or create an AJV instance with the current config settings.
  */
-function getAjvInstance(): Ajv {
+const getAjvInstance = (): Ajv => {
   const key = `coerce:${globalConfig.coerceTypes ?? true},remove:${globalConfig.removeAdditional ?? true}`;
   let instance = ajvCache.get(key);
 
@@ -189,7 +189,7 @@ function getAjvInstance(): Ajv {
   }
 
   return instance;
-}
+};
 
 // Cache compiled validators by schema hash + config key
 const validatorCache = new Map<string, ValidateFunction>();
@@ -197,9 +197,9 @@ const validatorCache = new Map<string, ValidateFunction>();
 /**
  * Generate a simple hash for a schema to use as a cache key.
  */
-function hashSchema(schema: OpenApiSchema): string {
+const hashSchema = (schema: OpenApiSchema): string => {
   return JSON.stringify(schema);
-}
+};
 
 const VALID_JSON_SCHEMA_TYPES = new Set([
   "string",
@@ -221,7 +221,7 @@ const MONGOOSE_TYPE_MAP: Record<string, {type: string; format?: string}> = {
  * Recursively replace non-standard mongoose-to-swagger types with valid JSON Schema types
  * so AJV can compile the schema.
  */
-function sanitizeSchemaForAjv(schema: Record<string, unknown>): Record<string, unknown> {
+const sanitizeSchemaForAjv = (schema: Record<string, unknown>): Record<string, unknown> => {
   if (!schema || typeof schema !== "object") {
     return schema;
   }
@@ -262,7 +262,7 @@ function sanitizeSchemaForAjv(schema: Record<string, unknown>): Record<string, u
   }
 
   return result;
-}
+};
 
 /**
  * Get or create a compiled validator for a schema.
@@ -270,7 +270,7 @@ function sanitizeSchemaForAjv(schema: Record<string, unknown>): Record<string, u
  * Sanitizes non-standard mongoose-to-swagger types before compilation.
  * Returns null if the schema still cannot be compiled after sanitization.
  */
-function getValidator(schema: OpenApiSchema): ValidateFunction | null {
+const getValidator = (schema: OpenApiSchema): ValidateFunction | null => {
   const ajv = getAjvInstance();
   const configKey = `coerce:${globalConfig.coerceTypes ?? true},remove:${globalConfig.removeAdditional ?? true}`;
   const hash = `${configKey}:${hashSchema(schema)}`;
@@ -293,12 +293,12 @@ function getValidator(schema: OpenApiSchema): ValidateFunction | null {
     validatorCache.set(hash, null as unknown as ValidateFunction);
     return null;
   }
-}
+};
 
 /**
  * Format AJV errors into a human-readable string.
  */
-function formatValidationErrors(errors: ErrorObject[]): string {
+const formatValidationErrors = (errors: ErrorObject[]): string => {
   return errors
     .map((err) => {
       const path = err.instancePath || "/";
@@ -306,17 +306,17 @@ function formatValidationErrors(errors: ErrorObject[]): string {
       return `${path}: ${message}`;
     })
     .join("; ");
-}
+};
 
 /**
  * Convert OpenApiSchemaProperty to a full OpenApiSchema suitable for AJV.
  * Strips `required` from individual properties (OpenAPI-style) and moves it
  * to the schema-level `required` array (JSON Schema-style) for AJV compatibility.
  */
-function propertiesToSchema(
+const propertiesToSchema = (
   properties: Record<string, OpenApiSchemaProperty>,
   requiredFields?: string[]
-): OpenApiSchema {
+): OpenApiSchema => {
   // Extract required fields from properties that have required: true
   const autoRequired = Object.entries(properties)
     .filter(([_, prop]) => prop.required)
@@ -344,7 +344,7 @@ function propertiesToSchema(
   }
 
   return schema;
-}
+};
 
 /**
  * Options for the request body validator middleware.
@@ -388,10 +388,10 @@ export interface RequestBodyValidatorOptions {
  * @param options - Optional configuration for this validator
  * @returns Express middleware function
  */
-export function validateRequestBody(
+export const validateRequestBody = (
   schema: Record<string, OpenApiSchemaProperty>,
   options?: RequestBodyValidatorOptions
-): (req: Request, res: Response, next: NextFunction) => void {
+): ((req: Request, res: Response, next: NextFunction) => void) => {
   const fullSchema = propertiesToSchema(schema, options?.required);
 
   return (req: Request, _res: Response, next: NextFunction): void => {
@@ -491,7 +491,7 @@ export function validateRequestBody(
 
     next();
   };
-}
+};
 
 /**
  * Options for the query parameter validator middleware.
@@ -515,10 +515,10 @@ export interface QueryValidatorOptions {
  * @param options - Optional configuration for this validator
  * @returns Express middleware function
  */
-export function validateQueryParams(
+export const validateQueryParams = (
   schema: Record<string, OpenApiSchemaProperty>,
   options?: QueryValidatorOptions
-): (req: Request, res: Response, next: NextFunction) => void {
+): ((req: Request, res: Response, next: NextFunction) => void) => {
   const fullSchema = propertiesToSchema(schema);
 
   return (req: Request, _res: Response, next: NextFunction): void => {
@@ -591,7 +591,7 @@ export function validateQueryParams(
 
     next();
   };
-}
+};
 
 /**
  * Options for creating a combined validation middleware.
@@ -630,9 +630,9 @@ export interface CreateValidatorOptions {
  * ], handler);
  * ```
  */
-export function createValidator(
+export const createValidator = (
   options: CreateValidatorOptions
-): (req: Request, res: Response, next: NextFunction) => void {
+): ((req: Request, res: Response, next: NextFunction) => void) => {
   const bodyValidator = options.body
     ? validateRequestBody(options.body, {enabled: options.enabled})
     : null;
@@ -663,7 +663,7 @@ export function createValidator(
       next();
     }
   };
-}
+};
 
 /**
  * Validates response data against a schema.
@@ -673,10 +673,10 @@ export function createValidator(
  * @param schema - The expected schema
  * @returns Object with valid flag and any errors
  */
-export function validateResponseData(
+export const validateResponseData = (
   data: unknown,
   schema: Record<string, OpenApiSchemaProperty>
-): {valid: boolean; errors?: ErrorObject[]} {
+): {valid: boolean; errors?: ErrorObject[]} => {
   if (!globalConfig.validateResponses) {
     return {valid: true};
   }
@@ -698,7 +698,7 @@ export function validateResponseData(
   }
 
   return {valid: true};
-}
+};
 
 const m2sOptions = {
   props: ["readOnly", "required", "enum", "default"],
@@ -712,19 +712,19 @@ const m2sOptions = {
  * @param model - A Mongoose model
  * @returns Schema properties suitable for validation
  */
-export function getSchemaFromModel<T>(model: Model<T>): Record<string, OpenApiSchemaProperty> {
+export const getSchemaFromModel = <T>(model: Model<T>): Record<string, OpenApiSchemaProperty> => {
   const modelSwagger = m2s(model, m2sOptions);
   fixMixedFields((model as any).schema, modelSwagger.properties);
   return modelSwagger.properties as Record<string, OpenApiSchemaProperty>;
-}
+};
 
 /**
  * Extract required field names from a Mongoose model's swagger schema.
  */
-function getRequiredFieldsFromModel<T>(model: Model<T>): string[] {
+const getRequiredFieldsFromModel = <T>(model: Model<T>): string[] => {
   const modelSwagger = m2s(model, m2sOptions);
   return (modelSwagger.required as string[]) ?? [];
-}
+};
 
 /**
  * Creates a request body validator middleware from a Mongoose model.
@@ -734,10 +734,10 @@ function getRequiredFieldsFromModel<T>(model: Model<T>): string[] {
  * @param options - Optional configuration for the validator
  * @returns Express middleware function
  */
-export function validateModelRequestBody<T>(
+export const validateModelRequestBody = <T>(
   model: Model<T>,
   options?: RequestBodyValidatorOptions
-): (req: Request, res: Response, next: NextFunction) => void {
+): ((req: Request, res: Response, next: NextFunction) => void) => {
   let schema = getSchemaFromModel(model);
   let requiredFields = getRequiredFieldsFromModel(model);
 
@@ -751,7 +751,7 @@ export function validateModelRequestBody<T>(
     ...options,
     required: [...(options?.required ?? []), ...requiredFields],
   });
-}
+};
 
 /**
  * Options for creating validation middleware for a modelRouter.
@@ -805,13 +805,13 @@ export interface ModelRouterValidationOptions {
  * @param options - Configuration options
  * @returns Object with create and update validation middleware
  */
-export function createModelValidators<T>(
+export const createModelValidators = <T>(
   model: Model<T>,
   options?: ModelRouterValidationOptions
 ): {
   create: (req: Request, res: Response, next: NextFunction) => void;
   update: (req: Request, res: Response, next: NextFunction) => void;
-} {
+} => {
   const schema = getSchemaFromModel(model);
 
   return {
@@ -826,7 +826,7 @@ export function createModelValidators<T>(
       onError: options?.onError,
     }),
   };
-}
+};
 
 /**
  * Build a query parameter schema from a model's Mongoose schema and queryFields array.
@@ -836,10 +836,10 @@ export function createModelValidators<T>(
  * @param queryFields - Array of field names allowed for querying
  * @returns Schema properties suitable for query validation
  */
-export function buildQuerySchemaFromFields<T>(
+export const buildQuerySchemaFromFields = <T>(
   model: Model<T>,
   queryFields: string[] = []
-): Record<string, OpenApiSchemaProperty> {
+): Record<string, OpenApiSchemaProperty> => {
   const modelSchema = getSchemaFromModel(model);
   const querySchema: Record<string, OpenApiSchemaProperty> = {
     limit: {type: "number"},
@@ -859,4 +859,4 @@ export function buildQuerySchemaFromFields<T>(
   }
 
   return querySchema;
-}
+};