@wx-sab/renkei 1.2.5 → 1.3.1

package/lib/core/folder-selector.js

@@ -0,0 +1,147 @@
+"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.selectFoldersForServices = exports.selectFolders = exports.extractFoldersFromSwagger = exports.fetchSwaggerDocument = void 0;
+const axios_1 = __importDefault(require("axios"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("./utils");
+const fetchSwaggerDocument = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const finalConfig = (0, utils_1.generateConfig)(config);
+    if (!finalConfig.source) {
+        throw new Error('未配置文档源');
+    }
+    try {
+        const response = yield axios_1.default.get(finalConfig.source, {
+            timeout: 30000,
+            validateStatus: (status) => status < 400
+        });
+        return response.data;
+    }
+    catch (error) {
+        const message = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message;
+        throw new Error(`获取文档失败: ${message}`, { cause: error });
+    }
+});
+exports.fetchSwaggerDocument = fetchSwaggerDocument;
+const extractFoldersFromSwagger = (swaggerDoc) => {
+    const folderMap = new Map();
+    if (swaggerDoc.paths) {
+        Object.entries(swaggerDoc.paths).forEach(([path, methods]) => {
+            if (methods && typeof methods === 'object') {
+                Object.values(methods).forEach((methodInfo) => {
+                    if (methodInfo && methodInfo['x-apifox-folder']) {
+                        const folder = methodInfo['x-apifox-folder'];
+                        const folderPath = folder.split('/')[0];
+                        if (folderMap.has(folderPath)) {
+                            const info = folderMap.get(folderPath);
+                            info.count++;
+                            info.paths.add(path);
+                        }
+                        else {
+                            folderMap.set(folderPath, {
+                                count: 1,
+                                paths: new Set([path])
+                            });
+                        }
+                    }
+                });
+            }
+        });
+    }
+    const folders = [];
+    folderMap.forEach((info, name) => {
+        folders.push({
+            name,
+            path: name,
+            count: info.count
+        });
+    });
+    return lodash_1.default.sortBy(folders, ['name']);
+};
+exports.extractFoldersFromSwagger = extractFoldersFromSwagger;
+const selectFolders = (folders) => __awaiter(void 0, void 0, void 0, function* () {
+    if (folders.length === 0) {
+        console.log('未找到任何文件夹，将生成所有接口');
+        return [];
+    }
+    const totalCount = folders.reduce((sum, f) => sum + f.count, 0);
+    console.log('\n发现以下文件夹:');
+    folders.forEach((folder, index) => {
+        console.log(`  ${index + 1}. ${folder.name} (${folder.count} 个接口)`);
+    });
+    const { selectedFolders } = yield inquirer_1.default.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedFolders',
+            message: '请选择要生成的文件夹 (空格选择，回车确认)',
+            choices: [
+                {
+                    name: `全部 (共 ${totalCount} 个接口)`,
+                    value: '__ALL__',
+                    checked: true
+                },
+                new inquirer_1.default.Separator('── 具体文件夹 ──'),
+                ...folders.map(f => ({
+                    name: `${f.name} (${f.count} 个接口)`,
+                    value: f.name,
+                    checked: false
+                }))
+            ],
+            pageSize: 15,
+            loop: false
+        }
+    ]);
+    // 如果选择了"全部"选项，返回空数组（表示生成所有接口）
+    if (selectedFolders.includes('__ALL__')) {
+        return [];
+    }
+    return selectedFolders;
+});
+exports.selectFolders = selectFolders;
+const selectFoldersForServices = (configs) => __awaiter(void 0, void 0, void 0, function* () {
+    const folderSelections = new Map();
+    const failedServices = [];
+    for (const config of configs) {
+        console.log(`\n正在分析服务: ${config.serviceName}`);
+        try {
+            const swaggerDoc = yield (0, exports.fetchSwaggerDocument)(config);
+            const folders = (0, exports.extractFoldersFromSwagger)(swaggerDoc);
+            if (folders.length > 0) {
+                const selectedFolders = yield (0, exports.selectFolders)(folders);
+                folderSelections.set(config.serviceName, selectedFolders);
+            }
+            else {
+                console.log(`  服务 ${config.serviceName} 未找到文件夹信息，将生成所有接口`);
+                folderSelections.set(config.serviceName, []);
+            }
+        }
+        catch (error) {
+            const errorMessage = error.message || '未知错误';
+            console.error(`  获取服务 ${config.serviceName} 的文档失败: ${errorMessage}`);
+            failedServices.push({ serviceName: config.serviceName, error: errorMessage });
+            folderSelections.set(config.serviceName, []);
+        }
+    }
+    if (failedServices.length > 0) {
+        console.log('\n⚠️  部分服务获取失败:');
+        failedServices.forEach(({ serviceName, error }) => {
+            console.log(`  - ${serviceName}: ${error}`);
+        });
+        console.log('这些服务将生成所有接口\n');
+    }
+    return folderSelections;
+});
+exports.selectFoldersForServices = selectFoldersForServices;

package/lib/core/generate.js

@@ -28,36 +28,27 @@ const lodash_1 = __importDefault(require("lodash"));
 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();
-    return (0, swagger_typescript_api_1.generateApi)({
+    const skippedRoutes = new Set();
+    const result = yield (0, swagger_typescript_api_1.generateApi)({
         url: config.source,
-        // 文件名
         name: config.name,
-        // 输出目录
         output: path_1.default.resolve(config.output, config.serviceName),
-        // 模块化？
         modular: false,
-        // 静默
         silent: true,
         extractRequestParams: true,
-        // 清空输出目录？
         cleanOutput: false,
-        // 生成请求客户端
         generateClient: false,
-        // 模板文件
         templates: path_1.default.resolve(__dirname, "../../templates"),
-        // 额外的，此处为了生成接口
         extraTemplates: [
             {
                 name: "index.ts",
@@ -67,7 +58,19 @@ const generate = (conf) => {
         hooks: {
             onCreateRouteName(routeNameInfo, rawRouteInfo) {
                 var _a, _b, _c;
-                // 自定义请求路由
+                if (config.folders && config.folders.length > 0) {
+                    const extendedRouteInfo = rawRouteInfo;
+                    const folder = extendedRouteInfo['x-apifox-folder'] || '';
+                    const folderPath = folder.split('/')[0];
+                    if (!config.folders.includes(folderPath)) {
+                        skippedRoutes.add(routeNameInfo.original);
+                        return {
+                            duplicate: false,
+                            original: config_utils_1.SKIP_ROUTE_MARKER,
+                            usage: config_utils_1.SKIP_ROUTE_MARKER
+                        };
+                    }
+                }
                 const newRoute = (_a = config.customRequestUrl) === null || _a === void 0 ? void 0 : _a.call(config, rawRouteInfo, config);
                 if (typeof newRoute === "string") {
                     rawRouteInfo.route = newRoute;
@@ -77,12 +80,10 @@ const generate = (conf) => {
                     // @ts-ignore
                     rawRouteInfo.mockUrl = newRoute.mockUrl;
                 }
-                // 检测路径中的常见错误
                 if (/ /.test(rawRouteInfo.route)) {
                     throw Error(`语法错误，路径中存在空格，请核对，可以尝试通过配置 customRequestUrl 进行处理，当前处理节点为：${rawRouteInfo.route}`);
                 }
                 else if (/([\u4e00-\u9fa5])/.test(rawRouteInfo.route)) {
-                    // 如果路径里面包含中文，警告用户，因为通常不会写带中文的api，但是直接抄配置文件很有可能由于大小项目的apifox目录组织结构不同，导致这个问题。
                     console.warn(`警告：检测到请求路径中存在中文，这通常是因为错误配置了 customRequestUrl，请进行核对，当前处理路径为：${rawRouteInfo.route} `);
                 }
                 const methodName = (_c = (_b = config === null || config === void 0 ? void 0 : config.customRouteName) === null || _b === void 0 ? void 0 : _b.call(config, routeNameInfo, rawRouteInfo)) !== null && _c !== void 0 ? _c : (0, utils_1.generateRouteName)(rawRouteInfo.method, rawRouteInfo.route);
@@ -96,10 +97,10 @@ const generate = (conf) => {
             },
             onPrepareConfig(currentConfiguration) {
                 return Object.assign(Object.assign({}, currentConfiguration), { modelNamespace,
-                    serviceName, requestTempalte: config.requestTempalte });
+                    serviceName, requestTempalte: config.requestTempalte, skippedRoutes,
+                    SKIP_ROUTE_MARKER: config_utils_1.SKIP_ROUTE_MARKER });
             },
             onParseSchema(originalSchema, parsedSchema) {
-                // 针对解析出的 any 做转换，主要是 swagger 3.0
                 if (parsedSchema.name === "any" &&
                     typeof parsedSchema.content === "string" &&
                     parsedSchema.$ref) {
@@ -109,8 +110,6 @@ const generate = (conf) => {
             },
             onCreateRoute(routeData) {
                 var _a;
-                // 将 /api/v1/order-mains/{orderId} 转成 /api/v1/order-mains/${orderId}
-                // routeData.raw.route 是进过 customRequestUrl 转换过的
                 // @ts-ignore
                 routeData.request.path = (_a = routeData.raw.route) === null || _a === void 0 ? void 0 : _a.replace(/\{([^}]+)\}/g, "${$1}");
                 return routeData;
@@ -120,38 +119,23 @@ 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* () {
+const generateApis = (config, services) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
-    // 递归收集config下可能有的 projects ，也当做新的config
-    const collectConfig = (conf, collects = []) => {
-        if (!conf)
-            return collects;
-        if (Array.isArray(conf)) {
-            conf.forEach((con) => collectConfig(con, collects));
-        }
-        else {
-            collects.push(lodash_1.default.omit(conf, "projects"));
-            if (Array.isArray(conf.projects)) {
-                conf.projects.forEach((project) => collectConfig(Object.assign(Object.assign({}, lodash_1.default.omit(conf, "projects")), project), collects));
-            }
-        }
-        return collects;
-    };
-    const _configs = collectConfig(config).filter((conf) => {
-        // 只筛选指定的服务
+    const _configs = (0, config_utils_1.collectConfig)(config).filter((conf) => {
         if (services.length > 0) {
             return services.includes(conf.serviceName);
         }
         return true;
     });
-    // 进度条控制
     const progress = new cli_progress_1.default.SingleBar({});
     progress.start(_configs.length, 0);
-    let failedServices = []; // 统计失败服务
+    const failedServices = [];
     try {
         for (var _d = true, _configs_1 = __asyncValues(_configs), _configs_1_1; _configs_1_1 = yield _configs_1.next(), _a = _configs_1_1.done, !_a; _d = true) {
             _c = _configs_1_1.value;
@@ -161,8 +145,12 @@ const generateApis = (config, services // 指定服务
                 yield (0, exports.generate)(conf);
             }
             catch (e) {
-                console.error(e.message);
-                failedServices.push(conf.serviceName);
+                const message = e instanceof Error ? e.message : String(e);
+                console.error(message);
+                failedServices.push({
+                    serviceName: conf.serviceName,
+                    error: message || '未知错误'
+                });
             }
             finally {
                 progress.increment(1);
@@ -177,8 +165,14 @@ const generateApis = (config, services // 指定服务
         finally { if (e_1) throw e_1.error; }
     }
     progress.stop();
-    console.info(`✅ 执行完毕${failedServices.length
-        ? `，以下服务生成失败: ${failedServices.join("、")}`
-        : ""}`);
+    if (failedServices.length > 0) {
+        console.info('✅ 执行完毕，以下服务生成失败:');
+        failedServices.forEach(({ serviceName, error }) => {
+            console.info(`  - ${serviceName}: ${error}`);
+        });
+    }
+    else {
+        console.info('✅ 执行完毕');
+    }
 });
 exports.generateApis = generateApis;

package/lib/core/interface.d.ts

@@ -1,4 +1,15 @@
 import { GenerateApiParams, RawRouteInfo, RouteNameInfo } from "swagger-typescript-api";
+export interface ExtendedRawRouteInfo extends RawRouteInfo {
+    'x-apifox-folder'?: string;
+}
+export interface ConfigWithProjects extends BasicConfig {
+    projects?: ConfigWithProjects[];
+}
+export interface ServiceConfig {
+    serviceName: string;
+    folders?: string[];
+    projects?: ServiceConfig[];
+}
 /**
  * 基础配置
  */
@@ -60,6 +71,11 @@ export type BasicConfig = {
      * 自定义生成的接口名
      */
     customRouteName?(routeNameInfo: RouteNameInfo, rawRouteInfo: RawRouteInfo): string;
+    /**
+     * 要生成的文件夹列表（文件夹名称）
+     * 如果为空数组，则生成所有接口
+     */
+    folders?: string[];
 };
 /**
  * 如果 sourceType 是 apifox，则适用该配置项

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 {};