@jaypie/testkit 1.2.3 → 1.2.7

package/dist/mock/index.js

@@ -213,6 +213,7 @@ function createMockTool(nameOrCallOrOptions, callOrOptions) {
 // Constants for mock values
 const TAG$3 = "AWS";
 const getMessages = createMockWrappedFunction(original.getMessages, []);
+const getS3FileBuffer = createMockFunction(async ({ bucket, key }) => Buffer.from(`_MOCK_S3_FILE_[${bucket}/${key}]`));
 const getSecret = createMockResolvedFunction("mock-secret-value");
 const sendMessage = createMockResolvedFunction({
     MessageId: "mock-message-id",
@@ -295,6 +296,7 @@ var aws = /*#__PURE__*/Object.freeze({
     formatSSE: formatSSE,
     getEnvSecret: getEnvSecret,
     getMessages: getMessages,
+    getS3FileBuffer: getS3FileBuffer,
     getSecret: getSecret,
     getSingletonMessage: getSingletonMessage,
     getTextractJob: getTextractJob,
@@ -591,6 +593,207 @@ var datadog = /*#__PURE__*/Object.freeze({
     submitMetricSet: submitMetricSet
 });
 
+// Primary markers
+const APEX$1 = "@"; // Root-level marker (DynamoDB prohibits empty strings)
+const SEPARATOR$1 = "#"; // Composite key separator
+// GSI names
+const INDEX_ALIAS$1 = "indexAlias";
+const INDEX_CLASS$1 = "indexClass";
+const INDEX_OU$1 = "indexOu";
+const INDEX_TYPE$1 = "indexType";
+const INDEX_XID$1 = "indexXid";
+// Index suffixes for soft state
+const ARCHIVED_SUFFIX$1 = "#archived";
+const DELETED_SUFFIX$1 = "#deleted";
+
+/**
+ * Build the indexOu key for hierarchical queries
+ * @param ou - The organizational unit (APEX or "{parent.model}#{parent.id}")
+ * @param model - The entity model name
+ * @returns Composite key: "{ou}#{model}"
+ */
+function buildIndexOu$1(ou, model) {
+    return `${ou}${SEPARATOR$1}${model}`;
+}
+/**
+ * Build the indexAlias key for human-friendly lookups
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param alias - The human-friendly alias
+ * @returns Composite key: "{ou}#{model}#{alias}"
+ */
+function buildIndexAlias$1(ou, model, alias) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${alias}`;
+}
+/**
+ * Build the indexClass key for category filtering
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param recordClass - The category classification
+ * @returns Composite key: "{ou}#{model}#{class}"
+ */
+function buildIndexClass$1(ou, model, recordClass) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${recordClass}`;
+}
+/**
+ * Build the indexType key for type filtering
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param type - The type classification
+ * @returns Composite key: "{ou}#{model}#{type}"
+ */
+function buildIndexType$1(ou, model, type) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${type}`;
+}
+/**
+ * Build the indexXid key for external ID lookups
+ * @param ou - The organizational unit
+ * @param model - The entity model name
+ * @param xid - The external ID
+ * @returns Composite key: "{ou}#{model}#{xid}"
+ */
+function buildIndexXid$1(ou, model, xid) {
+    return `${ou}${SEPARATOR$1}${model}${SEPARATOR$1}${xid}`;
+}
+/**
+ * Calculate the organizational unit from a parent reference
+ * @param parent - Optional parent entity reference
+ * @returns APEX ("@") if no parent, otherwise "{parent.model}#{parent.id}"
+ */
+function calculateOu$1(parent) {
+    if (!parent) {
+        return APEX$1;
+    }
+    return `${parent.model}${SEPARATOR$1}${parent.id}`;
+}
+/**
+ * Auto-populate GSI index keys on an entity
+ * - indexOu is always populated from ou + model
+ * - indexAlias is populated only when alias is present
+ * - indexClass is populated only when class is present
+ * - indexType is populated only when type is present
+ * - indexXid is populated only when xid is present
+ *
+ * @param entity - The entity to populate index keys for
+ * @param suffix - Optional suffix to append to all index keys (e.g., "#deleted", "#archived")
+ * @returns The entity with populated index keys
+ */
+function indexEntity$1(entity, suffix = "") {
+    const result = { ...entity };
+    // indexOu is always set (from ou + model)
+    result.indexOu = buildIndexOu$1(entity.ou, entity.model) + suffix;
+    // Optional indexes - only set when the source field is present
+    if (entity.alias !== undefined) {
+        result.indexAlias =
+            buildIndexAlias$1(entity.ou, entity.model, entity.alias) + suffix;
+    }
+    if (entity.class !== undefined) {
+        result.indexClass =
+            buildIndexClass$1(entity.ou, entity.model, entity.class) + suffix;
+    }
+    if (entity.type !== undefined) {
+        result.indexType =
+            buildIndexType$1(entity.ou, entity.model, entity.type) + suffix;
+    }
+    if (entity.xid !== undefined) {
+        result.indexXid =
+            buildIndexXid$1(entity.ou, entity.model, entity.xid) + suffix;
+    }
+    return result;
+}
+
+// Re-export constants (no need to mock, just pass through)
+const APEX = APEX$1;
+const ARCHIVED_SUFFIX = ARCHIVED_SUFFIX$1;
+const DELETED_SUFFIX = DELETED_SUFFIX$1;
+const INDEX_ALIAS = INDEX_ALIAS$1;
+const INDEX_CLASS = INDEX_CLASS$1;
+const INDEX_OU = INDEX_OU$1;
+const INDEX_TYPE = INDEX_TYPE$1;
+const INDEX_XID = INDEX_XID$1;
+const SEPARATOR = SEPARATOR$1;
+// Key builder functions - use createMockFunction with typed implementations
+const buildIndexAlias = createMockFunction((ou, model, alias) => buildIndexAlias$1(ou, model, alias));
+const buildIndexClass = createMockFunction((ou, model, recordClass) => buildIndexClass$1(ou, model, recordClass));
+const buildIndexOu = createMockFunction((ou, model) => buildIndexOu$1(ou, model));
+const buildIndexType = createMockFunction((ou, model, type) => buildIndexType$1(ou, model, type));
+const buildIndexXid = createMockFunction((ou, model, xid) => buildIndexXid$1(ou, model, xid));
+const calculateOu = createMockFunction((parent) => calculateOu$1(parent));
+const indexEntity = createMockFunction((entity, suffix) => indexEntity$1(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 - return mock data
+const getEntity = createMockFunction(async () => null);
+const putEntity = createMockFunction(async (params) => indexEntity$1(params.entity));
+const updateEntity = createMockFunction(async (params) => ({
+    ...indexEntity$1(params.entity),
+    updatedAt: new Date().toISOString(),
+}));
+const deleteEntity = createMockFunction(async () => true);
+const archiveEntity = createMockFunction(async () => true);
+const destroyEntity = createMockFunction(async () => true);
+// Query functions - return empty results by default (use 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";
@@ -858,6 +1061,7 @@ var lambda = /*#__PURE__*/Object.freeze({
 
 const LLM = original$3.LLM;
 const mockOperate = createMockResolvedFunction({
+    content: "_MOCK_OUTPUT_TEXT",
     history: [
         {
             content: "_MOCK_USER_INPUT",
@@ -883,6 +1087,7 @@ const mockOperate = createMockResolvedFunction({
         },
     ],
     provider: "_MOCK_PROVIDER",
+    reasoning: [],
     responses: [
         {
             id: "_MOCK_RESPONSE_ID",
@@ -904,7 +1109,6 @@ const mockOperate = createMockResolvedFunction({
             model: "_MOCK_MODEL",
         },
     ],
-    content: "_MOCK_OUTPUT_TEXT",
 });
 const mockSend = createMockResolvedFunction("_MOCK_LLM_RESPONSE");
 const Llm = Object.assign(vi.fn().mockImplementation((providerName = "_MOCK_LLM_PROVIDER") => ({
@@ -949,6 +1153,12 @@ const GeminiProvider = createMockWrappedObject(original$3.GeminiProvider, {
 const OpenRouterProvider = createMockWrappedObject(original$3.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;
 // Tool collections
 const toolkit = new original$3.JaypieToolkit([
     random,
@@ -969,6 +1179,11 @@ var llm = /*#__PURE__*/Object.freeze({
     LlmStreamChunkType: LlmStreamChunkType,
     OpenRouterProvider: OpenRouterProvider,
     Toolkit: Toolkit,
+    extractReasoning: extractReasoning,
+    isLlmOperateInput: isLlmOperateInput,
+    isLlmOperateInputContent: isLlmOperateInputContent,
+    isLlmOperateInputFile: isLlmOperateInputFile,
+    isLlmOperateInputImage: isLlmOperateInputImage,
     toolkit: toolkit,
     tools: tools
 });
@@ -1037,6 +1252,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
@@ -1084,10 +1314,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
@@ -1099,15 +1391,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,
@@ -1115,5 +1411,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, forbiddenRoute, force, formatError, formatSSE, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getSecret, getSingletonMessage, getTextractJob, goneRoute, hasDatadogEnv, isClass, isJaypieError, 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