@jaypie/testkit 1.1.26 → 1.1.28

package/dist/mock/index.js

@@ -0,0 +1,820 @@
+import * as original from '@jaypie/aws';
+import { vi, beforeAll } from 'vitest';
+import * as original$1 from '@jaypie/core';
+import { log, BadRequestError as BadRequestError$1, UnhandledError as UnhandledError$1 } from '@jaypie/core';
+export { log } from '@jaypie/core';
+import * as original$2 from '@jaypie/datadog';
+import * as original$3 from '@jaypie/express';
+import * as original$4 from '@jaypie/llm';
+import { mongoose as mongoose$1 } from '@jaypie/mongoose';
+export { mongoose } from '@jaypie/mongoose';
+import { readFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { TextractDocument } from 'amazon-textract-response-parser';
+import * as original$5 from '@jaypie/textract';
+
+/**
+ * Internal wrapper for vi.fn() that adds _jaypie: true to all mocks
+ */
+function _createJaypieMock(implementation) {
+    const mock = vi.fn(implementation);
+    Object.defineProperty(mock, "_jaypie", { value: true });
+    return mock;
+}
+/**
+ * Creates function mocks with proper typing
+ * Internal utility to create properly typed mocks
+ */
+function createMockFunction(implementation) {
+    // Use a more specific type conversion to avoid TypeScript error
+    return _createJaypieMock(implementation);
+}
+/**
+ * Creates a mock function that resolves to a value when awaited
+ * Internal utility to create async mock functions
+ */
+function createMockResolvedFunction(value) {
+    return _createJaypieMock().mockResolvedValue(value);
+}
+/**
+ * Creates a mock function that returns a value
+ * Internal utility to create mock functions that return a value
+ */
+function createMockReturnedFunction(value) {
+    return _createJaypieMock().mockReturnValue(value);
+}
+/**
+ * Creates a mock function that wraps another function
+ * Internal utility to create mock functions that wrap another function
+ */
+function createMockWrappedFunction(fn, fallbackOrOptions = "_MOCK_WRAPPED_RESULT") {
+    // Determine if we have a direct fallback or options object
+    const options = typeof fallbackOrOptions === "object" &&
+        fallbackOrOptions !== null &&
+        ("fallback" in fallbackOrOptions ||
+            "throws" in fallbackOrOptions ||
+            "class" in fallbackOrOptions)
+        ? fallbackOrOptions
+        : { fallback: fallbackOrOptions };
+    // Extract values with defaults
+    const fallback = options.fallback ?? "_MOCK_WRAPPED_RESULT";
+    const throws = options.throws ?? false;
+    const isClass = options.class ?? false;
+    return _createJaypieMock().mockImplementation((...args) => {
+        try {
+            return isClass ? new fn(...args) : fn(...args);
+        }
+        catch (error) {
+            if (throws) {
+                throw error;
+            }
+            console.warn(`[@jaypie/testkit] Actual implementation failed. To suppress this warning, manually mock the response with mockReturnValue`);
+            if (error instanceof Error) {
+                console.warn(`[@jaypie/testkit] ${error.message}`);
+            }
+            // If fallback is a function, call it
+            if (typeof fallback === "function") {
+                try {
+                    return fallback(...args);
+                }
+                catch (fallbackError) {
+                    console.warn(`[@jaypie/testkit] Fallback function failed: ${fallbackError instanceof Error ? fallbackError.message : fallbackError}`);
+                    return "_MOCK_WRAPPED_RESULT";
+                }
+            }
+            return fallback;
+        }
+    });
+}
+function createMockWrappedObject(object, fallbackOrOptions = "_MOCK_WRAPPED_RESULT") {
+    let returnMock = {};
+    // Extract values with defaults for the top-level call
+    const options = typeof fallbackOrOptions === "object" &&
+        fallbackOrOptions !== null &&
+        ("fallback" in fallbackOrOptions ||
+            "throws" in fallbackOrOptions ||
+            "class" in fallbackOrOptions)
+        ? fallbackOrOptions
+        : { fallback: fallbackOrOptions };
+    const fallback = options.fallback ?? "_MOCK_WRAPPED_RESULT";
+    const throws = options.throws ?? false;
+    const isClass = options.class ?? false;
+    // Create options for recursive calls
+    // Do not pass down class=true to nested objects
+    const recursiveOptions = {
+        fallback,
+        throws,
+        class: false, // Always pass class=false to nested objects
+    };
+    if (typeof object === "function") {
+        returnMock = createMockWrappedFunction(object, {
+            fallback,
+            throws,
+            class: isClass,
+        });
+    }
+    for (const key of Object.keys(object)) {
+        const value = object[key];
+        if (typeof value === "function") {
+            returnMock[key] = createMockWrappedFunction(value, {
+                fallback,
+                throws,
+                class: isClass,
+            });
+        }
+        else if (typeof value === "object" && value !== null) {
+            returnMock[key] = createMockWrappedObject(value, recursiveOptions);
+        }
+        else {
+            returnMock[key] = value;
+        }
+    }
+    return returnMock;
+}
+/**
+ * Utility to create a mock error constructor from an error class
+ */
+function createMockError(ErrorClass) {
+    // Create a mock constructor that returns a new instance of ErrorClass
+    const mockConstructor = _createJaypieMock(function (...args) {
+        return new ErrorClass(...args);
+    });
+    return mockConstructor;
+}
+
+// Constants for mock values
+const TAG$4 = "AWS";
+const getMessages = createMockWrappedFunction(original.getMessages, []);
+const getSecret = createMockResolvedFunction("mock-secret-value");
+const sendMessage = createMockResolvedFunction({
+    MessageId: "mock-message-id",
+});
+// Add missing functions from original implementation
+const getEnvSecret = createMockFunction(async (key) => `_MOCK_ENV_SECRET_[${TAG$4}][${key}]`);
+const getSingletonMessage = createMockWrappedFunction(original.getSingletonMessage, { value: "_MOCK_SINGLETON_MESSAGE_" });
+const getTextractJob = createMockFunction(async (job) => ({ value: `_MOCK_TEXTRACT_JOB_[${job}]` }));
+const sendBatchMessages = createMockResolvedFunction(true);
+const sendTextractJob = createMockFunction(async ({ bucket, key, featureTypes = [] }) => {
+    // Basic validation to mimic original behavior
+    if (!bucket || !key) {
+        throw new Error("Bucket and key are required");
+    }
+    return [`_MOCK_TEXTRACT_JOB_ID_[${TAG$4}]_${bucket}_${key}`];
+});
+
+var aws = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getEnvSecret: getEnvSecret,
+    getMessages: getMessages,
+    getSecret: getSecret,
+    getSingletonMessage: getSingletonMessage,
+    getTextractJob: getTextractJob,
+    sendBatchMessages: sendBatchMessages,
+    sendMessage: sendMessage,
+    sendTextractJob: sendTextractJob
+});
+
+function mockLogFactory() {
+    // Create skeleton of mock objects
+    const mock = {
+        debug: vi.fn(),
+        error: vi.fn(),
+        fatal: vi.fn(),
+        info: vi.fn(),
+        init: vi.fn(),
+        lib: vi.fn(),
+        tag: vi.fn(),
+        trace: vi.fn(),
+        untag: vi.fn(),
+        var: vi.fn(),
+        warn: vi.fn(),
+        with: vi.fn(),
+    };
+    // Fill out nested mocks
+    mock.debug.var = mock.var;
+    mock.error.var = mock.var;
+    mock.fatal.var = mock.var;
+    mock.info.var = mock.var;
+    mock.trace.var = mock.var;
+    mock.warn.var = mock.var;
+    // Have modules return correct objects
+    mock.init.mockReturnValue(null);
+    mock.lib.mockReturnValue(mock);
+    mock.with.mockReturnValue(mock);
+    // Pin mocks to the module
+    mock.mock = {
+        debug: mock.debug,
+        error: mock.error,
+        fatal: mock.fatal,
+        info: mock.info,
+        init: mock.init,
+        lib: mock.lib,
+        tag: mock.tag,
+        trace: mock.trace,
+        untag: mock.untag,
+        var: mock.var,
+        warn: mock.warn,
+        with: mock.with,
+    };
+    return mock;
+}
+const LOG_METHOD_NAMES = [
+    "debug",
+    "error",
+    "fatal",
+    "info",
+    "init",
+    "lib",
+    "tag",
+    "trace",
+    "untag",
+    "var",
+    "warn",
+    "with",
+];
+// Use Record type for more flexible access pattern
+const originalLogMethods = new WeakMap();
+function spyLog(logInstance) {
+    if (!originalLogMethods.has(logInstance)) {
+        const mockLog = mockLogFactory();
+        const originalMethods = {};
+        // Save only methods that actually exist on the log instance
+        LOG_METHOD_NAMES.forEach((method) => {
+            if (method in logInstance) {
+                originalMethods[method] =
+                    logInstance[method];
+                // Use type assertion after checking existence
+                logInstance[method] = mockLog[method];
+            }
+        });
+        originalLogMethods.set(logInstance, originalMethods);
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+// Constants for mock values
+const TAG$3 = "CORE";
+const BadGatewayError = createMockError(original$1.BadGatewayError);
+const BadRequestError = createMockError(original$1.BadRequestError);
+const ConfigurationError = createMockError(original$1.ConfigurationError);
+const ForbiddenError = createMockError(original$1.ForbiddenError);
+const GatewayTimeoutError = createMockError(original$1.GatewayTimeoutError);
+const GoneError = createMockError(original$1.GoneError);
+const IllogicalError = createMockError(original$1.IllogicalError);
+const InternalError = createMockError(original$1.InternalError);
+const MethodNotAllowedError = createMockError(original$1.MethodNotAllowedError);
+const MultiError = createMockError(original$1.MultiError);
+const NotFoundError = createMockError(original$1.NotFoundError);
+const NotImplementedError = createMockError(original$1.NotImplementedError);
+const ProjectError = createMockError(original$1.ProjectError);
+const ProjectMultiError = createMockError(original$1.ProjectMultiError);
+const RejectedError = createMockError(original$1.RejectedError);
+const TeapotError = createMockError(original$1.TeapotError);
+const UnauthorizedError = createMockError(original$1.UnauthorizedError);
+const UnavailableError = createMockError(original$1.UnavailableError);
+const UnhandledError = createMockError(original$1.UnhandledError);
+const UnreachableCodeError = createMockError(original$1.UnreachableCodeError);
+// Mock core functions
+const validate = createMockWrappedObject(original$1.validate, {
+    fallback: false,
+    throws: true,
+});
+beforeAll(async () => {
+    spyLog(log);
+});
+// Add missing core functions
+const cloneDeep = createMockWrappedFunction(original$1.cloneDeep, {
+    throws: true,
+});
+const envBoolean = createMockReturnedFunction(true);
+const envsKey = createMockWrappedFunction(original$1.envsKey, `_MOCK_ENVS_KEY_[${TAG$3}]`);
+const errorFromStatusCode = createMockFunction((statusCode, message = `Mock error for status code ${statusCode}`) => {
+    try {
+        // Try to mimic original implementation
+        switch (statusCode) {
+            case 400:
+                return new BadRequestError(message);
+            case 401:
+                return new UnauthorizedError(message);
+            case 403:
+                return new ForbiddenError(message);
+            case 404:
+                return new NotFoundError(message);
+            case 405:
+                return new MethodNotAllowedError(message);
+            case 410:
+                return new GoneError(message);
+            case 418:
+                return new TeapotError(message);
+            case 500:
+                return new InternalError(message);
+            case 501:
+                return new NotImplementedError(message);
+            case 502:
+                return new BadGatewayError(message);
+            case 503:
+                return new UnavailableError(message);
+            case 504:
+                return new GatewayTimeoutError(message);
+            default:
+                return new Error(message);
+        }
+    }
+    catch (error) {
+        return new Error(`_MOCK_ERROR_FROM_STATUS_CODE_[${TAG$3}][${statusCode}]`);
+    }
+});
+const formatError = createMockWrappedFunction(original$1.formatError, `_MOCK_FORMAT_ERROR_[${TAG$3}]`);
+const getHeaderFrom = createMockWrappedFunction(original$1.getHeaderFrom, `_MOCK_GET_HEADER_FROM_[${TAG$3}]`);
+const getObjectKeyCaseInsensitive = createMockWrappedFunction(original$1.getObjectKeyCaseInsensitive, `_MOCK_GET_OBJECT_KEY_CASE_INSENSITIVE_[${TAG$3}]`);
+const isClass = createMockWrappedFunction(original$1.isClass, `_MOCK_IS_CLASS_[${TAG$3}]`);
+const isJaypieError = createMockWrappedFunction(original$1.isJaypieError, false);
+// Optional/Required validation functions
+const optional = createMockWrappedObject(original$1.optional, {
+    fallback: true,
+    throws: true,
+});
+const required = createMockWrappedObject(original$1.required, {
+    fallback: true,
+    throws: true,
+});
+const resolveValue = createMockWrappedFunction(original$1.resolveValue, `_MOCK_RESOLVE_VALUE_[${TAG$3}]`);
+const safeParseFloat = createMockWrappedFunction(original$1.safeParseFloat, `_MOCK_SAFE_PARSE_FLOAT_[${TAG$3}]`);
+const placeholders = createMockWrappedFunction(original$1.placeholders, `_MOCK_PLACEHOLDERS_[${TAG$3}]`);
+// Add force utilities to help with jaypieHandler implementation
+const force = createMockWrappedObject(original$1.force);
+const jaypieHandler = createMockFunction((handler, options = {}) => {
+    return async (...args) => {
+        let result;
+        let thrownError;
+        // Destructure options with defaults
+        const { setup = [], teardown = [], unavailable = original$1.force.boolean(process.env.PROJECT_UNAVAILABLE), validate = [], } = options;
+        // Check if service is unavailable
+        if (unavailable)
+            throw new UnavailableError("Service unavailable");
+        // Run validation functions
+        const validateFunctions = original$1.force.array(validate);
+        for (const validator of validateFunctions) {
+            if (typeof validator === "function") {
+                const valid = await validator(...args);
+                if (valid === false) {
+                    throw new BadRequestError("Validation failed");
+                }
+            }
+        }
+        try {
+            // Run setup functions
+            const setupFunctions = original$1.force.array(setup);
+            for (const setupFunction of setupFunctions) {
+                if (typeof setupFunction === "function") {
+                    await setupFunction(...args);
+                }
+            }
+            // Execute the handler
+            result = await handler(...args);
+        }
+        catch (error) {
+            thrownError = error;
+        }
+        // Run teardown functions (always run even if there was an error)
+        const teardownFunctions = original$1.force.array(teardown);
+        for (const teardownFunction of teardownFunctions) {
+            if (typeof teardownFunction === "function") {
+                try {
+                    await teardownFunction(...args);
+                }
+                catch (error) {
+                    // Swallow teardown errors, but log them
+                    console.error(error);
+                }
+            }
+        }
+        // If there was an error in the handler, throw it after teardown
+        if (thrownError) {
+            throw thrownError;
+        }
+        return result;
+    };
+});
+const sleep = createMockResolvedFunction(true);
+const uuid = createMockWrappedFunction(original$1.uuid, `00000000-0000-0000-0000-000000000000`);
+const ERROR = original$1.ERROR;
+const HTTP$1 = original$1.HTTP;
+const JAYPIE = original$1.JAYPIE;
+const PROJECT = original$1.PROJECT;
+const VALIDATE = original$1.VALIDATE;
+
+var core = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BadGatewayError: BadGatewayError,
+    BadRequestError: BadRequestError,
+    ConfigurationError: ConfigurationError,
+    ERROR: ERROR,
+    ForbiddenError: ForbiddenError,
+    GatewayTimeoutError: GatewayTimeoutError,
+    GoneError: GoneError,
+    HTTP: HTTP$1,
+    IllogicalError: IllogicalError,
+    InternalError: InternalError,
+    JAYPIE: JAYPIE,
+    MethodNotAllowedError: MethodNotAllowedError,
+    MultiError: MultiError,
+    NotFoundError: NotFoundError,
+    NotImplementedError: NotImplementedError,
+    PROJECT: PROJECT,
+    ProjectError: ProjectError,
+    ProjectMultiError: ProjectMultiError,
+    RejectedError: RejectedError,
+    TeapotError: TeapotError,
+    UnauthorizedError: UnauthorizedError,
+    UnavailableError: UnavailableError,
+    UnhandledError: UnhandledError,
+    UnreachableCodeError: UnreachableCodeError,
+    VALIDATE: VALIDATE,
+    cloneDeep: cloneDeep,
+    envBoolean: envBoolean,
+    envsKey: envsKey,
+    errorFromStatusCode: errorFromStatusCode,
+    force: force,
+    formatError: formatError,
+    getHeaderFrom: getHeaderFrom,
+    getObjectKeyCaseInsensitive: getObjectKeyCaseInsensitive,
+    isClass: isClass,
+    isJaypieError: isJaypieError,
+    jaypieHandler: jaypieHandler,
+    log: log,
+    optional: optional,
+    placeholders: placeholders,
+    required: required,
+    resolveValue: resolveValue,
+    safeParseFloat: safeParseFloat,
+    sleep: sleep,
+    uuid: uuid,
+    validate: validate
+});
+
+const DATADOG = original$2.DATADOG;
+const submitMetric = createMockResolvedFunction(true);
+const submitMetricSet = createMockResolvedFunction(true);
+
+var datadog = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DATADOG: DATADOG,
+    submitMetric: submitMetric,
+    submitMetricSet: submitMetricSet
+});
+
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+// Constants for mock values
+const TAG$2 = "EXPRESS";
+const HTTP = {
+    CODE: { OK: 200, CREATED: 201, NO_CONTENT: 204, INTERNAL_ERROR: 500 },
+};
+const EXPRESS = original$3.EXPRESS;
+// Add Express route functions
+const badRequestRoute = createMockWrappedFunction(original$3.badRequestRoute, { error: `_MOCK_BAD_REQUEST_ROUTE_[${TAG$2}]` });
+const echoRoute = createMockWrappedFunction(original$3.echoRoute, (req) => req);
+const forbiddenRoute = createMockWrappedFunction(original$3.forbiddenRoute, { error: `_MOCK_FORBIDDEN_ROUTE_[${TAG$2}]` });
+const goneRoute = createMockWrappedFunction(original$3.goneRoute, {
+    error: `_MOCK_GONE_ROUTE_[${TAG$2}]`,
+});
+const methodNotAllowedRoute = createMockWrappedFunction(original$3.methodNotAllowedRoute, { error: `_MOCK_METHOD_NOT_ALLOWED_ROUTE_[${TAG$2}]` });
+const noContentRoute = createMockWrappedFunction(original$3.noContentRoute, { status: 204 });
+const notFoundRoute = createMockWrappedFunction(original$3.notFoundRoute, {
+    error: `_MOCK_NOT_FOUND_ROUTE_[${TAG$2}]`,
+});
+const notImplementedRoute = createMockWrappedFunction(original$3.notImplementedRoute, { error: `_MOCK_NOT_IMPLEMENTED_ROUTE_[${TAG$2}]` });
+const expressHttpCodeHandler = createMockWrappedFunction(original$3.expressHttpCodeHandler, (...args) => {
+    const [req, res, next] = args;
+    return res.status(200).send();
+});
+const cors = createMockWrappedFunction(original$3.cors);
+const expressHandler = createMockFunction((handlerOrProps, propsOrHandler) => {
+    let handler;
+    let props;
+    if (typeof handlerOrProps === "object" &&
+        typeof propsOrHandler === "function") {
+        handler = propsOrHandler;
+        props = handlerOrProps;
+    }
+    else if (typeof handlerOrProps === "function") {
+        handler = handlerOrProps;
+        props = (propsOrHandler || {});
+    }
+    else {
+        throw new BadRequestError$1("handler must be a function");
+    }
+    // Add locals setup if needed
+    if (props.locals &&
+        typeof props.locals === "object" &&
+        !Array.isArray(props.locals)) {
+        const keys = Object.keys(props.locals);
+        if (!props.setup)
+            props.setup = [];
+        props.setup = force.array(props.setup);
+        // @ts-expect-error TODO: cannot resolve; fix when JaypieHandler moves to TypeScript
+        props.setup.unshift((req) => {
+            if (!req || typeof req !== "object") {
+                throw new BadRequestError$1("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$1("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") {
+                    localsReq.locals[key] = await props.locals[key](localsReq, localsRes);
+                }
+                else {
+                    localsReq.locals[key] = props.locals[key];
+                }
+            }
+        };
+        props.setup.push(localsSetup);
+    }
+    if (props.locals && typeof props.locals !== "object") {
+        throw new BadRequestError$1("props.locals must be an object");
+    }
+    if (props.locals && Array.isArray(props.locals)) {
+        throw new BadRequestError$1("props.locals must be an object");
+    }
+    if (props.locals === null) {
+        throw new BadRequestError$1("props.locals must be an object");
+    }
+    const jaypieFunction = jaypieHandler(handler, props);
+    return async (req = {}, res = {}, ...extra) => {
+        const status = HTTP.CODE.OK;
+        let response;
+        let supertestMode = false;
+        if (res &&
+            typeof res === "object" &&
+            "socket" in res &&
+            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 && typeof res.status === "function") {
+                // In theory jaypieFunction has handled all errors
+                const errorStatus = error.status || HTTP.CODE.INTERNAL_ERROR;
+                let errorResponse;
+                if (typeof error.json === "function") {
+                    errorResponse = error.json();
+                }
+                else {
+                    // This should never happen
+                    errorResponse = new UnhandledError$1().json();
+                }
+                res.status(errorStatus).json(errorResponse);
+                return;
+            }
+            else {
+                // else, res.status is not a function, throw the error
+                throw error;
+            }
+        }
+        if (supertestMode && typeof res.status === "function") {
+            if (response) {
+                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) {
+                        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;
+        }
+    };
+});
+
+var express = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    EXPRESS: EXPRESS,
+    badRequestRoute: badRequestRoute,
+    cors: cors,
+    echoRoute: echoRoute,
+    expressHandler: expressHandler,
+    expressHttpCodeHandler: expressHttpCodeHandler,
+    forbiddenRoute: forbiddenRoute,
+    goneRoute: goneRoute,
+    methodNotAllowedRoute: methodNotAllowedRoute,
+    noContentRoute: noContentRoute,
+    notFoundRoute: notFoundRoute,
+    notImplementedRoute: notImplementedRoute
+});
+
+// Mock implementation of lambdaHandler that follows the original implementation pattern
+const lambdaHandler = createMockFunction((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);
+    };
+});
+
+var lambda = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    lambdaHandler: lambdaHandler
+});
+
+// Constants for mock values
+const TAG$1 = "LLM";
+const LLM = original$4.LLM;
+const mockOperate = createMockResolvedFunction({
+    history: [
+        {
+            content: "_MOCK_USER_INPUT",
+            role: "user",
+            type: "message",
+        },
+        {
+            id: "_MOCK_MESSAGE_ID",
+            type: "message",
+            status: "completed",
+            content: "_MOCK_CONTENT",
+            role: "assistant",
+        },
+    ],
+    output: [
+        {
+            id: "_MOCK_MESSAGE_ID",
+            type: "message",
+            status: "completed",
+            content: "_MOCK_CONTENT",
+            role: "assistant",
+        },
+    ],
+    responses: [
+        {
+            id: "_MOCK_RESPONSE_ID",
+            object: "response",
+            created_at: Date.now() / 1000,
+            status: "completed",
+            error: null,
+            output_text: "_MOCK_OUTPUT_TEXT",
+        },
+    ],
+    status: "completed",
+    usage: { input: 100, output: 20, reasoning: 0, total: 120 },
+    content: "_MOCK_OUTPUT_TEXT",
+});
+const mockSend = createMockResolvedFunction("_MOCK_LLM_RESPONSE");
+const Llm = Object.assign(vi.fn().mockImplementation((providerName = "_MOCK_LLM_PROVIDER") => ({
+    _provider: providerName,
+    _llm: {
+        operate: mockOperate,
+        send: mockSend,
+    },
+    operate: mockOperate,
+    send: mockSend,
+})), {
+    operate: mockOperate,
+    send: mockSend,
+});
+// Tool implementations - always return mock values
+const random = createMockReturnedFunction(0.5);
+const roll = createMockReturnedFunction(6);
+const time = createMockReturnedFunction(`_MOCK_TIME_[${TAG$1}]`);
+const weather = createMockResolvedFunction({
+    location: `_MOCK_WEATHER_LOCATION_[${TAG$1}]`,
+    forecast: Array(7)
+        .fill(0)
+        .map((_, i) => ({
+        date: `2025-05-${i + 1}`,
+        temperature: 72,
+        condition: "Sunny",
+        precipitation: 0,
+    })),
+});
+// Tool collections
+const toolkit = {
+    random,
+    roll,
+    time,
+    weather,
+};
+const Toolkit = createMockWrappedObject(original$4.Toolkit, {
+    isClass: true,
+});
+const tools = Object.values(toolkit);
+
+var llm = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LLM: LLM,
+    Llm: Llm,
+    Toolkit: Toolkit,
+    toolkit: toolkit,
+    tools: tools
+});
+
+// Mongoose mock functions
+const connect = createMockReturnedFunction(true);
+const connectFromSecretEnv = createMockReturnedFunction(true);
+const disconnect = createMockReturnedFunction(true);
+
+var mongoose = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    connect: connect,
+    connectFromSecretEnv: connectFromSecretEnv,
+    disconnect: disconnect,
+    mongoose: mongoose$1
+});
+
+// Constants for mock values
+const TAG = "TEXTRACT";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const MOCK_TEXTRACT_DOCUMENT_PATH = join(__dirname, "..", "mockTextract.json");
+// Setup
+let mockTextractContents;
+beforeAll(async () => {
+    mockTextractContents = await readFile(MOCK_TEXTRACT_DOCUMENT_PATH, "utf-8");
+});
+/**
+ * Mock for MarkdownPage class from @jaypie/textract
+ */
+const MarkdownPage = createMockWrappedObject(original$5.MarkdownPage, {
+    class: true,
+    fallback: () => {
+        const mockDocument = new TextractDocument(JSON.parse(mockTextractContents));
+        // Double type assertion needed to bridge incompatible types
+        return new original$5.MarkdownPage(mockDocument.pageNumber(1));
+    },
+});
+/**
+ * Mock for textractJsonToMarkdown function from @jaypie/textract
+ */
+const textractJsonToMarkdown = createMockWrappedFunction(original$5.textractJsonToMarkdown, `_MOCK_TEXTRACT_JSON_TO_MARKDOWN_[${TAG}]`);
+// Export default for convenience
+var textract = {
+    MarkdownPage,
+    textractJsonToMarkdown,
+};
+
+var textract$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MarkdownPage: MarkdownPage,
+    default: textract,
+    textractJsonToMarkdown: textractJsonToMarkdown
+});
+
+// Import all mocks
+// Export default object with all mocks
+var index = {
+    // AWS module
+    ...aws,
+    // Core module
+    ...core,
+    // Datadog module
+    ...datadog,
+    // Express module
+    ...express,
+    // Lambda module
+    ...lambda,
+    // LLM module
+    ...llm,
+    // Mongoose module (now empty)
+    ...mongoose,
+    // Textract module
+    ...textract$1,
+};
+
+export { BadGatewayError, BadRequestError, ConfigurationError, DATADOG, ERROR, EXPRESS, ForbiddenError, GatewayTimeoutError, GoneError, HTTP$1 as HTTP, IllogicalError, InternalError, JAYPIE, LLM, Llm, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, VALIDATE, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, index as default, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, forbiddenRoute, force, formatError, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getSecret, getSingletonMessage, getTextractJob, goneRoute, isClass, isJaypieError, jaypieHandler, lambdaHandler, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, optional, placeholders, required, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid, validate };
+//# sourceMappingURL=index.js.map