@jaypie/testkit 1.0.29 → 1.1.1

package/dist/jsonApiSchema.module.d.ts

@@ -0,0 +1,61 @@
+import { JsonApiData, JsonApiError } from "./types/jaypie-testkit";
+export declare const jsonApiErrorSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly errors: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly status: {
+                        readonly type: "number";
+                    };
+                    readonly title: {
+                        readonly type: "string";
+                    };
+                    readonly detail: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["status", "title"];
+            };
+            readonly minItems: 1;
+        };
+    };
+    readonly required: readonly ["errors"];
+};
+export declare const jsonApiSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly data: {
+            readonly type: "object";
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                };
+                readonly type: {
+                    readonly type: "string";
+                };
+                readonly attributes: {
+                    readonly type: "object";
+                };
+                readonly links: {
+                    readonly type: "object";
+                };
+                readonly meta: {
+                    readonly type: "object";
+                };
+                readonly relationships: {
+                    readonly type: "object";
+                };
+            };
+            readonly required: readonly ["id", "type"];
+        };
+        readonly meta: {
+            readonly type: "object";
+        };
+    };
+    readonly required: readonly ["data"];
+};
+export declare const isJsonApiError: (obj: unknown) => obj is JsonApiError;
+export declare const isJsonApiData: (obj: unknown) => obj is JsonApiData;

package/dist/matchers/toBeCalledAboveTrace.matcher.d.ts

@@ -0,0 +1,3 @@
+import { LogMock, MatcherResult } from "../types/jaypie-testkit";
+declare const calledAboveTrace: (log: LogMock) => MatcherResult;
+export default calledAboveTrace;

package/dist/matchers/toBeCalledWithInitialParams.matcher.d.ts

@@ -0,0 +1,4 @@
+import { Mock } from "vitest";
+import { MatcherResult } from "../types/jaypie-testkit";
+declare const toBeCalledWithInitialParams: (received: Mock, ...passed: unknown[]) => MatcherResult;
+export default toBeCalledWithInitialParams;

package/dist/matchers/toBeClass.matcher.d.ts

@@ -0,0 +1,3 @@
+import { MatcherResult } from "../types/jaypie-testkit";
+declare const toBeClass: (received: unknown) => MatcherResult;
+export default toBeClass;

package/dist/matchers/toBeJaypieError.matcher.d.ts

@@ -0,0 +1,3 @@
+import { MatcherResult } from "../types/jaypie-testkit";
+declare const toBeJaypieError: (received: unknown) => MatcherResult;
+export default toBeJaypieError;

package/dist/matchers/toMatch.matcher.d.ts

@@ -0,0 +1,12 @@
+import { MatcherResult } from "../types/jaypie-testkit";
+export declare const toMatchBase64: (subject: string) => MatcherResult;
+export declare const toMatchJwt: (subject: string) => MatcherResult;
+export declare const toMatchMongoId: (subject: string) => MatcherResult;
+export declare const toMatchSignedCookie: (subject: string) => MatcherResult;
+export declare const toMatchUuid4: (subject: string) => MatcherResult;
+export declare const toMatchUuid5: (subject: string) => MatcherResult;
+/**
+ * Determines if subject matches a UUID pattern.
+ * Does _NOT_ check if the UUID is valid.
+ */
+export declare const toMatchUuid: (subject: string) => MatcherResult;

package/dist/matchers/toThrowError.matcher.d.ts

@@ -0,0 +1,4 @@
+import { MatcherResult } from "../types/jaypie-testkit";
+type ReceivedFunction = () => unknown | Promise<unknown>;
+declare const toThrowError: (received: ReceivedFunction) => Promise<MatcherResult>;
+export default toThrowError;

package/dist/matchers/toThrowJaypieError.matcher.d.ts

@@ -0,0 +1,16 @@
+import { ProjectError } from "@jaypie/core";
+import { MatcherResult } from "../types/jaypie-testkit";
+type ReceivedFunction = () => unknown | Promise<unknown>;
+type ErrorConstructor = new () => ProjectError;
+declare const toThrowJaypieError: (received: ReceivedFunction, expected?: ProjectError | (() => ProjectError) | ErrorConstructor) => Promise<MatcherResult>;
+declare const toThrowBadGatewayError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowBadRequestError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowConfigurationError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowForbiddenError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowGatewayTimeoutError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowInternalError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowNotFoundError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowUnauthorizedError: (received: ReceivedFunction) => Promise<MatcherResult>;
+declare const toThrowUnavailableError: (received: ReceivedFunction) => Promise<MatcherResult>;
+export default toThrowJaypieError;
+export { toThrowBadGatewayError, toThrowBadRequestError, toThrowConfigurationError, toThrowForbiddenError, toThrowGatewayTimeoutError, toThrowInternalError, toThrowNotFoundError, toThrowUnauthorizedError, toThrowUnavailableError, };

package/dist/matchers.module.d.ts

@@ -0,0 +1,25 @@
+declare const matchers: {
+    toBeCalledAboveTrace: (log: import("./types/jaypie-testkit.js").LogMock) => import("./types/jaypie-testkit.js").MatcherResult;
+    toBeCalledWithInitialParams: (received: import("vitest").Mock, ...passed: unknown[]) => import("./types/jaypie-testkit.js").MatcherResult;
+    toBeClass: (received: unknown) => import("./types/jaypie-testkit.js").MatcherResult;
+    toBeJaypieError: (received: unknown) => import("./types/jaypie-testkit.js").MatcherResult;
+    toMatchBase64: (subject: string) => import("./types/jaypie-testkit.js").MatcherResult;
+    toMatchJwt: (subject: string) => import("./types/jaypie-testkit.js").MatcherResult;
+    toMatchMongoId: (subject: string) => import("./types/jaypie-testkit.js").MatcherResult;
+    toMatchSignedCookie: (subject: string) => import("./types/jaypie-testkit.js").MatcherResult;
+    toMatchUuid: (subject: string) => import("./types/jaypie-testkit.js").MatcherResult;
+    toMatchUuid4: (subject: string) => import("./types/jaypie-testkit.js").MatcherResult;
+    toMatchUuid5: (subject: string) => import("./types/jaypie-testkit.js").MatcherResult;
+    toThrowBadGatewayError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowBadRequestError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowConfigurationError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowForbiddenError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowGatewayTimeoutError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowInternalError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowJaypieError: (received: () => unknown | Promise<unknown>, expected?: import("@jaypie/core").ProjectError | (() => import("@jaypie/core").ProjectError) | (new () => import("@jaypie/core").ProjectError)) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowNotFoundError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowUnauthorizedError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+    toThrowUnavailableError: (received: () => unknown | Promise<unknown>) => Promise<import("./types/jaypie-testkit.js").MatcherResult>;
+};
+export default matchers;

package/dist/mockLog.module.d.ts

@@ -0,0 +1,5 @@
+import { Log } from "@jaypie/core";
+import { LogMock } from "./types/jaypie-testkit";
+export declare function mockLogFactory(): LogMock;
+export declare function spyLog(log: Log): void;
+export declare function restoreLog(log: Log): void;

package/dist/sqsTestRecords.function.d.ts

@@ -0,0 +1,14 @@
+interface SQSEvent {
+    Records: Array<{
+        body: string;
+        messageId?: string | number;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Creates a mock SQS event with the given records
+ * @param records - Array of records or individual records to include in the event
+ * @returns SQS event object with Records array
+ */
+declare const sqsTestRecords: (...records: Array<unknown>) => SQSEvent;
+export default sqsTestRecords;

package/package.json

@@ -1,59 +1,52 @@
 {
   "name": "@jaypie/testkit",
-  "version": "1.0.29",
+  "version": "1.1.1",
+  "license": "MIT",
   "author": "Finlayson Studio",
   "type": "module",
   "exports": {
-    ".": "./src/index.js",
-    "./mock": "./src/jaypie.mock.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mock": {
+      "types": "./dist/jaypie.mock.d.ts",
+      "import": "./dist/jaypie.mock.js"
+    }
   },
-  "main": "src/index.js",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "format": "npm run format:package && npm run format:lint",
-    "format:lint": "eslint --fix .",
-    "format:package": "sort-package-json ./package.json",
-    "init:commander": "hygen jaypie commander-init",
-    "init:deploy": "hygen jaypie workflow-npm",
+    "build": "rollup --config",
+    "format": "eslint --fix .",
     "lint": "eslint .",
-    "new": "hygen jaypie vite",
-    "new:command": "hygen jaypie command",
-    "new:constants": "hygen jaypie constants",
-    "new:hygen": "hygen jaypie hygen",
-    "new:index": "hygen jaypie index",
-    "new:model": "hygen jaypie model",
-    "new:test": "hygen jaypie vitest",
-    "test": "vitest",
-    "test:spec:constants": "vitest run ./src/__tests__/constants.spec.js",
-    "test:spec:expressHandler.mock": "vitest run ./src/__tests__/expressHandler-supertest.mock.spec.js",
-    "test:spec:index": "vitest run ./src/__tests__/index.spec.js",
-    "test:spec:jaypie.mock": "vitest run ./src/__tests__/jaypie.mock.spec.js",
-    "test:spec:jsonApiSchema.module": "vitest run ./src/__tests__/jsonApiSchema.module.spec.js",
-    "test:spec:matchers.module": "vitest run ./src/__tests__/matchers.module.spec.js",
-    "test:spec:mockLog.module": "vitest run ./src/__tests__/mockLog.module.spec.js",
-    "test:spec:sqsTestRecords.function": "vitest run ./src/__tests__/sqsTestRecords.function.spec.js",
-    "test:spec:toBeCalledAboveTrace.matcher": "vitest run ./src/matchers/__tests__/toBeCalledAboveTrace.matcher.spec.js",
-    "test:spec:toBeCalledWithInitialParams.matcher": "vitest run ./src/matchers/__tests__/toBeCalledWithInitialParams.matcher.spec.js",
-    "test:spec:toBeClass.matcher": "vitest run ./src/matchers/__tests__/toBeClass.matcher.spec.js",
-    "test:spec:toBeJaypieError.matcher": "vitest run ./src/matchers/__tests__/toBeJaypieError.matcher.spec.js",
-    "test:spec:toMatch.matcher": "vitest run ./src/matchers/__tests__/toMatch.matcher.spec.js",
-    "test:spec:toThrowJaypieError.matcher": "vitest run ./src/matchers/__tests__/toThrowJaypieError.matcher.spec.js"
+    "test": "vitest run .",
+    "test:watch": "vitest watch ."
   },
   "dependencies": {
-    "@jaypie/core": "^1.0.33",
+    "@jaypie/core": "^1.1.0",
+    "@jaypie/eslint": "^1.1.6",
     "jaypie": "^1.0.44",
     "jest-json-schema": "^6.1.0",
     "lodash.isequal": "^4.5.0",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "eslint": "^8.57.0",
-    "eslint-config-jaypie": "^1.0.7",
-    "express": "^4.19.2",
-    "hygen": "^6.2.11",
-    "jest-extended": "^4.0.2",
-    "prettier": "^3.2.5",
-    "sort-package-json": "^2.8.0",
-    "supertest": "^7.0.0",
-    "vitest": "^1.4.0"
-  }
+    "@types/express": "^5.0.0",
+    "@types/lodash.isequal": "^4.5.8",
+    "@types/node": "^20.0.0",
+    "@types/supertest": "^6.0.2",
+    "express": "^4.21.1",
+    "rollup": "^4.29.1",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "8b953596e065e06c57e75082dc5d3a2267b6b8bd"
 }

package/src/constants.js

@@ -1,28 +0,0 @@
-//
-//
-// Constants
-//
-
-export const LOG = {
-  LEVEL: {
-    ALL: "all",
-    DEBUG: "debug",
-    ERROR: "error",
-    FATAL: "fatal",
-    INFO: "info",
-    SILENT: "silent",
-    TRACE: "trace",
-    WARN: "warn",
-  },
-};
-
-export const RE_BASE64_PATTERN = /^[a-zA-Z0-9\\+\\/]+$/;
-export const RE_JWT_PATTERN = /^([^.]+)\.([^.]+)\.([^.]+)$/;
-export const RE_MONGO_ID_PATTERN = /^[a-f0-9]{24}$/i;
-export const RE_SIGNED_COOKIE_PATTERN = /^s:([^.]+)\.([^.]+)$/;
-export const RE_UUID_4_PATTERN =
-  /^[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$/i;
-export const RE_UUID_5_PATTERN =
-  /^[a-f0-9]{8}-?[a-f0-9]{4}-?5[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$/i;
-export const RE_UUID_PATTERN =
-  /^[a-f0-9]{8}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$/i;

package/src/jaypie.mock.js

@@ -1,371 +0,0 @@
-import { getMessages as originalGetMessages } from "@jaypie/aws";
-import { force, uuid as originalUuid } from "@jaypie/core";
-import {
-  // Core utilities
-  HTTP,
-  JAYPIE,
-  log,
-  // Errors
-  BadGatewayError as BadGatewayErrorOriginal,
-  BadRequestError as BadRequestErrorOriginal,
-  ConfigurationError as ConfigurationErrorOriginal,
-  ForbiddenError as ForbiddenErrorOriginal,
-  GatewayTimeoutError as GatewayTimeoutErrorOriginal,
-  GoneError as GoneErrorOriginal,
-  IllogicalError as IllogicalErrorOriginal,
-  InternalError as InternalErrorOriginal,
-  MethodNotAllowedError as MethodNotAllowedErrorOriginal,
-  MultiError as MultiErrorOriginal,
-  NotFoundError as NotFoundErrorOriginal,
-  NotImplementedError as NotImplementedErrorOriginal,
-  ProjectError as ProjectErrorOriginal,
-  ProjectMultiError as ProjectMultiErrorOriginal,
-  RejectedError as RejectedErrorOriginal,
-  TeapotError as TeapotErrorOriginal,
-  UnauthorizedError as UnauthorizedErrorOriginal,
-  UnavailableError as UnavailableErrorOriginal,
-  UnhandledError as UnhandledErrorOriginal,
-  UnreachableCodeError as UnreachableCodeErrorOriginal,
-} from "@jaypie/core";
-import { beforeAll, vi } from "vitest";
-
-import { spyLog } from "./mockLog.module.js";
-
-//
-//
-// Setup
-//
-
-const TAG = JAYPIE.LIB.TESTKIT;
-
-// Export all the modules from Jaypie packages:
-
-export * from "@jaypie/aws";
-export * from "@jaypie/core";
-export * from "@jaypie/express";
-export * from "@jaypie/datadog";
-export * from "@jaypie/lambda";
-export * from "@jaypie/mongoose";
-
-// Spy on log:
-
-beforeAll(() => {
-  spyLog(log);
-});
-
-// afterEach(() => {
-// This is not necessary because the log isn't being used outside tests:
-// restoreLog(log);
-// The is the client's responsibility:
-// vi.clearAllMocks();
-// });
-
-//
-//
-// Mock Functions
-//
-
-// @jaypie/aws
-
-export const getMessages = vi.fn((...params) => originalGetMessages(...params));
-
-export const getSecret = vi.fn(() => {
-  return `_MOCK_SECRET_[${TAG}]`;
-});
-
-export const sendBatchMessages = vi.fn(() => {
-  // TODO: better default value
-  return { value: `_MOCK_BATCH_MESSAGES_[${TAG}]` };
-});
-
-export const sendMessage = vi.fn(() => {
-  // TODO: better default value
-  return { value: `_MOCK_MESSAGE_[${TAG}]` };
-});
-
-// @jaypie/core Errors
-
-export const BadGatewayError = vi.fn((...params) => {
-  return BadGatewayErrorOriginal(...params);
-});
-export const BadRequestError = vi.fn((...params) => {
-  return BadRequestErrorOriginal(...params);
-});
-export const ConfigurationError = vi.fn((...params) => {
-  return ConfigurationErrorOriginal(...params);
-});
-export const ForbiddenError = vi.fn((...params) => {
-  return ForbiddenErrorOriginal(...params);
-});
-export const GatewayTimeoutError = vi.fn((...params) => {
-  return GatewayTimeoutErrorOriginal(...params);
-});
-export const GoneError = vi.fn((...params) => {
-  return GoneErrorOriginal(...params);
-});
-export const IllogicalError = vi.fn((...params) => {
-  return IllogicalErrorOriginal(...params);
-});
-export const InternalError = vi.fn((...params) => {
-  return InternalErrorOriginal(...params);
-});
-export const MethodNotAllowedError = vi.fn((...params) => {
-  return MethodNotAllowedErrorOriginal(...params);
-});
-export const MultiError = vi.fn((...params) => {
-  return MultiErrorOriginal(...params);
-});
-export const NotFoundError = vi.fn((...params) => {
-  return NotFoundErrorOriginal(...params);
-});
-export const NotImplementedError = vi.fn((...params) => {
-  return NotImplementedErrorOriginal(...params);
-});
-export const ProjectError = vi.fn((...params) => {
-  return ProjectErrorOriginal(...params);
-});
-export const ProjectMultiError = vi.fn((...params) => {
-  return ProjectMultiErrorOriginal(...params);
-});
-export const RejectedError = vi.fn((...params) => {
-  return RejectedErrorOriginal(...params);
-});
-export const TeapotError = vi.fn((...params) => {
-  return TeapotErrorOriginal(...params);
-});
-export const UnauthorizedError = vi.fn((...params) => {
-  return UnauthorizedErrorOriginal(...params);
-});
-export const UnavailableError = vi.fn((...params) => {
-  return UnavailableErrorOriginal(...params);
-});
-export const UnhandledError = vi.fn((...params) => {
-  return UnhandledErrorOriginal(...params);
-});
-export const UnreachableCodeError = vi.fn((...params) => {
-  return UnreachableCodeErrorOriginal(...params);
-});
-
-// @jaypie/core Functions
-
-export const envBoolean = vi.fn(() => {
-  return true;
-});
-
-export const jaypieHandler = vi.fn(
-  (
-    handler,
-    {
-      setup = [],
-      teardown = [],
-      unavailable = force.boolean(process.env.PROJECT_UNAVAILABLE),
-      validate = [],
-    } = {},
-  ) => {
-    return async (...args) => {
-      let result;
-      let thrownError;
-      if (unavailable) throw new UnavailableError();
-      for (const validator of validate) {
-        if (typeof validator === "function") {
-          const valid = await validator(...args);
-          if (valid === false) {
-            throw new BadRequestError();
-          }
-        }
-      }
-      try {
-        for (const setupFunction of setup) {
-          if (typeof setupFunction === "function") {
-            await setupFunction(...args);
-          }
-        }
-        result = handler(...args);
-      } catch (error) {
-        thrownError = error;
-      }
-      for (const teardownFunction of teardown) {
-        if (typeof teardownFunction === "function") {
-          try {
-            await teardownFunction(...args);
-          } catch (error) {
-            // eslint-disable-next-line no-console
-            console.error(error);
-          }
-        }
-      }
-      if (thrownError) {
-        throw thrownError;
-      }
-      return result;
-    };
-  },
-);
-
-export const sleep = vi.fn(() => {
-  return true;
-});
-
-export const uuid = vi.fn(originalUuid);
-
-// @jaypie/datadog
-
-export const submitMetric = vi.fn(() => {
-  return true;
-});
-
-export const submitMetricSet = vi.fn(() => {
-  return true;
-});
-
-// @jaypie/express
-
-export const expressHandler = vi.fn((handler, props = {}) => {
-  // If handler is an object and options is a function, swap them
-  if (typeof handler === "object" && typeof props === "function") {
-    const temp = handler;
-    handler = props;
-    props = temp;
-  }
-  if (typeof handler !== "function") {
-    throw new BadRequestError("handler must be a function");
-  }
-  if (!props) {
-    props = {};
-  }
-  props.setup = force.array(props.setup); // allows a single item
-  props.teardown = force.array(props.teardown); // allows a single item
-  if (!Array.isArray(props.setup)) {
-    props.setup = [];
-  }
-  if (props.locals === null) {
-    throw new BadRequestError("locals cannot be null");
-  }
-  if (props.locals) {
-    if (typeof props.locals !== "object" || Array.isArray(props.locals)) {
-      throw new BadRequestError("locals must be an object");
-    }
-    // Locals
-    const keys = Object.keys(props.locals);
-    if (keys.length > 0) {
-      props.setup.push((req = {}) => {
-        if (typeof req !== "object") {
-          throw new BadRequestError("req must be an object");
-        }
-        // Set req.locals if it doesn't exist
-        if (!req.locals) req.locals = {};
-        if (typeof req.locals !== "object" || Array.isArray(req.locals)) {
-          throw new BadRequestError("req.locals must be an object");
-        }
-        if (!req.locals._jaypie) req.locals._jaypie = {};
-      });
-      const localsSetup = async (localsReq, localsRes) => {
-        for (let i = 0; i < keys.length; i += 1) {
-          const key = keys[i];
-          if (typeof props.locals[key] === "function") {
-            // eslint-disable-next-line no-await-in-loop
-            localsReq.locals[key] = await props.locals[key](
-              localsReq,
-              localsRes,
-            );
-          } else {
-            localsReq.locals[key] = props.locals[key];
-          }
-        }
-      };
-      props.setup.push(localsSetup);
-    }
-  }
-  const jaypieFunction = jaypieHandler(handler, props);
-  return async (req = {}, res = {}, ...extra) => {
-    const status = HTTP.CODE.OK;
-    let response;
-    let supertestMode = false;
-    if (
-      res &&
-      typeof res.socket === "object" &&
-      res.constructor.name === "ServerResponse"
-    ) {
-      // Use the response object in supertest mode
-      supertestMode = true;
-    }
-    try {
-      response = await jaypieFunction(req, res, ...extra);
-    } catch (error) {
-      // In the mock context, if status is a function we are in a "supertest"
-      if (supertestMode) {
-        // In theory jaypieFunction has handled all errors
-        const errorStatus = error.status || HTTP.CODE.INTERNAL_SERVER_ERROR;
-        let errorResponse;
-        if (typeof error.json === "function") {
-          errorResponse = error.json();
-        } else {
-          // This should never happen
-          errorResponse = new UnhandledError().json();
-        }
-        res.status(errorStatus).json(errorResponse);
-        return;
-      } else {
-        // else, res.status is not a function, throw the error
-        throw error;
-      }
-    }
-    if (supertestMode) {
-      if (response) {
-        // res.status(200);
-        if (typeof response === "object") {
-          if (typeof response.json === "function") {
-            res.json(response.json());
-          } else {
-            res.status(status).json(response);
-          }
-        } else if (typeof response === "string") {
-          try {
-            res.status(status).json(JSON.parse(response));
-          } catch (error) {
-            if (supertestMode) {
-              res.status(status).send(response);
-            }
-          }
-        } else if (response === true) {
-          res.status(HTTP.CODE.CREATED).send();
-        } else {
-          res.status(status).send(response);
-        }
-      } else {
-        res.status(HTTP.CODE.NO_CONTENT).send();
-      }
-    } else {
-      return response;
-    }
-  };
-});
-
-// @jaypie/lambda
-
-// For testing, this is the same as the jaypieHandler
-export const lambdaHandler = vi.fn((handler, props = {}) => {
-  // If handler is an object and options is a function, swap them
-  if (typeof handler === "object" && typeof props === "function") {
-    const temp = handler;
-    handler = props;
-    props = temp;
-  }
-  return async (event, context, ...extra) => {
-    return jaypieHandler(handler, props)(event, context, ...extra);
-  };
-});
-
-// @jaypie/mongoose
-
-export const connect = vi.fn(() => {
-  return true;
-});
-
-export const connectFromSecretEnv = vi.fn(() => {
-  return true;
-});
-
-export const disconnect = vi.fn(() => {
-  return true;
-});