@frontmcp/sdk 0.3.1 → 0.4.0

package/src/__test-utils__/fixtures/tool.fixtures.js

@@ -0,0 +1,91 @@
+"use strict";
+/// <reference types="jest" />
+/**
+ * Test fixtures for tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockToolClass = void 0;
+exports.createToolMetadata = createToolMetadata;
+exports.createEchoToolMetadata = createEchoToolMetadata;
+exports.createCalculatorToolMetadata = createCalculatorToolMetadata;
+exports.createStructuredOutputToolMetadata = createStructuredOutputToolMetadata;
+exports.createMockToolInstance = createMockToolInstance;
+const zod_1 = require("zod");
+/**
+ * Simple test tool metadata
+ */
+function createToolMetadata(overrides = {}) {
+    return {
+        name: 'test_tool',
+        description: 'A test tool',
+        inputSchema: {
+            text: zod_1.z.string(),
+        },
+        outputSchema: 'string',
+        ...overrides,
+    };
+}
+/**
+ * Creates a simple echo tool metadata
+ */
+function createEchoToolMetadata() {
+    return {
+        name: 'echo',
+        description: 'Echoes back the input',
+        inputSchema: {
+            message: zod_1.z.string().describe('Message to echo'),
+        },
+        outputSchema: 'string',
+    };
+}
+/**
+ * Creates a calculator tool metadata
+ */
+function createCalculatorToolMetadata() {
+    return {
+        name: 'calculator',
+        description: 'Performs basic arithmetic',
+        inputSchema: {
+            operation: zod_1.z.enum(['add', 'subtract', 'multiply', 'divide']),
+            a: zod_1.z.number(),
+            b: zod_1.z.number(),
+        },
+        outputSchema: 'number',
+    };
+}
+/**
+ * Creates a tool with structured output
+ */
+function createStructuredOutputToolMetadata() {
+    return {
+        name: 'get_user',
+        description: 'Gets user information',
+        inputSchema: {
+            userId: zod_1.z.string(),
+        },
+        outputSchema: zod_1.z.object({
+            id: zod_1.z.string(),
+            name: zod_1.z.string(),
+            email: zod_1.z.string().email(),
+        }),
+    };
+}
+/**
+ * Mock tool class for testing
+ */
+class MockToolClass {
+    async execute(input) {
+        return `Echo: ${input.text}`;
+    }
+}
+exports.MockToolClass = MockToolClass;
+/**
+ * Mock tool instance for testing
+ */
+function createMockToolInstance(metadata) {
+    return {
+        metadata: createToolMetadata(metadata),
+        execute: jest.fn(async (input) => `Result: ${JSON.stringify(input)}`),
+    };
+}
+//# sourceMappingURL=tool.fixtures.js.map

package/src/__test-utils__/fixtures/tool.fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.fixtures.js","sourceRoot":"","sources":["../../../../src/__test-utils__/fixtures/tool.fixtures.ts"],"names":[],"mappings":";AAAA,8BAA8B;AAC9B;;GAEG;;;AAQH,gDAUC;AAKD,wDASC;AAKD,oEAWC;AAKD,gFAaC;AAcD,wDAKC;AAnFD,6BAAwB;AAGxB;;GAEG;AACH,SAAgB,kBAAkB,CAAC,YAAmC,EAAE;IACtE,OAAO;QACL,IAAI,EAAE,WAAW;QACjB,WAAW,EAAE,aAAa;QAC1B,WAAW,EAAE;YACX,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;SACjB;QACD,YAAY,EAAE,QAAQ;QACtB,GAAG,SAAS;KACb,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,sBAAsB;IACpC,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,uBAAuB;QACpC,WAAW,EAAE;YACX,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,iBAAiB,CAAC;SAChD;QACD,YAAY,EAAE,QAAQ;KACvB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,4BAA4B;IAC1C,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,WAAW,EAAE,2BAA2B;QACxC,WAAW,EAAE;YACX,SAAS,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;YAC5D,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE;YACb,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE;SACd;QACD,YAAY,EAAE,QAAQ;KACvB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,kCAAkC;IAChD,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,uBAAuB;QACpC,WAAW,EAAE;YACX,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE;SACnB;QACD,YAAY,EAAE,OAAC,CAAC,MAAM,CAAC;YACrB,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE;YACd,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;YAChB,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE;SAC1B,CAAC;KACH,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAa,aAAa;IACxB,KAAK,CAAC,OAAO,CAAC,KAAuB;QACnC,OAAO,SAAS,KAAK,CAAC,IAAI,EAAE,CAAC;IAC/B,CAAC;CACF;AAJD,sCAIC;AAED;;GAEG;AACH,SAAgB,sBAAsB,CAAC,QAAgC;IACrE,OAAO;QACL,QAAQ,EAAE,kBAAkB,CAAC,QAAQ,CAAC;QACtC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,KAAU,EAAE,EAAE,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;KAC3E,CAAC;AACJ,CAAC","sourcesContent":["/// <reference types=\"jest\" />\n/**\n * Test fixtures for tools\n */\n\nimport { z } from 'zod';\nimport { ToolMetadata } from '../../common/metadata';\n\n/**\n * Simple test tool metadata\n */\nexport function createToolMetadata(overrides: Partial<ToolMetadata> = {}): ToolMetadata {\n  return {\n    name: 'test_tool',\n    description: 'A test tool',\n    inputSchema: {\n      text: z.string(),\n    },\n    outputSchema: 'string',\n    ...overrides,\n  };\n}\n\n/**\n * Creates a simple echo tool metadata\n */\nexport function createEchoToolMetadata(): ToolMetadata {\n  return {\n    name: 'echo',\n    description: 'Echoes back the input',\n    inputSchema: {\n      message: z.string().describe('Message to echo'),\n    },\n    outputSchema: 'string',\n  };\n}\n\n/**\n * Creates a calculator tool metadata\n */\nexport function createCalculatorToolMetadata(): ToolMetadata {\n  return {\n    name: 'calculator',\n    description: 'Performs basic arithmetic',\n    inputSchema: {\n      operation: z.enum(['add', 'subtract', 'multiply', 'divide']),\n      a: z.number(),\n      b: z.number(),\n    },\n    outputSchema: 'number',\n  };\n}\n\n/**\n * Creates a tool with structured output\n */\nexport function createStructuredOutputToolMetadata(): ToolMetadata {\n  return {\n    name: 'get_user',\n    description: 'Gets user information',\n    inputSchema: {\n      userId: z.string(),\n    },\n    outputSchema: z.object({\n      id: z.string(),\n      name: z.string(),\n      email: z.string().email(),\n    }),\n  };\n}\n\n/**\n * Mock tool class for testing\n */\nexport class MockToolClass {\n  async execute(input: { text: string }): Promise<string> {\n    return `Echo: ${input.text}`;\n  }\n}\n\n/**\n * Mock tool instance for testing\n */\nexport function createMockToolInstance(metadata?: Partial<ToolMetadata>) {\n  return {\n    metadata: createToolMetadata(metadata),\n    execute: jest.fn(async (input: any) => `Result: ${JSON.stringify(input)}`),\n  };\n}\n"]}

package/src/__test-utils__/helpers/assertion.helpers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Custom assertion helpers for testing SDK components
+ */
+/**
+ * Asserts that a value is defined (not null or undefined)
+ */
+export declare function assertDefined<T>(value: T | null | undefined, message?: string): asserts value is T;
+/**
+ * Asserts that a value is an instance of a class
+ */
+export declare function assertInstanceOf<T>(value: any, Ctor: new (...args: any[]) => T, message?: string): asserts value is T;
+/**
+ * Asserts that an array contains a specific item
+ */
+export declare function assertContains<T>(array: T[], item: T, message?: string): void;
+/**
+ * Asserts that two arrays have the same elements with the same counts (order doesn't matter)
+ */
+export declare function assertSameElements<T>(actual: T[], expected: T[], message?: string): void;
+/**
+ * Asserts that a map has a specific key
+ */
+export declare function assertHasKey<K, V>(map: Map<K, V>, key: K, message?: string): void;
+/**
+ * Asserts that a promise rejects with a specific error
+ */
+export declare function assertRejects(promise: Promise<any>, expectedError?: string | RegExp | (new (...args: any[]) => Error)): Promise<Error>;
+/**
+ * Asserts that a promise resolves to a specific value
+ */
+export declare function assertResolves<T>(promise: Promise<T>, expectedValue?: T): Promise<T>;
+/**
+ * Creates a spy that captures console output
+ */
+export declare function spyConsole(): {
+    logs: string[];
+    warns: string[];
+    errors: string[];
+    infos: string[];
+    restore: () => void;
+};
+/**
+ * Suppresses console output during test execution
+ */
+export declare function suppressConsole(): () => void;

package/src/__test-utils__/helpers/assertion.helpers.js

@@ -0,0 +1,153 @@
+"use strict";
+/// <reference types="jest" />
+/**
+ * Custom assertion helpers for testing SDK components
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertDefined = assertDefined;
+exports.assertInstanceOf = assertInstanceOf;
+exports.assertContains = assertContains;
+exports.assertSameElements = assertSameElements;
+exports.assertHasKey = assertHasKey;
+exports.assertRejects = assertRejects;
+exports.assertResolves = assertResolves;
+exports.spyConsole = spyConsole;
+exports.suppressConsole = suppressConsole;
+const NO_EXPECTED = Symbol('assertResolves.noExpected');
+/**
+ * Asserts that a value is defined (not null or undefined)
+ */
+function assertDefined(value, message) {
+    if (value === null || value === undefined) {
+        throw new Error(message || 'Expected value to be defined');
+    }
+}
+/**
+ * Asserts that a value is an instance of a class
+ */
+function assertInstanceOf(value, Ctor, message) {
+    if (!(value instanceof Ctor)) {
+        throw new Error(message ||
+            `Expected value to be an instance of ${Ctor.name}, but got ${value?.constructor?.name || typeof value}`);
+    }
+}
+/**
+ * Asserts that an array contains a specific item
+ */
+function assertContains(array, item, message) {
+    if (!array.includes(item)) {
+        throw new Error(message || `Expected array to contain item`);
+    }
+}
+/**
+ * Asserts that two arrays have the same elements with the same counts (order doesn't matter)
+ */
+function assertSameElements(actual, expected, message) {
+    if (actual.length !== expected.length) {
+        throw new Error(message || `Expected arrays to have same length: ${actual.length} vs ${expected.length}`);
+    }
+    // Count occurrences of each element in both arrays
+    const actualCounts = new Map();
+    const expectedCounts = new Map();
+    for (const item of actual) {
+        actualCounts.set(item, (actualCounts.get(item) || 0) + 1);
+    }
+    for (const item of expected) {
+        expectedCounts.set(item, (expectedCounts.get(item) || 0) + 1);
+    }
+    // Check that all expected items exist with the correct counts
+    for (const [item, count] of expectedCounts) {
+        const actualCount = actualCounts.get(item) || 0;
+        if (actualCount !== count) {
+            throw new Error(message || `Expected array to contain ${count} occurrence(s) of ${item}, but found ${actualCount}`);
+        }
+    }
+    // Check that actual doesn't have extra items
+    for (const [item, count] of actualCounts) {
+        const expectedCount = expectedCounts.get(item) || 0;
+        if (expectedCount !== count) {
+            throw new Error(message || `Expected array to contain ${expectedCount} occurrence(s) of ${item}, but found ${count}`);
+        }
+    }
+}
+/**
+ * Asserts that a map has a specific key
+ */
+function assertHasKey(map, key, message) {
+    if (!map.has(key)) {
+        throw new Error(message || `Expected map to have key`);
+    }
+}
+/**
+ * Asserts that a promise rejects with a specific error
+ */
+async function assertRejects(promise, expectedError) {
+    try {
+        await promise;
+        throw new Error('Expected promise to reject, but it resolved');
+    }
+    catch (error) {
+        if (expectedError) {
+            if (typeof expectedError === 'string') {
+                expect(error.message).toContain(expectedError);
+            }
+            else if (expectedError instanceof RegExp) {
+                expect(error.message).toMatch(expectedError);
+            }
+            else {
+                expect(error).toBeInstanceOf(expectedError);
+            }
+        }
+        return error;
+    }
+}
+/**
+ * Asserts that a promise resolves to a specific value
+ */
+async function assertResolves(promise, expectedValue) {
+    const value = await promise;
+    const finalExpected = arguments.length > 1 ? expectedValue : NO_EXPECTED;
+    if (finalExpected !== NO_EXPECTED) {
+        expect(value).toEqual(finalExpected);
+    }
+    return value;
+}
+/**
+ * Creates a spy that captures console output
+ */
+function spyConsole() {
+    const originalConsole = {
+        log: console.log,
+        warn: console.warn,
+        error: console.error,
+        info: console.info,
+    };
+    const logs = [];
+    const warns = [];
+    const errors = [];
+    const infos = [];
+    console.log = jest.fn((...args) => logs.push(args.join(' ')));
+    console.warn = jest.fn((...args) => warns.push(args.join(' ')));
+    console.error = jest.fn((...args) => errors.push(args.join(' ')));
+    console.info = jest.fn((...args) => infos.push(args.join(' ')));
+    return {
+        logs,
+        warns,
+        errors,
+        infos,
+        restore: () => {
+            console.log = originalConsole.log;
+            console.warn = originalConsole.warn;
+            console.error = originalConsole.error;
+            console.info = originalConsole.info;
+        },
+    };
+}
+/**
+ * Suppresses console output during test execution
+ */
+function suppressConsole() {
+    const spy = spyConsole();
+    return spy.restore;
+}
+//# sourceMappingURL=assertion.helpers.js.map

package/src/__test-utils__/helpers/assertion.helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion.helpers.js","sourceRoot":"","sources":["../../../../src/__test-utils__/helpers/assertion.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference types=\"jest\" />\n/**\n * Custom assertion helpers for testing SDK components\n */\n\nconst NO_EXPECTED = Symbol('assertResolves.noExpected');\n\n/**\n * Asserts that a value is defined (not null or undefined)\n */\nexport function assertDefined<T>(value: T | null | undefined, message?: string): asserts value is T {\n  if (value === null || value === undefined) {\n    throw new Error(message || 'Expected value to be defined');\n  }\n}\n\n/**\n * Asserts that a value is an instance of a class\n */\nexport function assertInstanceOf<T>(value: any, Ctor: new (...args: any[]) => T, message?: string): asserts value is T {\n  if (!(value instanceof Ctor)) {\n    throw new Error(\n      message ||\n        `Expected value to be an instance of ${Ctor.name}, but got ${value?.constructor?.name || typeof value}`,\n    );\n  }\n}\n\n/**\n * Asserts that an array contains a specific item\n */\nexport function assertContains<T>(array: T[], item: T, message?: string): void {\n  if (!array.includes(item)) {\n    throw new Error(message || `Expected array to contain item`);\n  }\n}\n\n/**\n * Asserts that two arrays have the same elements with the same counts (order doesn't matter)\n */\nexport function assertSameElements<T>(actual: T[], expected: T[], message?: string): void {\n  if (actual.length !== expected.length) {\n    throw new Error(message || `Expected arrays to have same length: ${actual.length} vs ${expected.length}`);\n  }\n\n  // Count occurrences of each element in both arrays\n  const actualCounts = new Map<T, number>();\n  const expectedCounts = new Map<T, number>();\n\n  for (const item of actual) {\n    actualCounts.set(item, (actualCounts.get(item) || 0) + 1);\n  }\n\n  for (const item of expected) {\n    expectedCounts.set(item, (expectedCounts.get(item) || 0) + 1);\n  }\n\n  // Check that all expected items exist with the correct counts\n  for (const [item, count] of expectedCounts) {\n    const actualCount = actualCounts.get(item) || 0;\n    if (actualCount !== count) {\n      throw new Error(\n        message || `Expected array to contain ${count} occurrence(s) of ${item}, but found ${actualCount}`,\n      );\n    }\n  }\n\n  // Check that actual doesn't have extra items\n  for (const [item, count] of actualCounts) {\n    const expectedCount = expectedCounts.get(item) || 0;\n    if (expectedCount !== count) {\n      throw new Error(\n        message || `Expected array to contain ${expectedCount} occurrence(s) of ${item}, but found ${count}`,\n      );\n    }\n  }\n}\n\n/**\n * Asserts that a map has a specific key\n */\nexport function assertHasKey<K, V>(map: Map<K, V>, key: K, message?: string): void {\n  if (!map.has(key)) {\n    throw new Error(message || `Expected map to have key`);\n  }\n}\n\n/**\n * Asserts that a promise rejects with a specific error\n */\nexport async function assertRejects(\n  promise: Promise<any>,\n  expectedError?: string | RegExp | (new (...args: any[]) => Error),\n): Promise<Error> {\n  try {\n    await promise;\n    throw new Error('Expected promise to reject, but it resolved');\n  } catch (error) {\n    if (expectedError) {\n      if (typeof expectedError === 'string') {\n        expect((error as Error).message).toContain(expectedError);\n      } else if (expectedError instanceof RegExp) {\n        expect((error as Error).message).toMatch(expectedError);\n      } else {\n        expect(error).toBeInstanceOf(expectedError);\n      }\n    }\n    return error as Error;\n  }\n}\n\n/**\n * Asserts that a promise resolves to a specific value\n */\nexport async function assertResolves<T>(promise: Promise<T>, expectedValue?: T): Promise<T> {\n  const value = await promise;\n  const finalExpected: T | typeof NO_EXPECTED = arguments.length > 1 ? (expectedValue as T) : NO_EXPECTED;\n\n  if (finalExpected !== NO_EXPECTED) {\n    expect(value).toEqual(finalExpected as T);\n  }\n  return value;\n}\n\n/**\n * Creates a spy that captures console output\n */\nexport function spyConsole() {\n  const originalConsole = {\n    log: console.log,\n    warn: console.warn,\n    error: console.error,\n    info: console.info,\n  };\n\n  const logs: string[] = [];\n  const warns: string[] = [];\n  const errors: string[] = [];\n  const infos: string[] = [];\n\n  console.log = jest.fn((...args) => logs.push(args.join(' ')));\n  console.warn = jest.fn((...args) => warns.push(args.join(' ')));\n  console.error = jest.fn((...args) => errors.push(args.join(' ')));\n  console.info = jest.fn((...args) => infos.push(args.join(' ')));\n\n  return {\n    logs,\n    warns,\n    errors,\n    infos,\n    restore: () => {\n      console.log = originalConsole.log;\n      console.warn = originalConsole.warn;\n      console.error = originalConsole.error;\n      console.info = originalConsole.info;\n    },\n  };\n}\n\n/**\n * Suppresses console output during test execution\n */\nexport function suppressConsole() {\n  const spy = spyConsole();\n  return spy.restore;\n}\n"]}

package/src/__test-utils__/helpers/async.helpers.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Helper utilities for testing asynchronous operations
+ */
+/**
+ * Waits for a promise to settle and returns the result or error
+ */
+export declare function settled<T>(promise: Promise<T>): Promise<{
+    status: 'fulfilled';
+    value: T;
+} | {
+    status: 'rejected';
+    reason: any;
+}>;
+/**
+ * Waits for a condition to be true with a timeout
+ */
+export declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
+    timeout?: number;
+    interval?: number;
+}): Promise<void>;
+/**
+ * Flushes all pending promises (useful for testing async flows)
+ */
+export declare function flushPromises(): Promise<void>;
+/**
+ * Creates a deferred promise that can be resolved/rejected externally
+ */
+export declare function createDeferred<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+};
+/**
+ * Runs a function and expects it to throw an error
+ */
+export declare function expectToThrow<T>(fn: () => T | Promise<T>, expectedError?: string | RegExp | (new (...args: any[]) => Error)): Promise<Error>;
+/**
+ * Creates a mock function that tracks calls
+ */
+export declare function createMockFn<T extends (...args: any[]) => any>(): {
+    fn: jest.Mock<ReturnType<T>, Parameters<T>, any>;
+    calls: {
+        args: Parameters<T>;
+        result?: ReturnType<T>;
+        error?: any;
+    }[];
+    reset: () => void;
+};

package/src/__test-utils__/helpers/async.helpers.js

@@ -0,0 +1,112 @@
+"use strict";
+/// <reference types="jest" />
+/**
+ * Helper utilities for testing asynchronous operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settled = settled;
+exports.waitFor = waitFor;
+exports.flushPromises = flushPromises;
+exports.createDeferred = createDeferred;
+exports.expectToThrow = expectToThrow;
+exports.createMockFn = createMockFn;
+/**
+ * Waits for a promise to settle and returns the result or error
+ */
+async function settled(promise) {
+    try {
+        const value = await promise;
+        return { status: 'fulfilled', value };
+    }
+    catch (reason) {
+        return { status: 'rejected', reason };
+    }
+}
+/**
+ * Waits for a condition to be true with a timeout
+ */
+async function waitFor(condition, options = {}) {
+    const { timeout = 5000, interval = 50 } = options;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        if (await condition()) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error(`Timeout waiting for condition after ${timeout}ms`);
+}
+/**
+ * Flushes all pending promises (useful for testing async flows)
+ */
+async function flushPromises() {
+    await new Promise((resolve) => setImmediate(resolve));
+}
+/**
+ * Creates a deferred promise that can be resolved/rejected externally
+ */
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject,
+    };
+}
+/**
+ * Runs a function and expects it to throw an error
+ */
+async function expectToThrow(fn, expectedError) {
+    try {
+        await fn();
+    }
+    catch (error) {
+        if (expectedError) {
+            if (typeof expectedError === 'string') {
+                expect(error.message).toContain(expectedError);
+            }
+            else if (expectedError instanceof RegExp) {
+                expect(error.message).toMatch(expectedError);
+            }
+            else {
+                expect(error).toBeInstanceOf(expectedError);
+            }
+        }
+        return error;
+    }
+    throw new Error('Expected function to throw an error, but it did not');
+}
+/**
+ * Creates a mock function that tracks calls
+ */
+function createMockFn() {
+    const calls = [];
+    const fn = jest.fn((...args) => {
+        const call = { args };
+        try {
+            const result = undefined;
+            call.result = result;
+            calls.push(call);
+            return result;
+        }
+        catch (error) {
+            call.error = error;
+            calls.push(call);
+            throw error;
+        }
+    });
+    return {
+        fn,
+        calls,
+        reset: () => {
+            calls.length = 0;
+            fn.mockReset();
+        },
+    };
+}
+//# sourceMappingURL=async.helpers.js.map

package/src/__test-utils__/helpers/async.helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.helpers.js","sourceRoot":"","sources":["../../../../src/__test-utils__/helpers/async.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference types=\"jest\" />\n/**\n * Helper utilities for testing asynchronous operations\n */\n\n/**\n * Waits for a promise to settle and returns the result or error\n */\nexport async function settled<T>(\n  promise: Promise<T>,\n): Promise<{ status: 'fulfilled'; value: T } | { status: 'rejected'; reason: any }> {\n  try {\n    const value = await promise;\n    return { status: 'fulfilled', value };\n  } catch (reason) {\n    return { status: 'rejected', reason };\n  }\n}\n\n/**\n * Waits for a condition to be true with a timeout\n */\nexport async function waitFor(\n  condition: () => boolean | Promise<boolean>,\n  options: { timeout?: number; interval?: number } = {},\n): Promise<void> {\n  const { timeout = 5000, interval = 50 } = options;\n  const start = Date.now();\n\n  while (Date.now() - start < timeout) {\n    if (await condition()) {\n      return;\n    }\n    await new Promise((resolve) => setTimeout(resolve, interval));\n  }\n\n  throw new Error(`Timeout waiting for condition after ${timeout}ms`);\n}\n\n/**\n * Flushes all pending promises (useful for testing async flows)\n */\nexport async function flushPromises(): Promise<void> {\n  await new Promise((resolve) => setImmediate(resolve));\n}\n\n/**\n * Creates a deferred promise that can be resolved/rejected externally\n */\nexport function createDeferred<T>() {\n  let resolve: (value: T) => void;\n  let reject: (reason: any) => void;\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return {\n    promise,\n    resolve: resolve!,\n    reject: reject!,\n  };\n}\n\n/**\n * Runs a function and expects it to throw an error\n */\nexport async function expectToThrow<T>(\n  fn: () => T | Promise<T>,\n  expectedError?: string | RegExp | (new (...args: any[]) => Error),\n): Promise<Error> {\n  try {\n    await fn();\n  } catch (error) {\n    if (expectedError) {\n      if (typeof expectedError === 'string') {\n        expect((error as Error).message).toContain(expectedError);\n      } else if (expectedError instanceof RegExp) {\n        expect((error as Error).message).toMatch(expectedError);\n      } else {\n        expect(error).toBeInstanceOf(expectedError);\n      }\n    }\n    return error as Error;\n  }\n\n  throw new Error('Expected function to throw an error, but it did not');\n}\n\n/**\n * Creates a mock function that tracks calls\n */\nexport function createMockFn<T extends (...args: any[]) => any>() {\n  const calls: Array<{ args: Parameters<T>; result?: ReturnType<T>; error?: any }> = [];\n\n  const fn = jest.fn((...args: Parameters<T>): ReturnType<T> => {\n    const call: any = { args };\n    try {\n      const result = undefined as ReturnType<T>;\n      call.result = result;\n      calls.push(call);\n      return result;\n    } catch (error) {\n      call.error = error;\n      calls.push(call);\n      throw error;\n    }\n  });\n\n  return {\n    fn,\n    calls,\n    reset: () => {\n      calls.length = 0;\n      fn.mockReset();\n    },\n  };\n}\n"]}

package/src/__test-utils__/helpers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Helper utilities for testing
+ */
+export * from './async.helpers';
+export * from './assertion.helpers';
+export * from './setup.helpers';

package/src/__test-utils__/helpers/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Helper utilities for testing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./async.helpers"), exports);
+tslib_1.__exportStar(require("./assertion.helpers"), exports);
+tslib_1.__exportStar(require("./setup.helpers"), exports);
+//# sourceMappingURL=index.js.map

package/src/__test-utils__/helpers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/__test-utils__/helpers/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,0DAAgC;AAChC,8DAAoC;AACpC,0DAAgC","sourcesContent":["/**\n * Helper utilities for testing\n */\n\nexport * from './async.helpers';\nexport * from './assertion.helpers';\nexport * from './setup.helpers';\n"]}

package/src/__test-utils__/helpers/setup.helpers.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Helper utilities for test setup and teardown
+ */
+import 'reflect-metadata';
+/**
+ * Creates a clean test environment with automatic cleanup
+ */
+export declare function createTestEnvironment(): {
+    /**
+     * Registers a cleanup function to be called after the test
+     */
+    onCleanup(fn: () => void | Promise<void>): void;
+    /**
+     * Cleans up all registered resources
+     */
+    cleanup(): Promise<void>;
+};
+/**
+ * Wraps a test function with automatic environment setup and cleanup
+ */
+export declare function withTestEnvironment<T extends any[]>(testFn: (env: ReturnType<typeof createTestEnvironment>, ...args: T) => Promise<void> | void): (...args: T) => Promise<void>;
+/**
+ * Creates a mock timer for testing time-based operations
+ */
+export declare function useFakeTimers(): {
+    advance: (ms: number) => void;
+    runAll: () => void;
+    runPending: () => void;
+};
+/**
+ * Creates a test-specific logger that can be inspected
+ */
+export declare function createTestLogger(): {
+    log: (message: string, data?: any) => number;
+    warn: (message: string, data?: any) => number;
+    error: (message: string, data?: any) => number;
+    info: (message: string, data?: any) => number;
+    debug: (message: string, data?: any) => number;
+    getLogs: () => {
+        level: string;
+        message: string;
+        data?: any;
+    }[];
+    clear: () => number;
+    hasLog: (level: string, message: string) => boolean;
+};
+/**
+ * Ensures reflect-metadata is loaded for decorator tests
+ */
+export declare function setupReflectMetadata(): void;
+/**
+ * Clears all mocks between tests
+ */
+export declare function setupMockClearing(): void;

package/src/__test-utils__/helpers/setup.helpers.js

@@ -0,0 +1,106 @@
+"use strict";
+/// <reference types="jest" />
+/**
+ * Helper utilities for test setup and teardown
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestEnvironment = createTestEnvironment;
+exports.withTestEnvironment = withTestEnvironment;
+exports.useFakeTimers = useFakeTimers;
+exports.createTestLogger = createTestLogger;
+exports.setupReflectMetadata = setupReflectMetadata;
+exports.setupMockClearing = setupMockClearing;
+require("reflect-metadata");
+/**
+ * Creates a clean test environment with automatic cleanup
+ */
+function createTestEnvironment() {
+    const cleanupFns = [];
+    return {
+        /**
+         * Registers a cleanup function to be called after the test
+         */
+        onCleanup(fn) {
+            cleanupFns.push(fn);
+        },
+        /**
+         * Cleans up all registered resources
+         */
+        async cleanup() {
+            for (const fn of cleanupFns.reverse()) {
+                await fn();
+            }
+            cleanupFns.length = 0;
+        },
+    };
+}
+/**
+ * Wraps a test function with automatic environment setup and cleanup
+ */
+function withTestEnvironment(testFn) {
+    return async (...args) => {
+        const env = createTestEnvironment();
+        try {
+            await testFn(env, ...args);
+        }
+        finally {
+            await env.cleanup();
+        }
+    };
+}
+/**
+ * Creates a mock timer for testing time-based operations
+ */
+function useFakeTimers() {
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.runOnlyPendingTimers();
+        jest.useRealTimers();
+    });
+    return {
+        advance: (ms) => jest.advanceTimersByTime(ms),
+        runAll: () => jest.runAllTimers(),
+        runPending: () => jest.runOnlyPendingTimers(),
+    };
+}
+/**
+ * Creates a test-specific logger that can be inspected
+ */
+function createTestLogger() {
+    const logs = [];
+    return {
+        log: (message, data) => logs.push({ level: 'log', message, data }),
+        warn: (message, data) => logs.push({ level: 'warn', message, data }),
+        error: (message, data) => logs.push({ level: 'error', message, data }),
+        info: (message, data) => logs.push({ level: 'info', message, data }),
+        debug: (message, data) => logs.push({ level: 'debug', message, data }),
+        getLogs: () => logs,
+        clear: () => (logs.length = 0),
+        hasLog: (level, message) => logs.some((log) => log.level === level && log.message.includes(message)),
+    };
+}
+/**
+ * Ensures reflect-metadata is loaded for decorator tests
+ */
+function setupReflectMetadata() {
+    beforeAll(() => {
+        // Ensure reflect-metadata is loaded
+        if (typeof Reflect === 'undefined' || !Reflect.getMetadata) {
+            throw new Error('reflect-metadata is not loaded');
+        }
+    });
+}
+/**
+ * Clears all mocks between tests
+ */
+function setupMockClearing() {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+}
+//# sourceMappingURL=setup.helpers.js.map