@taicode/common-server 1.0.4 → 1.0.5

package/output/schema/index.d.ts

@@ -77,15 +77,42 @@ export declare function fuzzQueryBodySchema<F extends ZodType, E extends ZodEnum
     range: z.ZodTuple<[z.ZodISODateTime, z.ZodISODateTime], null>;
 }, z.core.$strip>;
 /**
- * 标准响应 Schema
+ * 标准响应数据内容 Schema
  * 用于定义统一的 API 响应结构
  * @param t - 响应数据的类型
  * @param s - 状态码的枚举类型
  * @returns 标准响应的 Schema
  */
-export declare function responseSchema<T extends ZodType, S extends ZodEnum>(t: T, s: S): z.ZodObject<{
+export declare function responseDataSchema<T extends ZodType, S extends ZodEnum>(t: T, s: S): z.ZodObject<{
     data: T;
     status: S;
     message: z.ZodString;
 }, z.core.$strip>;
+export declare function responseSchema<T extends ZodType, S extends ZodEnum, E extends ZodEnum>(t: T, u: S, e: E): {
+    '200': z.ZodObject<{
+        data: T;
+        status: z.ZodEnum<{
+            SUCCESS: "SUCCESS";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>;
+    '400': z.ZodObject<{
+        data: z.ZodNull;
+        status: S;
+        message: z.ZodString;
+    }, z.core.$strip>;
+    '500': z.ZodObject<{
+        data: z.ZodNull;
+        status: E;
+        message: z.ZodString;
+    }, z.core.$strip>;
+};
+interface RouterSchema {
+    tags: string[];
+    summary: string;
+    operationId: string;
+    description: string;
+}
+export declare function routerSchema<T extends RouterSchema>(schema: T & RouterSchema): T & RouterSchema;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/output/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AA2BzC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC;;;kBAKxD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC;;;kBAKvD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;;;;;;;;;;;;;kBAMhF;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;;;;;;;;;;kBAMrF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;;;;;;;;;;kBAMpF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;;;;kBAM9E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AA2BzC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC;;;kBAKxD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC;;;kBAKvD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;;;;;;;;;;;;;kBAMhF;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;;;;;;;;;;kBAMrF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;;;;;;;;;;kBAMpF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;;;;kBAMlF;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;;;;;;;;;;;;;;;;;;EAMvG;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,YAAY,EAAE,MAAM,EAAE,CAAC,GAAG,YAAY,GAAG,CAAC,GAAG,YAAY,CAY/F"}

package/output/schema/index.js

@@ -89,16 +89,34 @@ export function fuzzQueryBodySchema(f, e) {
     });
 }
 /**
- * 标准响应 Schema
+ * 标准响应数据内容 Schema
  * 用于定义统一的 API 响应结构
  * @param t - 响应数据的类型
  * @param s - 状态码的枚举类型
  * @returns 标准响应的 Schema
  */
-export function responseSchema(t, s) {
+export function responseDataSchema(t, s) {
     return z.object({
         data: t.describe('响应数据'),
         status: s.describe('响应状态码'),
         message: z.string().describe('响应消息'),
     });
 }
+export function responseSchema(t, u, e) {
+    return {
+        '200': responseDataSchema(t, z.enum(['SUCCESS'])),
+        '400': responseDataSchema(z.null(), u),
+        '500': responseDataSchema(z.null(), e),
+    };
+}
+export function routerSchema(schema) {
+    // 验证必需字段
+    if (!schema.operationId) {
+        throw new Error('routerSchema requires operationId');
+    }
+    // 如果没有提供 tags，设置默认值
+    if (!schema.tags) {
+        schema.tags = ['默认'];
+    }
+    return { ...schema };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-server",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "author": "Alain",
   "license": "ISC",
   "description": "",

package/output/mock/function/function.d.ts

@@ -1,30 +0,0 @@
-/**
- * mockFunction 主要用于在不依赖特定测试工具（如 jest、vitest）的情况下
- * 实现通用的 mock 能力，便于在多种环境下进行函数模拟、调用记录和行为控制。
- * 适用于需要脱离测试框架、或在生产/脚本环境下也能复用的场景。
- */
-/**
- * Mock 函数接口
- */
-interface MockFunction {
-    (...args: any[]): any;
-    mockCalls: any[][];
-    mockResults: Array<{
-        type: 'return' | 'throw';
-        value: any;
-    }>;
-    mockImplementation: (fn: Function) => MockFunction;
-    mockReturnValue: (value: any) => MockFunction;
-    mockResolvedValue: (value: any) => MockFunction;
-    mockRejectedValue: (error: any) => MockFunction;
-    mockClear: () => void;
-    mockReset: () => void;
-}
-/**
- * 创建 Mock 函数
- * 可记录调用参数、返回值、异常，并支持动态切换实现、固定返回、异步返回、异常抛出等能力。
- * 适合在无测试框架依赖的环境下灵活使用。
- */
-export declare function mockFunction(implementation?: Function): MockFunction;
-export {};
-//# sourceMappingURL=function.d.ts.map

package/output/mock/function/function.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../source/mock/function/function.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,UAAU,YAAY;IACpB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA;IACrB,SAAS,EAAE,GAAG,EAAE,EAAE,CAAA;IAClB,WAAW,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAC,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC,CAAA;IAC5D,kBAAkB,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,YAAY,CAAA;IAClD,eAAe,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,YAAY,CAAA;IAC7C,iBAAiB,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,YAAY,CAAA;IAC/C,iBAAiB,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,YAAY,CAAA;IAC/C,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,SAAS,EAAE,MAAM,IAAI,CAAA;CACtB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,cAAc,CAAC,EAAE,QAAQ,GAAG,YAAY,CAyDpE"}

package/output/mock/function/function.js

@@ -1,58 +0,0 @@
-/**
- * mockFunction 主要用于在不依赖特定测试工具（如 jest、vitest）的情况下
- * 实现通用的 mock 能力，便于在多种环境下进行函数模拟、调用记录和行为控制。
- * 适用于需要脱离测试框架、或在生产/脚本环境下也能复用的场景。
- */
-/**
- * 创建 Mock 函数
- * 可记录调用参数、返回值、异常，并支持动态切换实现、固定返回、异步返回、异常抛出等能力。
- * 适合在无测试框架依赖的环境下灵活使用。
- */
-export function mockFunction(implementation) {
-    const mockCalls = [];
-    const mockResults = [];
-    let mockImpl = implementation;
-    const mockFn = function (...args) {
-        mockCalls.push(args);
-        if (mockImpl) {
-            try {
-                const result = mockImpl(...args);
-                mockResults.push({ type: 'return', value: result });
-                return result;
-            }
-            catch (error) {
-                mockResults.push({ type: 'throw', value: error });
-                throw error;
-            }
-        }
-        return undefined;
-    };
-    mockFn.mockCalls = mockCalls;
-    mockFn.mockResults = mockResults;
-    mockFn.mockImplementation = (fn) => {
-        mockImpl = fn;
-        return mockFn;
-    };
-    mockFn.mockReturnValue = (value) => {
-        mockImpl = () => value;
-        return mockFn;
-    };
-    mockFn.mockResolvedValue = (value) => {
-        mockImpl = () => Promise.resolve(value);
-        return mockFn;
-    };
-    mockFn.mockRejectedValue = (error) => {
-        mockImpl = () => Promise.reject(error);
-        return mockFn;
-    };
-    mockFn.mockClear = () => {
-        mockCalls.length = 0;
-        mockResults.length = 0;
-    };
-    mockFn.mockReset = () => {
-        mockCalls.length = 0;
-        mockResults.length = 0;
-        mockImpl = implementation;
-    };
-    return mockFn;
-}

package/output/mock/function/function.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=function.test.d.ts.map

package/output/mock/function/function.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.test.d.ts","sourceRoot":"","sources":["../../../source/mock/function/function.test.ts"],"names":[],"mappings":""}

package/output/mock/function/function.test.js

@@ -1,55 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mockFunction } from './function';
-describe('mockFunction', () => {
-    it('应能记录调用参数和返回值', () => {
-        const fn = mockFunction((a, b) => a + b);
-        expect(fn(1, 2)).toBe(3);
-        expect(fn(2, 3)).toBe(5);
-        expect(fn.mockCalls).toEqual([[1, 2], [2, 3]]);
-        expect(fn.mockResults[0]).toEqual({ type: 'return', value: 3 });
-        expect(fn.mockResults[1]).toEqual({ type: 'return', value: 5 });
-    });
-    it('应能记录抛出的异常', () => {
-        const error = new Error('fail');
-        const fn = mockFunction(() => { throw error; });
-        expect(() => fn(1)).toThrow(error);
-        expect(fn.mockResults[0]).toEqual({ type: 'throw', value: error });
-    });
-    it('mockImplementation 可动态替换实现', () => {
-        const fn = mockFunction((x) => x + 1);
-        expect(fn(1)).toBe(2);
-        fn.mockImplementation((x) => x * 2);
-        expect(fn(2)).toBe(4);
-    });
-    it('mockReturnValue 可设置固定返回值', () => {
-        const fn = mockFunction().mockReturnValue(42);
-        expect(fn()).toBe(42);
-        expect(fn(1, 2)).toBe(42);
-    });
-    it('mockResolvedValue 应返回 Promise.resolve', async () => {
-        const fn = mockFunction().mockResolvedValue('ok');
-        await expect(fn()).resolves.toBe('ok');
-    });
-    it('mockRejectedValue 应返回 Promise.reject', async () => {
-        const fn = mockFunction().mockRejectedValue('fail');
-        await expect(fn()).rejects.toBe('fail');
-    });
-    it('mockClear 应清空调用记录', () => {
-        const fn = mockFunction((x) => x);
-        fn(1);
-        fn(2);
-        fn.mockClear();
-        expect(fn.mockCalls.length).toBe(0);
-        expect(fn.mockResults.length).toBe(0);
-    });
-    it('mockReset 应重置实现和调用记录', () => {
-        const fn = mockFunction((x) => x + 1);
-        fn(1);
-        fn.mockImplementation((x) => x + 10);
-        fn(2);
-        fn.mockReset();
-        expect(fn.mockCalls.length).toBe(0);
-        expect(fn.mockResults.length).toBe(0);
-        expect(fn(3)).toBe(4); // 恢复为初始实现
-    });
-});

package/output/mock/function/index.d.ts

@@ -1,2 +0,0 @@
-export { mockFunction } from './function';
-//# sourceMappingURL=index.d.ts.map

package/output/mock/function/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/mock/function/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA"}

package/output/mock/function/index.js

@@ -1 +0,0 @@
-export { mockFunction } from './function';

package/output/mock/index.d.ts

@@ -1,3 +0,0 @@
-export * from './function';
-export * from './prismaClient';
-//# sourceMappingURL=index.d.ts.map

package/output/mock/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/mock/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}

package/output/mock/index.js

@@ -1,3 +0,0 @@
-// mock 目录根 index.ts，统一导出所有 mock 能力
-export * from './function';
-export * from './prismaClient';

package/output/mock/prismaClient/index.d.ts

@@ -1,2 +0,0 @@
-export { mockPrismaClient } from './prismaClient';
-//# sourceMappingURL=index.d.ts.map

package/output/mock/prismaClient/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/mock/prismaClient/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA"}

package/output/mock/prismaClient/index.js

@@ -1 +0,0 @@
-export { mockPrismaClient } from './prismaClient';

package/output/mock/prismaClient/prismaClient.d.ts

@@ -1,257 +0,0 @@
-import { PrismaClient } from '@prisma/client';
-/**
- * Prisma 支持的数据库操作方法列表
- * 包含所有常用的 CRUD 和聚合操作
- */
-declare const DB_METHODS: readonly ["create", "createMany", "findFirst", "findUnique", "findMany", "update", "updateMany", "delete", "deleteMany", "upsert", "count", "aggregate", "groupBy", "findFirstOrThrow", "findUniqueOrThrow"];
-type DbMethod = typeof DB_METHODS[number];
-/**
- * 数据库调用记录接口
- * 记录每次数据库操作的详细信息
- */
-interface CallRecord {
-    /** 调用的方法名 */
-    method: DbMethod;
-    /** 调用时间戳 */
-    timestamp: Date;
-    /** 调用参数 */
-    args: any[];
-    /** 调用返回值（如果有的话） */
-    returnValue?: any;
-    /** 调用是否抛出异常 */
-    isError?: boolean;
-    /** 异常信息（如果有的话） */
-    error?: any;
-}
-/**
- * Mock 返回值配置接口
- */
-interface MockReturnConfig {
-    /** 返回值 */
-    value?: any;
-    /** 是否抛出异常 */
-    shouldThrow?: boolean;
-    /** 是否返回 Promise */
-    isAsync?: boolean;
-    /** 调用次数限制（可选） */
-    times?: number;
-}
-/**
- * 扩展的 Mock Prisma Client 接口
- * 在原有 PrismaClient 基础上添加测试辅助方法
- */
-interface MockPrismaClient extends PrismaClient {
-    /**
-     * 获取调用历史记录
-     * @param table 可选，指定表名过滤
-     * @param method 可选，指定方法名过滤
-     * @returns 调用记录数组
-     */
-    __getCallHistory(table?: string, method?: DbMethod): CallRecord[];
-    /**
-     * 清空调用历史记录
-     * @param table 可选，指定表名。不传则清空所有记录
-     */
-    __clearCallHistory(table?: string): void;
-    /**
-     * 获取最后一次调用记录
-     * @param table 表名
-     * @param method 方法名
-     * @returns 最后一次调用记录或 undefined
-     */
-    __getLastCall(table: string, method: DbMethod): CallRecord | undefined;
-    /**
-     * 获取指定方法的调用次数
-     * @param table 表名
-     * @param method 方法名
-     * @returns 调用次数
-     */
-    __getCallCount(table: string, method: DbMethod): number;
-    /**
-     * 设置方法的返回值（同步）
-     * @param table 表名
-     * @param method 方法名
-     * @param value 返回值
-     */
-    __mockReturnValue(table: string, method: DbMethod, value: any): void;
-    /**
-     * 设置方法的返回值（异步成功）
-     * @param table 表名
-     * @param method 方法名
-     * @param value 返回值
-     */
-    __mockResolvedValue(table: string, method: DbMethod, value: any): void;
-    /**
-     * 设置方法抛出异常（异步失败）
-     * @param table 表名
-     * @param method 方法名
-     * @param error 异常
-     */
-    __mockRejectedValue(table: string, method: DbMethod, error: any): void;
-    /**
-     * 高级 Mock 配置
-     * @param table 表名
-     * @param method 方法名
-     * @param config Mock 配置
-     */
-    __mockAdvanced(table: string, method: DbMethod, config: MockReturnConfig): void;
-    /**
-     * 重置所有 Mock 配置
-     * @param table 可选，指定表名。不传则重置所有表
-     */
-    __resetMocks(table?: string): void;
-    /**
-     * 获取所有被访问过的表名
-     * @returns 表名数组
-     */
-    __getAccessedTables(): string[];
-    /**
-     * 验证方法是否被调用
-     * @param table 表名
-     * @param method 方法名
-     * @param times 可选，期望的调用次数
-     * @returns 是否符合期望
-     */
-    __wasCalledWith(table: string, method: DbMethod, times?: number): boolean;
-    /**
-     * 验证方法是否被特定参数调用
-     * @param table 表名
-     * @param method 方法名
-     * @param expectedArgs 期望的参数
-     * @returns 是否符合期望
-     */
-    __wasCalledWithArgs(table: string, method: DbMethod, expectedArgs: any): boolean;
-    /**
-     * 创建数据快照，用于测试前后数据对比
-     * @returns 当前调用历史的快照
-     */
-    __createSnapshot(): string;
-    /**
-     * 恢复到指定快照状态
-     * @param snapshot 快照字符串
-     */
-    __restoreSnapshot(snapshot: string): void;
-    /**
-     * 批量设置多个表的 mock 返回值
-     * @param configs 批量配置对象
-     * @example
-     * mockDb.__batchMock({
-     *   'user.findMany': { value: [{ id: 1, name: 'John' }] },
-     *   'post.create': { value: { id: 1, title: 'Hello' } }
-     * })
-     */
-    __batchMock(configs: Record<string, MockReturnConfig>): void;
-    /**
-     * 等待异步操作完成（用于复杂异步测试场景）
-     * @param ms 等待毫秒数
-     */
-    __waitForAsyncOperations(ms?: number): Promise<void>;
-    /**
-     * 验证调用序列是否符合预期
-     * @param expectedSequence 期望的调用序列
-     * @returns 是否符合期望
-     * @example
-     * mockDb.__verifyCallSequence([
-     *   { table: 'user', method: 'findUnique' },
-     *   { table: 'post', method: 'create' }
-     * ])
-     */
-    __verifyCallSequence(expectedSequence: Array<{
-        table: string;
-        method: DbMethod;
-    }>): boolean;
-    /**
-     * 获取详细的调用统计信息
-     * @returns 调用统计数据
-     */
-    __getCallStatistics(): {
-        totalCalls: number;
-        tableStats: Record<string, number>;
-        methodStats: Record<string, number>;
-        timeRange: {
-            earliest: Date;
-            latest: Date;
-        } | null;
-    };
-}
-/**
- * 创建模拟的 Prisma Client
- * 提供完整的数据库操作模拟能力和测试辅助功能
- *
- * 主要特性：
- * - 动态创建数据库表代理，支持所有 Prisma 操作
- * - 记录所有方法调用历史，包括参数、返回值、异常等
- * - 支持灵活的 mock 返回值配置（同步/异步/异常）
- * - 提供丰富的断言和验证方法
- * - 支持调用序列验证和统计分析
- * - 支持快照和批量操作
- *
- * @example 基础用法
- * ```typescript
- * const mockDb = createPrismaClient()
- *
- * // 设置返回值
- * mockDb.__mockResolvedValue('user', 'findMany', [{ id: 1, name: 'John' }])
- *
- * // 执行操作
- * const users = await mockDb.user.findMany()
- *
- * // 验证调用
- * expect(mockDb.__getCallCount('user', 'findMany')).toBe(1)
- * expect(users).toEqual([{ id: 1, name: 'John' }])
- * ```
- *
- * @example 高级 mock 配置
- * ```typescript
- * // 限制调用次数的 mock
- * mockDb.__mockAdvanced('user', 'create', {
- *   value: { id: 1, name: 'John' },
- *   times: 2 // 只在前2次调用时返回此值
- * })
- *
- * // 批量设置 mock
- * mockDb.__batchMock({
- *   'user.findMany': { value: [] },
- *   'post.create': { value: { id: 1, title: 'Hello' } },
- *   'comment.delete': { shouldThrow: true, value: new Error('删除失败') }
- * })
- * ```
- *
- * @example 调用验证和统计
- * ```typescript
- * // 验证调用历史
- * expect(mockDb.__wasCalledWith('user', 'findMany')).toBe(true)
- * expect(mockDb.__wasCalledWithArgs('user', 'create', [{ name: 'John' }])).toBe(true)
- *
- * // 验证调用序列
- * expect(mockDb.__verifyCallSequence([
- *   { table: 'user', method: 'findUnique' },
- *   { table: 'post', method: 'create' }
- * ])).toBe(true)
- *
- * // 获取统计信息
- * const stats = mockDb.__getCallStatistics()
- * console.log(`总调用次数: ${stats.totalCalls}`)
- * ```
- *
- * @example 快照和重置
- * ```typescript
- * // 创建快照
- * const snapshot = mockDb.__createSnapshot()
- *
- * // 执行一些操作...
- * await mockDb.user.create({ data: { name: 'John' } })
- *
- * // 恢复到快照状态
- * mockDb.__restoreSnapshot(snapshot)
- *
- * // 重置特定表的 mock
- * mockDb.__resetMocks('user')
- *
- * // 清空所有调用历史
- * mockDb.__clearCallHistory()
- * ```
- */
-export declare function mockPrismaClient(): MockPrismaClient;
-export {};
-//# sourceMappingURL=prismaClient.d.ts.map

package/output/mock/prismaClient/prismaClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prismaClient.d.ts","sourceRoot":"","sources":["../../../source/mock/prismaClient/prismaClient.ts"],"names":[],"mappings":"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"}

package/output/mock/prismaClient/prismaClient.js

@@ -1,399 +0,0 @@
-import { mockFunction } from '../function/function';
-/**
- * Prisma 支持的数据库操作方法列表
- * 包含所有常用的 CRUD 和聚合操作
- */
-const DB_METHODS = [
-    'create', 'createMany',
-    'findFirst', 'findUnique', 'findMany',
-    'update', 'updateMany',
-    'delete', 'deleteMany',
-    'upsert', 'count', 'aggregate',
-    'groupBy', 'findFirstOrThrow', 'findUniqueOrThrow'
-];
-/**
- * 创建模拟的 Prisma Client
- * 提供完整的数据库操作模拟能力和测试辅助功能
- *
- * 主要特性：
- * - 动态创建数据库表代理，支持所有 Prisma 操作
- * - 记录所有方法调用历史，包括参数、返回值、异常等
- * - 支持灵活的 mock 返回值配置（同步/异步/异常）
- * - 提供丰富的断言和验证方法
- * - 支持调用序列验证和统计分析
- * - 支持快照和批量操作
- *
- * @example 基础用法
- * ```typescript
- * const mockDb = createPrismaClient()
- *
- * // 设置返回值
- * mockDb.__mockResolvedValue('user', 'findMany', [{ id: 1, name: 'John' }])
- *
- * // 执行操作
- * const users = await mockDb.user.findMany()
- *
- * // 验证调用
- * expect(mockDb.__getCallCount('user', 'findMany')).toBe(1)
- * expect(users).toEqual([{ id: 1, name: 'John' }])
- * ```
- *
- * @example 高级 mock 配置
- * ```typescript
- * // 限制调用次数的 mock
- * mockDb.__mockAdvanced('user', 'create', {
- *   value: { id: 1, name: 'John' },
- *   times: 2 // 只在前2次调用时返回此值
- * })
- *
- * // 批量设置 mock
- * mockDb.__batchMock({
- *   'user.findMany': { value: [] },
- *   'post.create': { value: { id: 1, title: 'Hello' } },
- *   'comment.delete': { shouldThrow: true, value: new Error('删除失败') }
- * })
- * ```
- *
- * @example 调用验证和统计
- * ```typescript
- * // 验证调用历史
- * expect(mockDb.__wasCalledWith('user', 'findMany')).toBe(true)
- * expect(mockDb.__wasCalledWithArgs('user', 'create', [{ name: 'John' }])).toBe(true)
- *
- * // 验证调用序列
- * expect(mockDb.__verifyCallSequence([
- *   { table: 'user', method: 'findUnique' },
- *   { table: 'post', method: 'create' }
- * ])).toBe(true)
- *
- * // 获取统计信息
- * const stats = mockDb.__getCallStatistics()
- * console.log(`总调用次数: ${stats.totalCalls}`)
- * ```
- *
- * @example 快照和重置
- * ```typescript
- * // 创建快照
- * const snapshot = mockDb.__createSnapshot()
- *
- * // 执行一些操作...
- * await mockDb.user.create({ data: { name: 'John' } })
- *
- * // 恢复到快照状态
- * mockDb.__restoreSnapshot(snapshot)
- *
- * // 重置特定表的 mock
- * mockDb.__resetMocks('user')
- *
- * // 清空所有调用历史
- * mockDb.__clearCallHistory()
- * ```
- */
-export function mockPrismaClient() {
-    const callHistory = new Map();
-    const mockReturnValues = new Map();
-    const accessedTables = new Set();
-    /**
-     * 记录方法调用
-     */
-    function recordCall(table, method, args, returnValue, error) {
-        accessedTables.add(table);
-        if (!callHistory.has(table)) {
-            callHistory.set(table, []);
-        }
-        callHistory.get(table).push({
-            method,
-            args: JSON.parse(JSON.stringify(args)), // 深拷贝避免引用问题
-            timestamp: new Date(),
-            returnValue,
-            isError: !!error,
-            error
-        });
-    }
-    /**
-     * 获取默认返回值
-     * 根据不同的数据库操作类型返回合理的默认值
-     */
-    function getDefaultReturnValue(method) {
-        switch (method) {
-            case 'count':
-                return Promise.resolve(0);
-            case 'aggregate':
-                return Promise.resolve({});
-            case 'findMany':
-                return Promise.resolve([]);
-            case 'findFirst':
-            case 'findUnique':
-                return Promise.resolve(null);
-            case 'findFirstOrThrow':
-            case 'findUniqueOrThrow':
-                return Promise.resolve({ id: 'mock-id', createdAt: new Date(), updatedAt: new Date() });
-            case 'create':
-            case 'update':
-            case 'upsert':
-                return Promise.resolve({ id: 'mock-id', createdAt: new Date(), updatedAt: new Date() });
-            case 'createMany':
-                return Promise.resolve({ count: 1 });
-            case 'delete':
-            case 'deleteMany':
-            case 'updateMany':
-                return Promise.resolve({ count: 1 });
-            case 'groupBy':
-                return Promise.resolve([]);
-            default:
-                return Promise.resolve(null);
-        }
-    }
-    /**
-     * 创建方法的 mock 函数
-     * 支持复杂的 mock 行为配置，包括调用次数限制、异常处理等
-     */
-    function createMethodMock(table, method) {
-        return mockFunction(async (...args) => {
-            const key = `${table}.${method}`;
-            const config = mockReturnValues.get(key);
-            try {
-                let result;
-                if (config) {
-                    // 检查调用次数限制
-                    if (config.times !== undefined) {
-                        const currentCount = callHistory.get(table)?.filter(c => c.method === method).length || 0;
-                        if (currentCount >= config.times) {
-                            // 超过限制次数，使用默认返回值
-                            result = getDefaultReturnValue(method);
-                        }
-                        else {
-                            if (config.shouldThrow) {
-                                throw config.value;
-                            }
-                            result = config.isAsync ? Promise.resolve(config.value) : config.value;
-                        }
-                    }
-                    else {
-                        if (config.shouldThrow) {
-                            throw config.value;
-                        }
-                        result = config.isAsync ? Promise.resolve(config.value) : config.value;
-                    }
-                }
-                else {
-                    result = getDefaultReturnValue(method);
-                }
-                // 确保返回 Promise
-                const finalResult = result instanceof Promise ? await result : result;
-                recordCall(table, method, args, finalResult);
-                return finalResult;
-            }
-            catch (error) {
-                recordCall(table, method, args, undefined, error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * 动态创建表代理
-     */
-    function createTableProxy(tableName) {
-        return new Proxy({}, {
-            get(target, prop) {
-                if (typeof prop === 'string' && DB_METHODS.includes(prop)) {
-                    if (!target[prop]) {
-                        target[prop] = createMethodMock(tableName, prop);
-                    }
-                    return target[prop];
-                }
-                // 支持其他可能的 Prisma 属性
-                if (typeof prop === 'string') {
-                    return target[prop] || mockFunction();
-                }
-                return target[prop];
-            }
-        });
-    }
-    /**
-     * 创建主数据库代理
-     */
-    const dbProxy = new Proxy({}, {
-        get(target, prop) {
-            if (typeof prop === 'string') {
-                // 测试辅助方法实现
-                switch (prop) {
-                    case '__getCallHistory':
-                        return (table, method) => {
-                            if (!table) {
-                                const allCalls = [];
-                                for (const [tableName, calls] of callHistory.entries()) {
-                                    allCalls.push(...calls.map(call => ({ ...call, table: tableName })));
-                                }
-                                return allCalls.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-                            }
-                            const calls = callHistory.get(table) || [];
-                            return method ? calls.filter(call => call.method === method) : calls;
-                        };
-                    case '__clearCallHistory':
-                        return (table) => {
-                            if (table) {
-                                callHistory.delete(table);
-                            }
-                            else {
-                                callHistory.clear();
-                                accessedTables.clear();
-                            }
-                        };
-                    case '__getLastCall':
-                        return (table, method) => {
-                            const calls = callHistory.get(table) || [];
-                            const methodCalls = calls.filter(call => call.method === method);
-                            return methodCalls[methodCalls.length - 1];
-                        };
-                    case '__getCallCount':
-                        return (table, method) => {
-                            const calls = callHistory.get(table) || [];
-                            return calls.filter(call => call.method === method).length;
-                        };
-                    case '__mockReturnValue':
-                        return (table, method, value) => {
-                            mockReturnValues.set(`${table}.${method}`, { value, isAsync: false });
-                        };
-                    case '__mockResolvedValue':
-                        return (table, method, value) => {
-                            mockReturnValues.set(`${table}.${method}`, { value, isAsync: true });
-                        };
-                    case '__mockRejectedValue':
-                        return (table, method, error) => {
-                            mockReturnValues.set(`${table}.${method}`, { value: error, shouldThrow: true, isAsync: true });
-                        };
-                    case '__mockAdvanced':
-                        return (table, method, config) => {
-                            mockReturnValues.set(`${table}.${method}`, { ...config });
-                        };
-                    case '__resetMocks':
-                        return (table) => {
-                            if (table) {
-                                const keysToDelete = Array.from(mockReturnValues.keys()).filter(key => key.startsWith(`${table}.`));
-                                keysToDelete.forEach(key => mockReturnValues.delete(key));
-                            }
-                            else {
-                                mockReturnValues.clear();
-                            }
-                        };
-                    case '__getAccessedTables':
-                        return () => Array.from(accessedTables);
-                    case '__wasCalledWith':
-                        return (table, method, times) => {
-                            const callCount = callHistory.get(table)?.filter(call => call.method === method).length || 0;
-                            return times !== undefined ? callCount === times : callCount > 0;
-                        };
-                    case '__wasCalledWithArgs':
-                        return (table, method, expectedArgs) => {
-                            const calls = callHistory.get(table) || [];
-                            return calls.some(call => call.method === method &&
-                                JSON.stringify(call.args) === JSON.stringify(expectedArgs));
-                        };
-                    case '__createSnapshot':
-                        return () => {
-                            return JSON.stringify({
-                                callHistory: Array.from(callHistory.entries()),
-                                mockReturnValues: Array.from(mockReturnValues.entries()),
-                                accessedTables: Array.from(accessedTables)
-                            });
-                        };
-                    case '__restoreSnapshot':
-                        return (snapshot) => {
-                            try {
-                                const data = JSON.parse(snapshot);
-                                callHistory.clear();
-                                mockReturnValues.clear();
-                                accessedTables.clear();
-                                data.callHistory.forEach(([table, calls]) => {
-                                    callHistory.set(table, calls.map(call => ({
-                                        ...call,
-                                        timestamp: new Date(call.timestamp)
-                                    })));
-                                });
-                                data.mockReturnValues.forEach(([key, config]) => {
-                                    mockReturnValues.set(key, config);
-                                });
-                                data.accessedTables.forEach((table) => {
-                                    accessedTables.add(table);
-                                });
-                            }
-                            catch (error) {
-                                throw new Error('无效的快照数据');
-                            }
-                        };
-                    case '__batchMock':
-                        return (configs) => {
-                            Object.entries(configs).forEach(([key, config]) => {
-                                mockReturnValues.set(key, { ...config });
-                            });
-                        };
-                    case '__waitForAsyncOperations':
-                        return async (ms = 10) => {
-                            await new Promise(resolve => setTimeout(resolve, ms));
-                        };
-                    case '__verifyCallSequence':
-                        return (expectedSequence) => {
-                            const allCalls = [];
-                            for (const [tableName, calls] of callHistory.entries()) {
-                                allCalls.push(...calls.map(call => ({
-                                    table: tableName,
-                                    method: call.method,
-                                    timestamp: call.timestamp
-                                })));
-                            }
-                            // 按时间戳排序
-                            allCalls.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-                            if (allCalls.length < expectedSequence.length) {
-                                return false;
-                            }
-                            // 检查序列是否匹配
-                            for (let i = 0; i < expectedSequence.length; i++) {
-                                const expected = expectedSequence[i];
-                                const actual = allCalls[i];
-                                if (actual.table !== expected.table || actual.method !== expected.method) {
-                                    return false;
-                                }
-                            }
-                            return true;
-                        };
-                    case '__getCallStatistics':
-                        return () => {
-                            let totalCalls = 0;
-                            const tableStats = {};
-                            const methodStats = {};
-                            let earliest = null;
-                            let latest = null;
-                            for (const [tableName, calls] of callHistory.entries()) {
-                                tableStats[tableName] = calls.length;
-                                totalCalls += calls.length;
-                                calls.forEach(call => {
-                                    const methodKey = `${tableName}.${call.method}`;
-                                    methodStats[methodKey] = (methodStats[methodKey] || 0) + 1;
-                                    if (!earliest || call.timestamp < earliest) {
-                                        earliest = call.timestamp;
-                                    }
-                                    if (!latest || call.timestamp > latest) {
-                                        latest = call.timestamp;
-                                    }
-                                });
-                            }
-                            return {
-                                totalCalls,
-                                tableStats,
-                                methodStats,
-                                timeRange: earliest && latest ? { earliest, latest } : null
-                            };
-                        };
-                }
-                // 数据库表代理
-                if (!target[prop]) {
-                    target[prop] = createTableProxy(prop);
-                }
-                return target[prop];
-            }
-            return target[prop];
-        }
-    });
-    return dbProxy;
-}

package/output/mock/prismaClient/prismaClient.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=prismaClient.test.d.ts.map

package/output/mock/prismaClient/prismaClient.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prismaClient.test.d.ts","sourceRoot":"","sources":["../../../source/mock/prismaClient/prismaClient.test.ts"],"names":[],"mappings":""}

package/output/mock/prismaClient/prismaClient.test.js

@@ -1,91 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { mockPrismaClient } from './prismaClient';
-describe('mockPrismaClient', () => {
-    let db;
-    beforeEach(() => {
-        db = mockPrismaClient();
-    });
-    it('应支持 mockResolvedValue 并记录调用', async () => {
-        db.__mockResolvedValue('user', 'findMany', [{ id: 1, name: '张三' }]);
-        const users = await db.user.findMany();
-        expect(users).toEqual([{ id: 1, name: '张三' }]);
-        expect(db.__getCallCount('user', 'findMany')).toBe(1);
-        const lastCall = db.__getLastCall('user', 'findMany');
-        expect(lastCall?.args).toEqual([]);
-        expect(lastCall?.returnValue).toEqual([{ id: 1, name: '张三' }]);
-    });
-    it('应支持 mockRejectedValue 并捕获异常', async () => {
-        db.__mockRejectedValue('user', 'create', new Error('创建失败'));
-        await expect(db.user.create({ data: { name: '李四' } })).rejects.toThrow('创建失败');
-        expect(db.__getCallCount('user', 'create')).toBe(1);
-        const lastCall = db.__getLastCall('user', 'create');
-        expect(lastCall?.isError).toBe(true);
-        expect(lastCall?.error).toBeInstanceOf(Error);
-    });
-    it('应支持 mockReturnValue 返回同步值', async () => {
-        db.__mockReturnValue('post', 'count', 5);
-        const count = await db.post.count();
-        expect(count).toBe(5);
-    });
-    it('应支持 __getCallHistory 和 __clearCallHistory', async () => {
-        db.__mockResolvedValue('user', 'findMany', []);
-        await db.user.findMany();
-        await db.user.findMany({ where: { id: 1 } });
-        expect(db.__getCallHistory('user', 'findMany').length).toBe(2);
-        db.__clearCallHistory('user');
-        expect(db.__getCallHistory('user', 'findMany').length).toBe(0);
-    });
-    it('应支持 __resetMocks', async () => {
-        db.__mockReturnValue('user', 'count', 10);
-        await db.user.count();
-        db.__resetMocks('user');
-        const count = await db.user.count();
-        expect(count).toBe(0); // 恢复为默认值
-    });
-    it('应支持 __batchMock 批量设置', async () => {
-        db.__batchMock({
-            'user.findMany': { value: [{ id: 1 }], isAsync: true },
-            'post.create': { value: { id: 2 }, isAsync: true }
-        });
-        expect(await db.user.findMany()).toEqual([{ id: 1 }]);
-        expect(await db.post.create({ data: { title: 't' } })).toEqual({ id: 2 });
-    });
-    it('应支持 __createSnapshot 和 __restoreSnapshot', async () => {
-        db.__mockReturnValue('user', 'count', 7);
-        await db.user.count();
-        const snapshot = db.__createSnapshot();
-        db.__mockReturnValue('user', 'count', 1);
-        await db.user.count();
-        db.__restoreSnapshot(snapshot);
-        expect(await db.user.count()).toBe(7);
-    });
-    it('应支持 __wasCalledWith 和 __wasCalledWithArgs', async () => {
-        db.__mockResolvedValue('user', 'findUnique', { id: 1 });
-        await db.user.findUnique({ where: { id: 1 } });
-        expect(db.__wasCalledWith('user', 'findUnique')).toBe(true);
-        expect(db.__wasCalledWithArgs('user', 'findUnique', [{ where: { id: 1 } }])).toBe(true);
-    });
-    it('应支持 __verifyCallSequence', async () => {
-        db.__mockResolvedValue('user', 'findUnique', { id: 1 });
-        db.__mockResolvedValue('post', 'create', { id: 2 });
-        await db.user.findUnique({ where: { id: 1 } });
-        await db.post.create({ data: { title: 't' } });
-        expect(db.__verifyCallSequence([
-            { table: 'user', method: 'findUnique' },
-            { table: 'post', method: 'create' }
-        ])).toBe(true);
-    });
-    it('应支持 __getCallStatistics', async () => {
-        db.__mockResolvedValue('user', 'findMany', []);
-        db.__mockResolvedValue('post', 'count', 3);
-        await db.user.findMany();
-        await db.post.count();
-        const stats = db.__getCallStatistics();
-        expect(stats.totalCalls).toBe(2);
-        expect(stats.tableStats.user).toBe(1);
-        expect(stats.tableStats.post).toBe(1);
-        expect(stats.methodStats['user.findMany']).toBe(1);
-        expect(stats.methodStats['post.count']).toBe(1);
-        expect(stats.timeRange).not.toBeNull();
-    });
-});