@jaypie/testkit 1.2.4 → 1.2.9

package/dist/mock/index.js

@@ -6,15 +6,16 @@ import * as errors from '@jaypie/errors';
 import { BadRequestError as BadRequestError$1, UnhandledError as UnhandledError$1 } from '@jaypie/errors';
 import * as kit$1 from '@jaypie/kit';
 import * as original$1 from '@jaypie/datadog';
-import * as original$2 from '@jaypie/express';
-import * as original$3 from '@jaypie/llm';
+import * as original$2 from '@jaypie/dynamodb';
+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$4 from '@jaypie/textract';
+import * as original$5 from '@jaypie/textract';
 
 /* eslint-disable no-console */
 /**
@@ -593,31 +594,123 @@ var datadog = /*#__PURE__*/Object.freeze({
     submitMetricSet: submitMetricSet
 });
 
+// Re-export constants (no need to mock, just pass through)
+const APEX = original$2.APEX;
+const ARCHIVED_SUFFIX = original$2.ARCHIVED_SUFFIX;
+const DELETED_SUFFIX = original$2.DELETED_SUFFIX;
+const INDEX_ALIAS = original$2.INDEX_ALIAS;
+const INDEX_CLASS = original$2.INDEX_CLASS;
+const INDEX_OU = original$2.INDEX_OU;
+const INDEX_TYPE = original$2.INDEX_TYPE;
+const INDEX_XID = original$2.INDEX_XID;
+const SEPARATOR = original$2.SEPARATOR;
+// Key builder functions - use createMockFunction with typed implementations
+const buildIndexAlias = createMockFunction((ou, model, alias) => original$2.buildIndexAlias(ou, model, alias));
+const buildIndexClass = createMockFunction((ou, model, recordClass) => original$2.buildIndexClass(ou, model, recordClass));
+const buildIndexOu = createMockFunction((ou, model) => original$2.buildIndexOu(ou, model));
+const buildIndexType = createMockFunction((ou, model, type) => original$2.buildIndexType(ou, model, type));
+const buildIndexXid = createMockFunction((ou, model, xid) => original$2.buildIndexXid(ou, model, xid));
+const calculateOu = createMockFunction((parent) => original$2.calculateOu(parent));
+const indexEntity = createMockFunction((entity, suffix) => original$2.indexEntity(entity, suffix));
+// Client functions
+const initClient = createMockFunction(() => {
+    // No-op in mock
+});
+const getDocClient = createMockFunction(() => ({
+    send: createMockResolvedFunction({ Items: [] }),
+}));
+const getTableName = createMockFunction(() => "mock-table");
+const isInitialized = createMockFunction(() => true);
+const resetClient = createMockFunction(() => {
+    // No-op in mock
+});
+// Entity operations - service handler pattern (callable with object params)
+const getEntity = createMockFunction(async () => null);
+const putEntity = createMockFunction(async (params) => original$2.indexEntity(params.entity));
+const updateEntity = createMockFunction(async (params) => ({
+    ...original$2.indexEntity(params.entity),
+    updatedAt: new Date().toISOString(),
+}));
+const deleteEntity = createMockFunction(async () => true);
+const archiveEntity = createMockFunction(async () => true);
+const destroyEntity = createMockFunction(async () => true);
+// Query functions - service handler pattern (callable with object params)
+const queryByOu = createMockFunction(async () => ({
+    items: [],
+    lastEvaluatedKey: undefined,
+}));
+const queryByAlias = createMockFunction(async () => null);
+const queryByClass = createMockFunction(async () => ({
+    items: [],
+    lastEvaluatedKey: undefined,
+}));
+const queryByType = createMockFunction(async () => ({
+    items: [],
+    lastEvaluatedKey: undefined,
+}));
+const queryByXid = createMockFunction(async () => null);
+
+var dynamodb = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    APEX: APEX,
+    ARCHIVED_SUFFIX: ARCHIVED_SUFFIX,
+    DELETED_SUFFIX: DELETED_SUFFIX,
+    INDEX_ALIAS: INDEX_ALIAS,
+    INDEX_CLASS: INDEX_CLASS,
+    INDEX_OU: INDEX_OU,
+    INDEX_TYPE: INDEX_TYPE,
+    INDEX_XID: INDEX_XID,
+    SEPARATOR: SEPARATOR,
+    archiveEntity: archiveEntity,
+    buildIndexAlias: buildIndexAlias,
+    buildIndexClass: buildIndexClass,
+    buildIndexOu: buildIndexOu,
+    buildIndexType: buildIndexType,
+    buildIndexXid: buildIndexXid,
+    calculateOu: calculateOu,
+    deleteEntity: deleteEntity,
+    destroyEntity: destroyEntity,
+    getDocClient: getDocClient,
+    getEntity: getEntity,
+    getTableName: getTableName,
+    indexEntity: indexEntity,
+    initClient: initClient,
+    isInitialized: isInitialized,
+    putEntity: putEntity,
+    queryByAlias: queryByAlias,
+    queryByClass: queryByClass,
+    queryByOu: queryByOu,
+    queryByType: queryByType,
+    queryByXid: queryByXid,
+    resetClient: resetClient,
+    updateEntity: updateEntity
+});
+
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 // Constants for mock values
 const TAG$1 = "EXPRESS";
 const HTTP = {
     CODE: { OK: 200, CREATED: 201, NO_CONTENT: 204, INTERNAL_ERROR: 500 },
 };
-const EXPRESS = original$2.EXPRESS;
+const EXPRESS = original$3.EXPRESS;
 // Add Express route functions
-const badRequestRoute = createMockWrappedFunction(original$2.badRequestRoute, { error: `_MOCK_BAD_REQUEST_ROUTE_[${TAG$1}]` });
-const echoRoute = createMockWrappedFunction(original$2.echoRoute, (req) => req);
-const forbiddenRoute = createMockWrappedFunction(original$2.forbiddenRoute, { error: `_MOCK_FORBIDDEN_ROUTE_[${TAG$1}]` });
-const goneRoute = createMockWrappedFunction(original$2.goneRoute, {
+const badRequestRoute = createMockWrappedFunction(original$3.badRequestRoute, { error: `_MOCK_BAD_REQUEST_ROUTE_[${TAG$1}]` });
+const echoRoute = createMockWrappedFunction(original$3.echoRoute, (req) => req);
+const forbiddenRoute = createMockWrappedFunction(original$3.forbiddenRoute, { error: `_MOCK_FORBIDDEN_ROUTE_[${TAG$1}]` });
+const goneRoute = createMockWrappedFunction(original$3.goneRoute, {
     error: `_MOCK_GONE_ROUTE_[${TAG$1}]`,
 });
-const methodNotAllowedRoute = createMockWrappedFunction(original$2.methodNotAllowedRoute, { error: `_MOCK_METHOD_NOT_ALLOWED_ROUTE_[${TAG$1}]` });
-const noContentRoute = createMockWrappedFunction(original$2.noContentRoute, { status: 204 });
-const notFoundRoute = createMockWrappedFunction(original$2.notFoundRoute, {
+const methodNotAllowedRoute = createMockWrappedFunction(original$3.methodNotAllowedRoute, { error: `_MOCK_METHOD_NOT_ALLOWED_ROUTE_[${TAG$1}]` });
+const noContentRoute = createMockWrappedFunction(original$3.noContentRoute, { status: 204 });
+const notFoundRoute = createMockWrappedFunction(original$3.notFoundRoute, {
     error: `_MOCK_NOT_FOUND_ROUTE_[${TAG$1}]`,
 });
-const notImplementedRoute = createMockWrappedFunction(original$2.notImplementedRoute, { error: `_MOCK_NOT_IMPLEMENTED_ROUTE_[${TAG$1}]` });
-const expressHttpCodeHandler = createMockWrappedFunction(original$2.expressHttpCodeHandler, (...args) => {
+const notImplementedRoute = createMockWrappedFunction(original$3.notImplementedRoute, { error: `_MOCK_NOT_IMPLEMENTED_ROUTE_[${TAG$1}]` });
+const expressHttpCodeHandler = createMockWrappedFunction(original$3.expressHttpCodeHandler, (...args) => {
     const [, res] = args;
     return res.status(200).send();
 });
-const cors = createMockWrappedFunction(original$2.cors);
+const cors = createMockWrappedFunction(original$3.cors);
 const expressStreamHandler = createMockFunction((handlerOrProps, propsOrHandler) => {
     let handler;
     let props;
@@ -858,7 +951,7 @@ var lambda = /*#__PURE__*/Object.freeze({
     lambdaStreamHandler: lambdaStreamHandler
 });
 
-const LLM = original$3.LLM;
+const LLM = original$4.LLM;
 const mockOperate = createMockResolvedFunction({
     content: "_MOCK_OUTPUT_TEXT",
     history: [
@@ -930,36 +1023,36 @@ const weather = createMockTool("weather", createMockResolvedFunction({
     location: `_MOCK_WEATHER_LOCATION`,
     forecast: [{ conditions: "good" }],
 }));
-const Toolkit = createMockWrappedObject(original$3.Toolkit, {
+const Toolkit = createMockWrappedObject(original$4.Toolkit, {
     isClass: true,
 });
-const JaypieToolkit = createMockWrappedObject(original$3.JaypieToolkit, {
+const JaypieToolkit = createMockWrappedObject(original$4.JaypieToolkit, {
     isClass: true,
 });
-const LlmMessageRole = createMockWrappedObject(original$3.LlmMessageRole, {
+const LlmMessageRole = createMockWrappedObject(original$4.LlmMessageRole, {
     isClass: true,
 });
-const LlmMessageType = createMockWrappedObject(original$3.LlmMessageType, {
+const LlmMessageType = createMockWrappedObject(original$4.LlmMessageType, {
     isClass: true,
 });
-const LlmStreamChunkType = createMockWrappedObject(original$3.LlmStreamChunkType, {
+const LlmStreamChunkType = createMockWrappedObject(original$4.LlmStreamChunkType, {
     isClass: true,
 });
 // Provider mocks
-const GeminiProvider = createMockWrappedObject(original$3.GeminiProvider, {
+const GeminiProvider = createMockWrappedObject(original$4.GeminiProvider, {
     isClass: true,
 });
-const OpenRouterProvider = createMockWrappedObject(original$3.OpenRouterProvider, {
+const OpenRouterProvider = createMockWrappedObject(original$4.OpenRouterProvider, {
     isClass: true,
 });
 // Type guards and utilities - re-export from original (these are pure functions)
-const extractReasoning = original$3.extractReasoning;
-const isLlmOperateInput = original$3.isLlmOperateInput;
-const isLlmOperateInputContent = original$3.isLlmOperateInputContent;
-const isLlmOperateInputFile = original$3.isLlmOperateInputFile;
-const isLlmOperateInputImage = original$3.isLlmOperateInputImage;
+const extractReasoning = original$4.extractReasoning;
+const isLlmOperateInput = original$4.isLlmOperateInput;
+const isLlmOperateInputContent = original$4.isLlmOperateInputContent;
+const isLlmOperateInputFile = original$4.isLlmOperateInputFile;
+const isLlmOperateInputImage = original$4.isLlmOperateInputImage;
 // Tool collections
-const toolkit = new original$3.JaypieToolkit([
+const toolkit = new original$4.JaypieToolkit([
     random,
     roll,
     time,
@@ -1025,18 +1118,18 @@ beforeAll(async () => {
 /**
  * Mock for MarkdownPage class from @jaypie/textract
  */
-const MarkdownPage = createMockWrappedObject(original$4.MarkdownPage, {
+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$4.MarkdownPage(mockDocument.pageNumber(1));
+        return new original$5.MarkdownPage(mockDocument.pageNumber(1));
     },
 });
 /**
  * Mock for textractJsonToMarkdown function from @jaypie/textract
  */
-const textractJsonToMarkdown = createMockWrappedFunction(original$4.textractJsonToMarkdown, `_MOCK_TEXTRACT_JSON_TO_MARKDOWN_[${TAG}]`);
+const textractJsonToMarkdown = createMockWrappedFunction(original$5.textractJsonToMarkdown, `_MOCK_TEXTRACT_JSON_TO_MARKDOWN_[${TAG}]`);
 // Export default for convenience
 var textract = {
     MarkdownPage,
@@ -1051,6 +1144,21 @@ var textract$1 = /*#__PURE__*/Object.freeze({
 });
 
 // Mock implementations for @jaypie/vocabulary
+// Status Type - re-export real values (no mocking needed)
+const STATUS_VALUES = [
+    "canceled",
+    "complete",
+    "error",
+    "pending",
+    "processing",
+    "queued",
+    "sending",
+];
+const StatusType = [...STATUS_VALUES];
+function isStatus(value) {
+    return (typeof value === "string" &&
+        STATUS_VALUES.includes(value));
+}
 /**
  * Mock implementation of lambdaServiceHandler
  * Mirrors the real implementation: wraps a service handler for Lambda with getMessages processing
@@ -1098,10 +1206,72 @@ const lambdaServiceHandler = createMockFunction((handlerOrConfig, options = {})
         validate: opts.validate,
     });
 });
+/**
+ * Mock implementation of createLlmTool
+ * Creates an LLM tool from a vocabulary service handler
+ */
+const createLlmTool = createMockFunction((config) => {
+    const { description, handler, message, name } = config;
+    const toolName = name ?? handler.alias ?? "tool";
+    const toolDescription = description ?? handler.description ?? "";
+    const tool = {
+        call: async (args) => {
+            return handler(args);
+        },
+        description: toolDescription,
+        name: toolName,
+        parameters: {
+            properties: {},
+            required: [],
+            type: "object",
+        },
+        type: "function",
+    };
+    if (message !== undefined) {
+        tool.message = message;
+    }
+    return { tool };
+});
+/**
+ * Mock implementation of inputToJsonSchema
+ * Converts vocabulary input definitions to JSON Schema
+ */
+const inputToJsonSchema = createMockFunction(() => ({
+    properties: {},
+    required: [],
+    type: "object",
+}));
+/**
+ * Mock implementation of registerMcpTool
+ * Registers a vocabulary service handler as an MCP tool
+ */
+const registerMcpTool = createMockFunction((config) => {
+    const { description, handler, name, server } = config;
+    const toolName = name ?? handler.alias ?? "tool";
+    const toolDescription = description ?? handler.description ?? "";
+    server.tool(toolName, toolDescription, {}, async (args) => {
+        const result = await handler(args);
+        return {
+            content: [
+                {
+                    text: result === undefined || result === null ? "" : String(result),
+                    type: "text",
+                },
+            ],
+        };
+    });
+    return { name: toolName };
+});
 
 var vocabulary = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    lambdaServiceHandler: lambdaServiceHandler
+    STATUS_VALUES: STATUS_VALUES,
+    StatusType: StatusType,
+    createLlmTool: createLlmTool,
+    inputToJsonSchema: inputToJsonSchema,
+    isStatus: isStatus,
+    lambdaServiceHandler: lambdaServiceHandler,
+    registerMcpTool: registerMcpTool
 });
 
 // Import all mocks
@@ -1113,15 +1283,19 @@ const mock = {
     ...core,
     // Datadog module
     ...datadog,
+    // DynamoDB module
+    ...dynamodb,
     // Express module
     ...express,
+    // Kit module
     ...kit,
     // Lambda module
     ...lambda,
     // LLM module
     ...llm,
+    // Logger module
     ...logger,
-    // Mongoose module (now empty)
+    // Mongoose module
     ...mongoose,
     // Textract module
     ...textract$1,
@@ -1129,5 +1303,5 @@ const mock = {
     ...vocabulary,
 };
 
-export { BadGatewayError, BadRequestError, ConfigurationError, CorsError, DATADOG, EXPRESS, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP$1 as HTTP, IllogicalError, InternalError, JAYPIE, JaypieError, JaypieStream, JaypieToolkit, LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, TooManyRequestsError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, createExpressStream, createJaypieStream, createLambdaStream, createLogger, mock as default, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, expressStreamHandler, extractReasoning, forbiddenRoute, force, formatError, formatSSE, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getS3FileBuffer, getSecret, getSingletonMessage, getTextractJob, goneRoute, hasDatadogEnv, isClass, isJaypieError, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, isLocalEnv, isNodeTestEnv, isProductionEnv, jaypieErrorFromStatus, jaypieHandler, lambdaHandler, lambdaServiceHandler, lambdaStreamHandler, loadEnvSecrets, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, placeholders, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, streamToSSE, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid };
+export { APEX, ARCHIVED_SUFFIX, BadGatewayError, BadRequestError, ConfigurationError, CorsError, DATADOG, DELETED_SUFFIX, EXPRESS, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP$1 as HTTP, INDEX_ALIAS, INDEX_CLASS, INDEX_OU, INDEX_TYPE, INDEX_XID, IllogicalError, InternalError, JAYPIE, JaypieError, JaypieStream, JaypieToolkit, LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, PROJECT, ProjectError, ProjectMultiError, RejectedError, SEPARATOR, STATUS_VALUES, StatusType, TeapotError, TooManyRequestsError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, archiveEntity, badRequestRoute, buildIndexAlias, buildIndexClass, buildIndexOu, buildIndexType, buildIndexXid, calculateOu, cloneDeep, connect, connectFromSecretEnv, cors, createExpressStream, createJaypieStream, createLambdaStream, createLlmTool, createLogger, mock as default, deleteEntity, destroyEntity, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, expressStreamHandler, extractReasoning, forbiddenRoute, force, formatError, formatSSE, getDocClient, getEntity, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getS3FileBuffer, getSecret, getSingletonMessage, getTableName, getTextractJob, goneRoute, hasDatadogEnv, indexEntity, initClient, inputToJsonSchema, isClass, isInitialized, isJaypieError, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, isLocalEnv, isNodeTestEnv, isProductionEnv, isStatus, jaypieErrorFromStatus, jaypieHandler, lambdaHandler, lambdaServiceHandler, lambdaStreamHandler, loadEnvSecrets, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, placeholders, putEntity, queryByAlias, queryByClass, queryByOu, queryByType, queryByXid, registerMcpTool, resetClient, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, streamToSSE, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, updateEntity, uuid };
 //# sourceMappingURL=index.js.map