@wx-sab/renkei 1.3.3 → 1.3.4

package/lib/core/generate.test.js

@@ -0,0 +1,341 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const swagger_typescript_api_1 = require("swagger-typescript-api");
+const generate_1 = require("./generate");
+const type_filter_1 = require("./type-filter");
+const config_utils_1 = require("./config-utils");
+vitest_1.vi.mock('swagger-typescript-api', () => ({
+    generateApi: vitest_1.vi.fn()
+}));
+vitest_1.vi.mock('cli-progress', () => ({
+    default: {
+        SingleBar: class {
+            constructor() {
+                this.start = vitest_1.vi.fn();
+                this.increment = vitest_1.vi.fn();
+                this.stop = vitest_1.vi.fn();
+            }
+        }
+    }
+}));
+vitest_1.vi.mock('./type-filter', () => ({
+    filterUnusedTypes: vitest_1.vi.fn()
+}));
+const mockedGenerateApi = vitest_1.vi.mocked(swagger_typescript_api_1.generateApi);
+const mockedFilterUnusedTypes = vitest_1.vi.mocked(type_filter_1.filterUnusedTypes);
+(0, vitest_1.describe)('generate', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        vitest_1.vi.spyOn(console, 'warn').mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, 'info').mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)('base generate()', () => {
+        (0, vitest_1.it)('calls generateApi with correct base config', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedGenerateApi.mockResolvedValueOnce({});
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            (0, vitest_1.expect)(mockedGenerateApi).toHaveBeenCalledTimes(1);
+            const callArgs = mockedGenerateApi.mock.calls[0][0];
+            (0, vitest_1.expect)(callArgs.silent).toBe(true);
+            (0, vitest_1.expect)(callArgs.modular).toBe(false);
+            (0, vitest_1.expect)(callArgs.generateClient).toBe(false);
+            (0, vitest_1.expect)(callArgs.extractRequestParams).toBe(true);
+            (0, vitest_1.expect)(callArgs.cleanOutput).toBe(false);
+        }));
+        (0, vitest_1.it)('triggers filterUnusedTypes when folders configured and output set', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedGenerateApi.mockResolvedValueOnce({});
+            yield (0, generate_1.generate)({
+                serviceName: 'myService',
+                source: 'http://test.com',
+                folders: ['users'],
+                output: '/tmp/output'
+            });
+            (0, vitest_1.expect)(mockedFilterUnusedTypes).toHaveBeenCalledTimes(1);
+            (0, vitest_1.expect)(mockedFilterUnusedTypes).toHaveBeenCalledWith('/tmp/output', 'myService', 'MyService', 'Model');
+        }));
+        (0, vitest_1.it)('does NOT trigger filterUnusedTypes when no folders configured', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedGenerateApi.mockResolvedValueOnce({});
+            yield (0, generate_1.generate)({
+                serviceName: 'myService',
+                source: 'http://test.com',
+                output: '/tmp/output'
+            });
+            (0, vitest_1.expect)(mockedFilterUnusedTypes).not.toHaveBeenCalled();
+        }));
+    });
+    (0, vitest_1.describe)('onCreateRouteName hook', () => {
+        (0, vitest_1.it)('skips routes outside configured folders', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({
+                serviceName: 'test',
+                source: 'http://test.com',
+                folders: ['users']
+            });
+            const result = capturedHooks.onCreateRouteName({ original: 'getUsers', usage: 'getUsers' }, { route: '/orders', method: 'get', 'x-apifox-folder': 'orders/list' });
+            (0, vitest_1.expect)(result).toEqual({
+                duplicate: false,
+                original: config_utils_1.SKIP_ROUTE_MARKER,
+                usage: config_utils_1.SKIP_ROUTE_MARKER
+            });
+        }));
+        (0, vitest_1.it)('allows routes in configured folders', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({
+                serviceName: 'test',
+                source: 'http://test.com',
+                folders: ['users']
+            });
+            const result = capturedHooks.onCreateRouteName({ original: 'getUsers', usage: 'getUsers' }, { route: '/api/users', method: 'get', 'x-apifox-folder': 'users/list' });
+            (0, vitest_1.expect)(result.original).not.toBe(config_utils_1.SKIP_ROUTE_MARKER);
+            (0, vitest_1.expect)(result.usage).not.toBe(config_utils_1.SKIP_ROUTE_MARKER);
+        }));
+        (0, vitest_1.it)('throws on route with spaces', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            (0, vitest_1.expect)(() => capturedHooks.onCreateRouteName({ original: 'badRoute', usage: 'badRoute' }, { route: '/path with space', method: 'get' })).toThrow(/路径中存在空格/);
+        }));
+        (0, vitest_1.it)('warns on Chinese characters in route', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const rawRouteInfo = { route: '/api/中文路径', method: 'get' };
+            capturedHooks.onCreateRouteName({ original: 'test', usage: 'test' }, rawRouteInfo);
+            (0, vitest_1.expect)(console.warn).toHaveBeenCalledWith(vitest_1.expect.stringContaining('检测到请求路径中存在中文'));
+        }));
+        (0, vitest_1.it)('applies customRequestUrl when it returns a string', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({
+                serviceName: 'test',
+                source: 'http://test.com',
+                customRequestUrl: () => '/new-url'
+            });
+            const rawRouteInfo = { route: '/old-url', method: 'get' };
+            capturedHooks.onCreateRouteName({ original: 'test', usage: 'test' }, rawRouteInfo);
+            (0, vitest_1.expect)(rawRouteInfo.route).toBe('/new-url');
+        }));
+        (0, vitest_1.it)('applies customRequestUrl when it returns an object with path and mockUrl', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({
+                serviceName: 'test',
+                source: 'http://test.com',
+                customRequestUrl: () => ({
+                    path: '/new-path',
+                    mockUrl: 'https://mock.example.com/api'
+                })
+            });
+            const rawRouteInfo = { route: '/old-path', method: 'get', mockUrl: 'https://mock.example.com/api' };
+            capturedHooks.onCreateRouteName({ original: 'test', usage: 'test' }, rawRouteInfo);
+            (0, vitest_1.expect)(rawRouteInfo.route).toBe('/new-path');
+            (0, vitest_1.expect)(rawRouteInfo.mockUrl).toBe('https://mock.example.com/api');
+        }));
+        (0, vitest_1.it)('detects duplicate method names', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const rawRouteInfo = { route: '/users', method: 'get' };
+            const first = capturedHooks.onCreateRouteName({ original: 'test', usage: 'test' }, rawRouteInfo);
+            (0, vitest_1.expect)(first.duplicate).toBe(false);
+            const second = capturedHooks.onCreateRouteName({ original: 'test', usage: 'test' }, rawRouteInfo);
+            (0, vitest_1.expect)(second.duplicate).toBe(true);
+        }));
+        (0, vitest_1.it)('uses customRouteName when provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({
+                serviceName: 'test',
+                source: 'http://test.com',
+                customRouteName: () => 'customMethodName'
+            });
+            const result = capturedHooks.onCreateRouteName({ original: 'original', usage: 'original' }, { route: '/users', method: 'get' });
+            (0, vitest_1.expect)(result.original).toBe('customMethodName');
+            (0, vitest_1.expect)(result.usage).toBe('customMethodName');
+        }));
+    });
+    (0, vitest_1.describe)('onParseSchema hook', () => {
+        (0, vitest_1.it)('handles int64 format', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const result = capturedHooks.onParseSchema({ format: 'int64' }, { content: 'number' });
+            (0, vitest_1.expect)(result.content).toBe('number | string');
+        }));
+        (0, vitest_1.it)('handles long format', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const result = capturedHooks.onParseSchema({ format: 'long' }, { content: 'number' });
+            (0, vitest_1.expect)(result.content).toBe('number | string');
+        }));
+        (0, vitest_1.it)('handles any type with $ref by resolving to namespaced name', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const result = capturedHooks.onParseSchema({}, {
+                name: 'any',
+                content: 'any',
+                $ref: '#/definitions/UserVO'
+            });
+            // getValidName('UserVO') returns 'UserVO', modelNamespace is 'Model', serviceName is 'Test'
+            (0, vitest_1.expect)(result.content).toBe('Model.Test.UserVO');
+        }));
+        (0, vitest_1.it)('passes through non-matching schema unchanged', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const parsed = { name: 'string', content: 'string' };
+            const result = capturedHooks.onParseSchema({ format: 'email' }, parsed);
+            (0, vitest_1.expect)(result).toBe(parsed);
+        }));
+    });
+    (0, vitest_1.describe)('onCreateRoute hook', () => {
+        (0, vitest_1.it)('replaces path params from {param} to ${param}', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const routeData = {
+                raw: { route: '/users/{userId}/posts/{postId}' },
+                request: { path: '/users/{userId}/posts/{postId}' }
+            };
+            const result = capturedHooks.onCreateRoute(routeData);
+            (0, vitest_1.expect)(result.request.path).toBe('/users/${userId}/posts/${postId}');
+        }));
+    });
+    (0, vitest_1.describe)('onPrepareConfig hook', () => {
+        (0, vitest_1.it)('injects modelNamespace, serviceName, SKIP_ROUTE_MARKER, and skippedRoutes set', () => __awaiter(void 0, void 0, void 0, function* () {
+            let capturedHooks;
+            mockedGenerateApi.mockImplementationOnce((params) => __awaiter(void 0, void 0, void 0, function* () {
+                capturedHooks = params.hooks;
+                return {};
+            }));
+            yield (0, generate_1.generate)({ serviceName: 'test', source: 'http://test.com' });
+            const result = capturedHooks.onPrepareConfig({ someExisting: 'value' });
+            (0, vitest_1.expect)(result.modelNamespace).toBe('Model');
+            (0, vitest_1.expect)(result.serviceName).toBe('Test');
+            (0, vitest_1.expect)(result.SKIP_ROUTE_MARKER).toBe(config_utils_1.SKIP_ROUTE_MARKER);
+            (0, vitest_1.expect)(result.skippedRoutes).toBeInstanceOf(Set);
+            (0, vitest_1.expect)(result.someExisting).toBe('value');
+        }));
+    });
+});
+(0, vitest_1.describe)('generateApis', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        vitest_1.vi.spyOn(console, 'warn').mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, 'info').mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('generates all configs when services is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockedGenerateApi.mockResolvedValue({});
+        const configs = [
+            { serviceName: 'service1', source: 'http://s1.com' },
+            { serviceName: 'service2', source: 'http://s2.com' },
+            { serviceName: 'service3', source: 'http://s3.com' }
+        ];
+        yield (0, generate_1.generateApis)(configs, []);
+        (0, vitest_1.expect)(mockedGenerateApi).toHaveBeenCalledTimes(3);
+    }));
+    (0, vitest_1.it)('filters by services list', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockedGenerateApi.mockResolvedValue({});
+        const configs = [
+            { serviceName: 'service1', source: 'http://s1.com' },
+            { serviceName: 'service2', source: 'http://s2.com' },
+            { serviceName: 'service3', source: 'http://s3.com' }
+        ];
+        yield (0, generate_1.generateApis)(configs, ['service1', 'service3']);
+        (0, vitest_1.expect)(mockedGenerateApi).toHaveBeenCalledTimes(2);
+    }));
+    (0, vitest_1.it)('collects errors from failed services and logs failure info', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockedGenerateApi
+            .mockResolvedValueOnce({})
+            .mockRejectedValueOnce(new Error('generation failed'))
+            .mockResolvedValueOnce({});
+        const configs = [
+            { serviceName: 'service1', source: 'http://s1.com' },
+            { serviceName: 'service2', source: 'http://s2.com' },
+            { serviceName: 'service3', source: 'http://s3.com' }
+        ];
+        yield (0, generate_1.generateApis)(configs, []);
+        (0, vitest_1.expect)(console.error).toHaveBeenCalledWith('generation failed');
+        (0, vitest_1.expect)(console.info).toHaveBeenCalledWith(vitest_1.expect.stringContaining('生成失败'));
+        (0, vitest_1.expect)(console.info).toHaveBeenCalledWith(vitest_1.expect.stringContaining('service2'));
+    }));
+    (0, vitest_1.it)('prints success message when all services pass', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockedGenerateApi.mockResolvedValue({});
+        const configs = [
+            { serviceName: 'service1', source: 'http://s1.com' },
+            { serviceName: 'service2', source: 'http://s2.com' }
+        ];
+        yield (0, generate_1.generateApis)(configs, []);
+        (0, vitest_1.expect)(console.info).toHaveBeenCalledWith('✅ 执行完毕');
+    }));
+    (0, vitest_1.it)('handles non-Error thrown values (string thrown)', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockedGenerateApi.mockRejectedValueOnce('string error message');
+        const configs = [
+            { serviceName: 'service1', source: 'http://s1.com' }
+        ];
+        yield (0, generate_1.generateApis)(configs, []);
+        (0, vitest_1.expect)(console.error).toHaveBeenCalledWith('string error message');
+        (0, vitest_1.expect)(console.info).toHaveBeenCalledWith(vitest_1.expect.stringContaining('service1'));
+        (0, vitest_1.expect)(console.info).toHaveBeenCalledWith(vitest_1.expect.stringContaining('string error message'));
+    }));
+});

package/lib/core/type-filter.d.ts

@@ -1 +1,20 @@
+/** @internal */
+export declare const extractTypeReferences: (content: string, modelNamespace: string) => Map<string, Set<string>>;
+/** @internal */
+export declare const stripComments: (content: string) => string;
+/** @internal */
+export declare const collectTypeDefBody: (lines: string[], startIndex: number, initialLines: string[]) => {
+    typeDefLines: string[];
+    nextIndex: number;
+};
+/** @internal */
+export declare const extractAllTypeDefinitions: (content: string) => Map<string, string>;
+/** @internal */
+export declare const findShortNameRefs: (codeOnly: string, typeNameSet: Set<string>) => Set<string>;
+/** @internal */
+export declare const findTypeDependencies: (rootTypes: Set<string>, typeDefs: Map<string, string>, modelNamespace: string, serviceName: string) => Set<string>;
+/** @internal */
+export declare const detectNamespaceIndent: (lines: string[], serviceName: string) => string;
+/** @internal */
+export declare const filterModelTypes: (modelContent: string, usedTypes: Set<string>, modelNamespace: string, serviceName: string) => string;
 export declare const filterUnusedTypes: (outputDir: string, serviceDirName: string, serviceTypeName: string, modelNamespace: string) => Promise<void>;

package/lib/core/type-filter.js

@@ -12,9 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterUnusedTypes = void 0;
+exports.filterUnusedTypes = exports.filterModelTypes = exports.detectNamespaceIndent = exports.findTypeDependencies = exports.findShortNameRefs = exports.extractAllTypeDefinitions = exports.collectTypeDefBody = exports.stripComments = exports.extractTypeReferences = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+/** @internal */
 const extractTypeReferences = (content, modelNamespace) => {
     const typeUsageMap = new Map();
     const regex = new RegExp(`${modelNamespace}\\.(\\w+)\\.(\\w+)`, 'g');
@@ -29,6 +30,8 @@ const extractTypeReferences = (content, modelNamespace) => {
     }
     return typeUsageMap;
 };
+exports.extractTypeReferences = extractTypeReferences;
+/** @internal */
 const stripComments = (content) => {
     const result = [];
     let i = 0;
@@ -74,6 +77,8 @@ const stripComments = (content) => {
     }
     return result.join('');
 };
+exports.stripComments = stripComments;
+/** @internal */
 const collectTypeDefBody = (lines, startIndex, initialLines) => {
     const firstLine = lines[startIndex].trim();
     const typeDefLines = [...initialLines];
@@ -92,6 +97,8 @@ const collectTypeDefBody = (lines, startIndex, initialLines) => {
     }
     return { typeDefLines, nextIndex: i };
 };
+exports.collectTypeDefBody = collectTypeDefBody;
+/** @internal */
 const extractAllTypeDefinitions = (content) => {
     const typeDefs = new Map();
     const lines = content.split('\n');
@@ -116,7 +123,7 @@ const extractAllTypeDefinitions = (content) => {
                 const typeMatch = nextLine.match(/(?:export\s+)?(?:interface|type|enum)\s+(\w+)/);
                 if (typeMatch) {
                     const typeName = typeMatch[1];
-                    const { typeDefLines, nextIndex } = collectTypeDefBody(lines, i, commentLines);
+                    const { typeDefLines, nextIndex } = (0, exports.collectTypeDefBody)(lines, i, commentLines);
                     typeDefs.set(typeName, typeDefLines.join('\n'));
                     i = nextIndex;
                     continue;
@@ -127,7 +134,7 @@ const extractAllTypeDefinitions = (content) => {
         const typeMatch = trimmedLine.match(/(?:export\s+)?(?:interface|type|enum)\s+(\w+)/);
         if (typeMatch) {
             const typeName = typeMatch[1];
-            const { typeDefLines, nextIndex } = collectTypeDefBody(lines, i, []);
+            const { typeDefLines, nextIndex } = (0, exports.collectTypeDefBody)(lines, i, []);
             typeDefs.set(typeName, typeDefLines.join('\n'));
             i = nextIndex;
             continue;
@@ -136,7 +143,9 @@ const extractAllTypeDefinitions = (content) => {
     }
     return typeDefs;
 };
+exports.extractAllTypeDefinitions = extractAllTypeDefinitions;
 const CHUNK_SIZE = 200;
+/** @internal */
 const findShortNameRefs = (codeOnly, typeNameSet) => {
     const found = new Set();
     const typeNames = Array.from(typeNameSet);
@@ -151,6 +160,8 @@ const findShortNameRefs = (codeOnly, typeNameSet) => {
     }
     return found;
 };
+exports.findShortNameRefs = findShortNameRefs;
+/** @internal */
 const findTypeDependencies = (rootTypes, typeDefs, modelNamespace, serviceName) => {
     const visited = new Set();
     const typeNameSet = new Set(typeDefs.keys());
@@ -169,8 +180,8 @@ const findTypeDependencies = (rootTypes, typeDefs, modelNamespace, serviceName)
                 traverse(refTypeName);
             }
         }
-        const codeOnly = stripComments(typeDef);
-        const shortRefs = findShortNameRefs(codeOnly, typeNameSet);
+        const codeOnly = (0, exports.stripComments)(typeDef);
+        const shortRefs = (0, exports.findShortNameRefs)(codeOnly, typeNameSet);
         for (const refTypeName of shortRefs) {
             if (refTypeName !== typeName && !visited.has(refTypeName) && typeDefs.has(refTypeName)) {
                 traverse(refTypeName);
@@ -182,6 +193,8 @@ const findTypeDependencies = (rootTypes, typeDefs, modelNamespace, serviceName)
     }
     return visited;
 };
+exports.findTypeDependencies = findTypeDependencies;
+/** @internal */
 const detectNamespaceIndent = (lines, serviceName) => {
     var _a;
     for (const line of lines) {
@@ -193,10 +206,12 @@ const detectNamespaceIndent = (lines, serviceName) => {
     }
     return '    ';
 };
+exports.detectNamespaceIndent = detectNamespaceIndent;
+/** @internal */
 const filterModelTypes = (modelContent, usedTypes, modelNamespace, serviceName) => {
     const lines = modelContent.split('\n');
-    const allTypeDefs = extractAllTypeDefinitions(modelContent);
-    const allUsedTypes = findTypeDependencies(usedTypes, allTypeDefs, modelNamespace, serviceName);
+    const allTypeDefs = (0, exports.extractAllTypeDefinitions)(modelContent);
+    const allUsedTypes = (0, exports.findTypeDependencies)(usedTypes, allTypeDefs, modelNamespace, serviceName);
     const filteredTypeDefs = [];
     allTypeDefs.forEach((typeDef, name) => {
         if (allUsedTypes.has(name)) {
@@ -229,7 +244,7 @@ const filterModelTypes = (modelContent, usedTypes, modelNamespace, serviceName)
         }
         header.push(line);
     }
-    const closingIndent = detectNamespaceIndent(lines, serviceName);
+    const closingIndent = (0, exports.detectNamespaceIndent)(lines, serviceName);
     const result = [
         ...header,
         ...filteredTypeDefs,
@@ -238,6 +253,7 @@ const filterModelTypes = (modelContent, usedTypes, modelNamespace, serviceName)
     ];
     return result.join('\n');
 };
+exports.filterModelTypes = filterModelTypes;
 const filterUnusedTypes = (outputDir, serviceDirName, serviceTypeName, modelNamespace) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const serviceDir = path_1.default.join(outputDir, serviceDirName);
@@ -245,7 +261,7 @@ const filterUnusedTypes = (outputDir, serviceDirName, serviceTypeName, modelName
         const modelFile = path_1.default.join(serviceDir, 'model.d.ts');
         const indexContent = yield promises_1.default.readFile(indexFile, 'utf-8');
         const modelContent = yield promises_1.default.readFile(modelFile, 'utf-8');
-        const typeUsageMap = extractTypeReferences(indexContent, modelNamespace);
+        const typeUsageMap = (0, exports.extractTypeReferences)(indexContent, modelNamespace);
         if (!typeUsageMap.has(serviceTypeName)) {
             console.log(`没有找到服务 ${serviceTypeName} 的类型引用，跳过过滤`);
             return;
@@ -255,7 +271,7 @@ const filterUnusedTypes = (outputDir, serviceDirName, serviceTypeName, modelName
             console.log(`服务 ${serviceTypeName} 没有使用任何类型，跳过过滤`);
             return;
         }
-        const filteredModelContent = filterModelTypes(modelContent, usedTypes, modelNamespace, serviceTypeName);
+        const filteredModelContent = (0, exports.filterModelTypes)(modelContent, usedTypes, modelNamespace, serviceTypeName);
         yield promises_1.default.writeFile(modelFile, filteredModelContent, 'utf-8');
         const originalLines = modelContent.split('\n').length;
         const filteredLines = filteredModelContent.split('\n').length;

package/lib/core/type-filter.test.d.ts

@@ -0,0 +1 @@
+export {};