@wx-sab/renkei 1.3.0 → 1.3.2

package/lib/core/config-utils.test.d.ts

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

package/lib/core/config-utils.test.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const config_utils_1 = require("./config-utils");
+(0, vitest_1.describe)('config-utils', () => {
+    (0, vitest_1.describe)('collectConfig', () => {
+        (0, vitest_1.it)('should return empty array for null/undefined config', () => {
+            // 测试边界情况：null 和 undefined 输入
+            (0, vitest_1.expect)((0, config_utils_1.collectConfig)(null)).toEqual([]);
+            (0, vitest_1.expect)((0, config_utils_1.collectConfig)(undefined)).toEqual([]);
+        });
+        (0, vitest_1.it)('should collect single config', () => {
+            const config = {
+                serviceName: 'test-service',
+                sourceType: 'apifox',
+                apifoxProjectId: '12345'
+            };
+            const result = (0, config_utils_1.collectConfig)(config);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].serviceName).toBe('test-service');
+        });
+        (0, vitest_1.it)('should collect array of configs', () => {
+            const configs = [
+                { serviceName: 'service1', sourceType: 'apifox', apifoxProjectId: '123' },
+                { serviceName: 'service2', sourceType: 'swagger' }
+            ];
+            const result = (0, config_utils_1.collectConfig)(configs);
+            (0, vitest_1.expect)(result).toHaveLength(2);
+            (0, vitest_1.expect)(result[0].serviceName).toBe('service1');
+            (0, vitest_1.expect)(result[1].serviceName).toBe('service2');
+        });
+        (0, vitest_1.it)('should flatten nested projects', () => {
+            const config = {
+                serviceName: 'parent-service',
+                sourceType: 'apifox',
+                apifoxProjectId: '123',
+                projects: [
+                    { serviceName: 'child-service-1' },
+                    { serviceName: 'child-service-2' }
+                ]
+            };
+            const result = (0, config_utils_1.collectConfig)(config);
+            (0, vitest_1.expect)(result).toHaveLength(3);
+            (0, vitest_1.expect)(result[0].serviceName).toBe('parent-service');
+            (0, vitest_1.expect)(result[1].serviceName).toBe('child-service-1');
+            (0, vitest_1.expect)(result[2].serviceName).toBe('child-service-2');
+        });
+        (0, vitest_1.it)('should omit projects field from collected configs', () => {
+            const config = {
+                serviceName: 'parent-service',
+                sourceType: 'apifox',
+                apifoxProjectId: '123',
+                projects: [
+                    { serviceName: 'child-service' }
+                ]
+            };
+            const result = (0, config_utils_1.collectConfig)(config);
+            (0, vitest_1.expect)(result[0]).not.toHaveProperty('projects');
+            (0, vitest_1.expect)(result[1]).not.toHaveProperty('projects');
+        });
+        (0, vitest_1.it)('should merge parent config with child projects', () => {
+            const config = {
+                serviceName: 'parent-service',
+                sourceType: 'apifox',
+                apifoxProjectId: '123',
+                output: '/custom/output',
+                projects: [
+                    { serviceName: 'child-service' }
+                ]
+            };
+            const result = (0, config_utils_1.collectConfig)(config);
+            (0, vitest_1.expect)(result[1].serviceName).toBe('child-service');
+            (0, vitest_1.expect)(result[1].sourceType).toBe('apifox');
+            (0, vitest_1.expect)(result[1].apifoxProjectId).toBe('123');
+            (0, vitest_1.expect)(result[1].output).toBe('/custom/output');
+        });
+        (0, vitest_1.it)('should handle deeply nested projects', () => {
+            const config = {
+                serviceName: 'root-service',
+                sourceType: 'swagger',
+                projects: [
+                    {
+                        serviceName: 'level-1',
+                        projects: [
+                            { serviceName: 'level-2' }
+                        ]
+                    }
+                ]
+            };
+            const result = (0, config_utils_1.collectConfig)(config);
+            (0, vitest_1.expect)(result).toHaveLength(3);
+            (0, vitest_1.expect)(result[0].serviceName).toBe('root-service');
+            (0, vitest_1.expect)(result[1].serviceName).toBe('level-1');
+            (0, vitest_1.expect)(result[2].serviceName).toBe('level-2');
+        });
+        (0, vitest_1.it)('should preserve existing collects array', () => {
+            const config = {
+                serviceName: 'new-service'
+            };
+            const existing = [
+                { serviceName: 'existing-service' }
+            ];
+            const result = (0, config_utils_1.collectConfig)(config, existing);
+            (0, vitest_1.expect)(result).toHaveLength(2);
+            (0, vitest_1.expect)(result[0].serviceName).toBe('existing-service');
+            (0, vitest_1.expect)(result[1].serviceName).toBe('new-service');
+        });
+    });
+    (0, vitest_1.describe)('applyFoldersToConfig', () => {
+        (0, vitest_1.it)('should apply folders to single config', () => {
+            const config = {
+                serviceName: 'test-service'
+            };
+            const folderSelections = new Map();
+            folderSelections.set('test-service', ['folder1', 'folder2']);
+            (0, config_utils_1.applyFoldersToConfig)(config, folderSelections);
+            (0, vitest_1.expect)(config.folders).toEqual(['folder1', 'folder2']);
+        });
+        (0, vitest_1.it)('should not modify config if no folders selected', () => {
+            const config = {
+                serviceName: 'test-service'
+            };
+            const folderSelections = new Map();
+            (0, config_utils_1.applyFoldersToConfig)(config, folderSelections);
+            (0, vitest_1.expect)(config.folders).toBeUndefined();
+        });
+        (0, vitest_1.it)('should apply folders to array of configs', () => {
+            const configs = [
+                { serviceName: 'service1' },
+                { serviceName: 'service2' }
+            ];
+            const folderSelections = new Map();
+            folderSelections.set('service1', ['folder1']);
+            folderSelections.set('service2', ['folder2']);
+            (0, config_utils_1.applyFoldersToConfig)(configs, folderSelections);
+            (0, vitest_1.expect)(configs[0].folders).toEqual(['folder1']);
+            (0, vitest_1.expect)(configs[1].folders).toEqual(['folder2']);
+        });
+        (0, vitest_1.it)('should apply folders to nested projects', () => {
+            const config = {
+                serviceName: 'parent-service',
+                projects: [
+                    { serviceName: 'child-service' }
+                ]
+            };
+            const folderSelections = new Map();
+            folderSelections.set('parent-service', ['parent-folder']);
+            folderSelections.set('child-service', ['child-folder']);
+            (0, config_utils_1.applyFoldersToConfig)(config, folderSelections);
+            (0, vitest_1.expect)(config.folders).toEqual(['parent-folder']);
+            (0, vitest_1.expect)(config.projects[0].folders).toEqual(['child-folder']);
+        });
+        (0, vitest_1.it)('should use parent serviceName for projects without serviceName', () => {
+            const config = {
+                serviceName: 'parent-service',
+                projects: [
+                    {}
+                ]
+            };
+            const folderSelections = new Map();
+            folderSelections.set('parent-service', ['shared-folder']);
+            (0, config_utils_1.applyFoldersToConfig)(config, folderSelections);
+            (0, vitest_1.expect)(config.folders).toEqual(['shared-folder']);
+            (0, vitest_1.expect)(config.projects[0].folders).toEqual(['shared-folder']);
+        });
+        (0, vitest_1.it)('should not apply empty folder selection to projects', () => {
+            const config = {
+                serviceName: 'parent-service',
+                projects: [
+                    { serviceName: 'child-service', folders: ['existing-folder'] }
+                ]
+            };
+            const folderSelections = new Map();
+            folderSelections.set('child-service', []);
+            (0, config_utils_1.applyFoldersToConfig)(config, folderSelections);
+            (0, vitest_1.expect)(config.projects[0].folders).toEqual(['existing-folder']);
+        });
+        (0, vitest_1.it)('should not modify config when folder selection is empty', () => {
+            const config = {
+                serviceName: 'test-service',
+                folders: ['existing-folder']
+            };
+            const folderSelections = new Map();
+            folderSelections.set('test-service', []);
+            (0, config_utils_1.applyFoldersToConfig)(config, folderSelections);
+            (0, vitest_1.expect)(config.folders).toEqual(['existing-folder']);
+        });
+        (0, vitest_1.it)('should preserve services array parameter', () => {
+            const config = {
+                serviceName: 'test-service'
+            };
+            const folderSelections = new Map();
+            folderSelections.set('test-service', ['folder1']);
+            const services = [];
+            (0, config_utils_1.applyFoldersToConfig)(config, folderSelections, services);
+            (0, vitest_1.expect)(config.folders).toEqual(['folder1']);
+        });
+    });
+    (0, vitest_1.describe)('SKIP_ROUTE_MARKER', () => {
+        (0, vitest_1.it)('should be defined as constant', () => {
+            (0, vitest_1.expect)(config_utils_1.SKIP_ROUTE_MARKER).toBe('__SKIP__');
+        });
+    });
+});

package/lib/core/generate.js

@@ -29,16 +29,17 @@ const swagger_typescript_api_1 = require("swagger-typescript-api");
 const cli_progress_1 = __importDefault(require("cli-progress"));
 const utils_1 = require("./utils");
 const config_utils_1 = require("./config-utils");
+const type_filter_1 = require("./type-filter");
 /**
  * 单个配置生成
  */
-const generate = (conf) => {
+const generate = (conf) => __awaiter(void 0, void 0, void 0, function* () {
     const config = (0, utils_1.generateConfig)(conf);
     const modelNamespace = lodash_1.default.upperFirst(lodash_1.default.camelCase(config.modelNamespace));
     const serviceName = lodash_1.default.upperFirst(lodash_1.default.camelCase(config.serviceName));
     const methodNameSet = new Set();
     const skippedRoutes = new Set();
-    return (0, swagger_typescript_api_1.generateApi)({
+    const result = yield (0, swagger_typescript_api_1.generateApi)({
         url: config.source,
         name: config.name,
         output: path_1.default.resolve(config.output, config.serviceName),
@@ -100,6 +101,12 @@ const generate = (conf) => {
                     SKIP_ROUTE_MARKER: config_utils_1.SKIP_ROUTE_MARKER });
             },
             onParseSchema(originalSchema, parsedSchema) {
+                if (originalSchema.format === 'int64' ||
+                    originalSchema.format === 'long') {
+                    if (typeof parsedSchema.content === 'string') {
+                        return Object.assign(Object.assign({}, parsedSchema), { content: parsedSchema.content.replace(/\bnumber\b/g, 'number | string') });
+                    }
+                }
                 if (parsedSchema.name === "any" &&
                     typeof parsedSchema.content === "string" &&
                     parsedSchema.$ref) {
@@ -118,7 +125,11 @@ const generate = (conf) => {
             }
         }
     });
-};
+    if (config.folders && config.folders.length > 0 && config.output) {
+        yield (0, type_filter_1.filterUnusedTypes)(config.output, config.serviceName, serviceName, modelNamespace);
+    }
+    return result;
+});
 exports.generate = generate;
 const generateApis = (config, services) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
@@ -140,10 +151,11 @@ const generateApis = (config, services) => __awaiter(void 0, void 0, void 0, fun
                 yield (0, exports.generate)(conf);
             }
             catch (e) {
-                console.error(e.message);
+                const message = e instanceof Error ? e.message : String(e);
+                console.error(message);
                 failedServices.push({
                     serviceName: conf.serviceName,
-                    error: e.message || '未知错误'
+                    error: message || '未知错误'
                 });
             }
             finally {

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

@@ -0,0 +1 @@
+export declare const filterUnusedTypes: (outputDir: string, serviceDirName: string, serviceTypeName: string, modelNamespace: string) => Promise<void>;

package/lib/core/type-filter.js

@@ -0,0 +1,275 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterUnusedTypes = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const extractTypeReferences = (content, modelNamespace) => {
+    const typeUsageMap = new Map();
+    const regex = new RegExp(`${modelNamespace}\\.(\\w+)\\.(\\w+)`, 'g');
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const serviceName = match[1];
+        const typeName = match[2];
+        if (!typeUsageMap.has(serviceName)) {
+            typeUsageMap.set(serviceName, new Set());
+        }
+        typeUsageMap.get(serviceName).add(typeName);
+    }
+    return typeUsageMap;
+};
+const stripComments = (content) => {
+    const result = [];
+    let i = 0;
+    const len = content.length;
+    while (i < len) {
+        if (content[i] === '"' || content[i] === "'" || content[i] === '`') {
+            const quote = content[i];
+            result.push(content[i]);
+            i++;
+            while (i < len && content[i] !== quote) {
+                if (content[i] === '\\' && i + 1 < len) {
+                    result.push(content[i], content[i + 1]);
+                    i += 2;
+                }
+                else {
+                    result.push(content[i]);
+                    i++;
+                }
+            }
+            if (i < len) {
+                result.push(content[i]);
+                i++;
+            }
+            continue;
+        }
+        if (content[i] === '/' && i + 1 < len && content[i + 1] === '/') {
+            while (i < len && content[i] !== '\n') {
+                i++;
+            }
+            continue;
+        }
+        if (content[i] === '/' && i + 1 < len && content[i + 1] === '*') {
+            i += 2;
+            while (i < len && !(content[i] === '*' && i + 1 < len && content[i + 1] === '/')) {
+                i++;
+            }
+            if (i < len)
+                i += 2;
+            continue;
+        }
+        result.push(content[i]);
+        i++;
+    }
+    return result.join('');
+};
+const collectTypeDefBody = (lines, startIndex, initialLines) => {
+    const firstLine = lines[startIndex].trim();
+    const typeDefLines = [...initialLines];
+    if (!firstLine.includes('{')) {
+        typeDefLines.push(lines[startIndex]);
+        return { typeDefLines, nextIndex: startIndex + 1 };
+    }
+    let braceCount = (firstLine.match(/{/g) || []).length - (firstLine.match(/}/g) || []).length;
+    typeDefLines.push(lines[startIndex]);
+    let i = startIndex + 1;
+    while (i < lines.length && braceCount > 0) {
+        typeDefLines.push(lines[i]);
+        braceCount += (lines[i].match(/{/g) || []).length;
+        braceCount -= (lines[i].match(/}/g) || []).length;
+        i++;
+    }
+    return { typeDefLines, nextIndex: i };
+};
+const extractAllTypeDefinitions = (content) => {
+    const typeDefs = new Map();
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        const isJSDoc = trimmedLine.startsWith('/**');
+        const isBlockComment = trimmedLine.startsWith('/*') && !isJSDoc;
+        if (isJSDoc || isBlockComment) {
+            const commentLines = [];
+            while (i < lines.length) {
+                commentLines.push(lines[i]);
+                if (lines[i].trim().endsWith('*/')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            if (i < lines.length) {
+                const nextLine = lines[i].trim();
+                const typeMatch = nextLine.match(/(?:export\s+)?(?:interface|type|enum)\s+(\w+)/);
+                if (typeMatch) {
+                    const typeName = typeMatch[1];
+                    const { typeDefLines, nextIndex } = collectTypeDefBody(lines, i, commentLines);
+                    typeDefs.set(typeName, typeDefLines.join('\n'));
+                    i = nextIndex;
+                    continue;
+                }
+            }
+            continue;
+        }
+        const typeMatch = trimmedLine.match(/(?:export\s+)?(?:interface|type|enum)\s+(\w+)/);
+        if (typeMatch) {
+            const typeName = typeMatch[1];
+            const { typeDefLines, nextIndex } = collectTypeDefBody(lines, i, []);
+            typeDefs.set(typeName, typeDefLines.join('\n'));
+            i = nextIndex;
+            continue;
+        }
+        i++;
+    }
+    return typeDefs;
+};
+const CHUNK_SIZE = 200;
+const findShortNameRefs = (codeOnly, typeNameSet) => {
+    const found = new Set();
+    const typeNames = Array.from(typeNameSet);
+    for (let start = 0; start < typeNames.length; start += CHUNK_SIZE) {
+        const chunk = typeNames.slice(start, start + CHUNK_SIZE);
+        const pattern = chunk.map(n => `\\b${n}\\b`).join('|');
+        const regex = new RegExp(pattern, 'g');
+        let match;
+        while ((match = regex.exec(codeOnly)) !== null) {
+            found.add(match[0]);
+        }
+    }
+    return found;
+};
+const findTypeDependencies = (rootTypes, typeDefs, modelNamespace, serviceName) => {
+    const visited = new Set();
+    const typeNameSet = new Set(typeDefs.keys());
+    const traverse = (typeName) => {
+        if (visited.has(typeName))
+            return;
+        visited.add(typeName);
+        const typeDef = typeDefs.get(typeName);
+        if (!typeDef)
+            return;
+        const fullRefRegex = new RegExp(`${modelNamespace}\\.${serviceName}\\.(\\w+)`, 'g');
+        let match;
+        while ((match = fullRefRegex.exec(typeDef)) !== null) {
+            const refTypeName = match[1];
+            if (!visited.has(refTypeName)) {
+                traverse(refTypeName);
+            }
+        }
+        const codeOnly = stripComments(typeDef);
+        const shortRefs = findShortNameRefs(codeOnly, typeNameSet);
+        for (const refTypeName of shortRefs) {
+            if (refTypeName !== typeName && !visited.has(refTypeName) && typeDefs.has(refTypeName)) {
+                traverse(refTypeName);
+            }
+        }
+    };
+    for (const typeName of rootTypes) {
+        traverse(typeName);
+    }
+    return visited;
+};
+const detectNamespaceIndent = (lines, serviceName) => {
+    var _a;
+    for (const line of lines) {
+        if (line.trim().startsWith(`export namespace ${serviceName}`)) {
+            const indent = ((_a = line.match(/^(\s*)/)) === null || _a === void 0 ? void 0 : _a[1]) || '';
+            const innerIndent = indent + '  ';
+            return innerIndent;
+        }
+    }
+    return '    ';
+};
+const filterModelTypes = (modelContent, usedTypes, modelNamespace, serviceName) => {
+    const lines = modelContent.split('\n');
+    const allTypeDefs = extractAllTypeDefinitions(modelContent);
+    const allUsedTypes = findTypeDependencies(usedTypes, allTypeDefs, modelNamespace, serviceName);
+    const filteredTypeDefs = [];
+    allTypeDefs.forEach((typeDef, name) => {
+        if (allUsedTypes.has(name)) {
+            filteredTypeDefs.push(typeDef);
+        }
+    });
+    let inModelNamespace = false;
+    let inServiceNamespace = false;
+    const header = [];
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith(`export namespace ${modelNamespace}`)) {
+            inModelNamespace = true;
+            header.push(line);
+            continue;
+        }
+        if (trimmedLine.startsWith(`export namespace ${serviceName}`)) {
+            inServiceNamespace = true;
+            header.push(line);
+            continue;
+        }
+        if (inServiceNamespace) {
+            break;
+        }
+        if (inModelNamespace) {
+            if (trimmedLine === '}') {
+                inModelNamespace = false;
+            }
+            break;
+        }
+        header.push(line);
+    }
+    const closingIndent = detectNamespaceIndent(lines, serviceName);
+    const result = [
+        ...header,
+        ...filteredTypeDefs,
+        closingIndent + '}',
+        '}'
+    ];
+    return result.join('\n');
+};
+const filterUnusedTypes = (outputDir, serviceDirName, serviceTypeName, modelNamespace) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const serviceDir = path_1.default.join(outputDir, serviceDirName);
+        const indexFile = path_1.default.join(serviceDir, 'index.ts');
+        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);
+        if (!typeUsageMap.has(serviceTypeName)) {
+            console.log(`没有找到服务 ${serviceTypeName} 的类型引用，跳过过滤`);
+            return;
+        }
+        const usedTypes = typeUsageMap.get(serviceTypeName);
+        if (usedTypes.size === 0) {
+            console.log(`服务 ${serviceTypeName} 没有使用任何类型，跳过过滤`);
+            return;
+        }
+        const filteredModelContent = 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;
+        console.log(`✅ 服务 ${serviceTypeName} 已过滤类型`);
+        console.log(`   原始文件: ${originalLines} 行`);
+        console.log(`   过滤后: ${filteredLines} 行`);
+        console.log(`   减少: ${originalLines - filteredLines} 行 (${((1 - filteredLines / originalLines) * 100).toFixed(1)}%)`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const stack = error instanceof Error ? error.stack : '';
+        console.error(`过滤类型时出错: ${message}`);
+        if (stack)
+            console.error(stack);
+    }
+});
+exports.filterUnusedTypes = filterUnusedTypes;

package/lib/core/utils.test.d.ts

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

package/lib/core/utils.test.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const utils_1 = require("./utils");
+(0, vitest_1.describe)('utils', () => {
+    (0, vitest_1.describe)('generateConfig', () => {
+        (0, vitest_1.it)('should generate config with default values', () => {
+            const conf = {
+                serviceName: 'test-service'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.sourceType).toBe('apifox');
+            (0, vitest_1.expect)(result.output).toContain('src/services');
+            (0, vitest_1.expect)(result.name).toBe('model.d.ts');
+            (0, vitest_1.expect)(result.modular).toBe(false);
+            (0, vitest_1.expect)(result.modelNamespace).toBe('Model');
+            (0, vitest_1.expect)(result.requestTempalte).toBe(`import { request } from '@wx-sab/renkei'`);
+        });
+        (0, vitest_1.it)('should merge user config with default config', () => {
+            const conf = {
+                serviceName: 'test-service',
+                sourceType: 'swagger',
+                output: '/custom/output',
+                name: 'custom.d.ts',
+                modelNamespace: 'CustomModel'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.sourceType).toBe('swagger');
+            (0, vitest_1.expect)(result.output).toBe('/custom/output');
+            (0, vitest_1.expect)(result.name).toBe('custom.d.ts');
+            (0, vitest_1.expect)(result.modelNamespace).toBe('CustomModel');
+        });
+        (0, vitest_1.it)('should generate apifox source when sourceType is apifox', () => {
+            const conf = {
+                serviceName: 'test-service',
+                sourceType: 'apifox',
+                apifoxProjectId: '12345'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.source).toContain('projectId=12345');
+            (0, vitest_1.expect)(result.source).toContain('127.0.0.1:4523');
+        });
+        (0, vitest_1.it)('should generate swagger source when sourceType is swagger', () => {
+            const conf = {
+                serviceName: 'my-service',
+                sourceType: 'swagger'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.source).toContain('my-service');
+            (0, vitest_1.expect)(result.source).toContain('api-docs');
+        });
+        (0, vitest_1.it)('should use custom source if provided', () => {
+            const conf = {
+                serviceName: 'test-service',
+                source: 'https://custom.api.com/swagger'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.source).toBe('https://custom.api.com/swagger');
+        });
+        (0, vitest_1.it)('should apply customResponseType function', () => {
+            const conf = {
+                serviceName: 'test-service',
+                customResponseType: (type) => `CustomResponse<${type}>`
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.customResponseType).toBeDefined();
+            (0, vitest_1.expect)(result.customResponseType('User')).toBe('CustomResponse<User>');
+        });
+        (0, vitest_1.it)('should apply customMockService function', () => {
+            const conf = {
+                serviceName: 'test-service',
+                apifoxProjectId: '12345',
+                customMockService: (config) => `https://mock.example.com/${config.apifoxProjectId}`
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.customMockService).toBeDefined();
+            (0, vitest_1.expect)(result.customMockService(result)).toBe('https://mock.example.com/12345');
+        });
+        (0, vitest_1.it)('should use default customResponseType when not provided', () => {
+            const conf = {
+                serviceName: 'test-service'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.customResponseType).toBeDefined();
+            (0, vitest_1.expect)(result.customResponseType('User')).toBe('AxiosResponse<User>');
+        });
+        (0, vitest_1.it)('should use default customMockService when apifoxProjectId is provided', () => {
+            const conf = {
+                serviceName: 'test-service',
+                apifoxProjectId: '12345'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.customMockService).toBeDefined();
+            (0, vitest_1.expect)(result.customMockService(result)).toContain('mock.apifox.cn');
+            (0, vitest_1.expect)(result.customMockService(result)).toContain('12345');
+        });
+        (0, vitest_1.it)('should return empty string for default customMockService without apifoxProjectId', () => {
+            const conf = {
+                serviceName: 'test-service'
+            };
+            const result = (0, utils_1.generateConfig)(conf);
+            (0, vitest_1.expect)(result.customMockService).toBeDefined();
+            (0, vitest_1.expect)(result.customMockService(result)).toBe('');
+        });
+    });
+    (0, vitest_1.describe)('generateRouteName', () => {
+        (0, vitest_1.it)('should generate route name from method and route', () => {
+            const result = (0, utils_1.generateRouteName)('GET', '/api/users');
+            (0, vitest_1.expect)(result).toBe('get_api_users');
+        });
+        (0, vitest_1.it)('should handle route with path parameters', () => {
+            const result = (0, utils_1.generateRouteName)('POST', '/api/users/{id}');
+            (0, vitest_1.expect)(result).toBe('post_api_users_$p');
+        });
+        (0, vitest_1.it)('should convert to lowercase', () => {
+            const result = (0, utils_1.generateRouteName)('GET', '/API/Users');
+            (0, vitest_1.expect)(result).toBe('get_api_users');
+        });
+        (0, vitest_1.it)('should replace hyphens with underscores', () => {
+            const result = (0, utils_1.generateRouteName)('GET', '/api/user-profiles');
+            (0, vitest_1.expect)(result).toBe('get_api_user_profiles');
+        });
+        (0, vitest_1.it)('should replace dots with underscores', () => {
+            const result = (0, utils_1.generateRouteName)('GET', '/api/user.profiles');
+            (0, vitest_1.expect)(result).toBe('get_api_user_profiles');
+        });
+        (0, vitest_1.it)('should replace asterisks with underscores', () => {
+            const result = (0, utils_1.generateRouteName)('GET', '/api/user*profiles');
+            (0, vitest_1.expect)(result).toBe('get_api_user_profiles');
+        });
+        (0, vitest_1.it)('should handle complex route patterns', () => {
+            const result = (0, utils_1.generateRouteName)('DELETE', '/api/users/{userId}/posts/{postId}');
+            (0, vitest_1.expect)(result).toBe('delete_api_users_$p_posts_$p');
+        });
+        (0, vitest_1.it)('should handle empty route segments', () => {
+            const result = (0, utils_1.generateRouteName)('GET', '/api//users');
+            (0, vitest_1.expect)(result).toBe('get_api_users');
+        });
+    });
+    (0, vitest_1.describe)('getValidName', () => {
+        (0, vitest_1.it)('should return null for empty string', () => {
+            const result = (0, utils_1.getValidName)('');
+            (0, vitest_1.expect)(result).toBeNull();
+        });
+        (0, vitest_1.it)('should return null for null/undefined', () => {
+            // 测试边界情况：null 和 undefined 输入
+            (0, vitest_1.expect)((0, utils_1.getValidName)(null)).toBeNull();
+            (0, vitest_1.expect)((0, utils_1.getValidName)(undefined)).toBeNull();
+        });
+        (0, vitest_1.it)('should return the same string if no special characters', () => {
+            const result = (0, utils_1.getValidName)('UserVO');
+            (0, vitest_1.expect)(result).toBe('UserVO');
+        });
+        (0, vitest_1.it)('should handle nested generic types', () => {
+            const result = (0, utils_1.getValidName)('ResponseVO«AgentTraceVO»');
+            (0, vitest_1.expect)(result).toBe('ResponseVOAgentTraceVO');
+        });
+        (0, vitest_1.it)('should handle path with slashes', () => {
+            const result = (0, utils_1.getValidName)('path/to/Component');
+            (0, vitest_1.expect)(result).toBe('Component');
+        });
+        (0, vitest_1.it)('should remove all non-word characters', () => {
+            const result = (0, utils_1.getValidName)('User@VO#Test');
+            (0, vitest_1.expect)(result).toBe('UserVOTest');
+        });
+        (0, vitest_1.it)('should handle complex nested types', () => {
+            const result = (0, utils_1.getValidName)('List«Map«String,Object»»');
+            (0, vitest_1.expect)(result).toBe('ListMapStringObject');
+        });
+    });
+    (0, vitest_1.describe)('defineConfig', () => {
+        (0, vitest_1.it)('should return single config', () => {
+            const config = {
+                serviceName: 'test-service',
+                sourceType: 'apifox',
+                apifoxProjectId: '12345'
+            };
+            const result = (0, utils_1.defineConfig)(config);
+            (0, vitest_1.expect)(result).toEqual(config);
+        });
+        (0, vitest_1.it)('should return array of configs', () => {
+            const configs = [
+                { serviceName: 'service1', sourceType: 'apifox', apifoxProjectId: '123' },
+                { serviceName: 'service2', sourceType: 'swagger' }
+            ];
+            const result = (0, utils_1.defineConfig)(configs);
+            (0, vitest_1.expect)(result).toEqual(configs);
+            (0, vitest_1.expect)(Array.isArray(result)).toBe(true);
+            (0, vitest_1.expect)(result).toHaveLength(2);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wx-sab/renkei",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "解析swagger转为ts代码，日本动漫《游戏王》中的‘Renkei’，意为连携或协作。",
   "main": "./lib/index.js",
   "bin": {
@@ -11,7 +11,10 @@
     "clean": "rm -rf lib",
     "build": "npm run clean & tsc --outDir lib",
     "version:alpha": "npm version premajor --preid alpha",
-    "api": "ts-node --transpile-only ./src/cli.ts api"
+    "api": "ts-node --transpile-only ./src/cli.ts api",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage"
   },
   "repository": {
     "type": "git",
@@ -24,7 +27,10 @@
     "@types/inquirer": "9.0.7",
     "@types/lodash": "^4.14.196",
     "@types/node": "^20.4.7",
-    "typescript": "^5.1.6"
+    "@vitest/coverage-v8": "^4.1.4",
+    "@vitest/ui": "^4.1.4",
+    "typescript": "^5.1.6",
+    "vitest": "^4.1.4"
   },
   "files": [
     "lib",