czh-api 1.0.0

package/README.md

@@ -0,0 +1,104 @@
+# CZH API
+
+`czh-api` 是一款功能强大且灵活的前端 API 同步工具，灵感来源于 Pont。它能够根据 Swagger/OpenAPI 文档自动生成 TypeScript API 代码，帮助您保持前后端接口的一致性，提高开发效率，并减少手动编写代码带来的错误。
+
+## ✨ 功能特性
+
+- **多标准支持**: 完美兼容 Swagger v2, OpenAPI v3, 以及 Knife4j 风格的 JSON 文档。
+- **智能模块生成**: 根据接口的 `x-package` 字段（例如 `com.czh.SysConfigController` -> `sysConfig` 模块）自动对 API 进行模块化分组，当该字段缺失时，则使用 URL 的第一段作为备用方案。
+- **清晰的命名规范**: API 函数名采用 `HTTP方法` + `驼峰式路径` 的方式生成（例如 `POST /sys/user/add` -> `postSysUserAdd`），确保了全局唯一性和代码的可读性。
+- **可定制化模板**: 提供 Handlebars (`.hbs`) 模板，覆盖 API、类型和模块索引文件，允许您完全自定义生成的代码风格。
+- **自动化类型生成**: 为所有请求参数和响应数据生成 TypeScript 类型定义（`types.ts`）。
+- **详尽的 JSDoc 注释**: 为每个 API 函数自动生成全面的 JSDoc 注释，包含接口描述以及每个参数详尽的 `@param` 注解, 参数名称带[]则后端为非必填。
+- **灵活的配置**: 使用 `czh-api.config.json` 文件来管理所有设置，例如 Swagger 地址、输出目录、需要排除的路径以及自定义导入语句等。
+- **NPM 包与命令行工具**: 已封装为 Node.js 命令行工具，便于在任何前端项目中安装和使用。
+
+## 🚀 安装
+
+通过 npm 全局安装本工具：
+
+```bash
+npm install -g czh-api
+```
+
+## 🛠️ 使用说明
+
+### 主要命令
+
+`czh-api` 提供了以下核心命令来管理您的 API 代码生成：
+
+| 命令          | 别名 (`alias`) | 描述                                                                                                                              |
+|---------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------|
+| `czh-api` | `-h`, `--help` | **显示帮助信息**。列出所有可用的命令和选项。                                                                                      |
+| `czh-api -v`| `--version`    | **查看版本号**。显示当前安装的 `czh-api` 的版本。                                                                             |
+| `czh-api init`  |                | **初始化项目**。在当前目录下创建 `czh-api.config.json` 配置文件和 `czh-api-template` 模板文件夹。                         |
+| `czh-api build` |                | **生成 API 代码**。根据配置文件中的 `url` 获取远程 API 文档，并在指定的 `outputDir` 目录中生成所有 TypeScript 模块、类型和索引文件。 |
+
+### 配置文件 (`czh-api.config.json`)
+
+`init` 命令会生成此文件。您需要根据项目需求进行编辑：
+
+```json
+{
+  "url": "https://your-swagger-docs/v2/api-docs",
+  "outputDir": "./src/api",
+  "templates": "./czh-api-template",
+  "customImports": [
+    "import http from '@/utils/http';"
+  ],
+  "excludePaths": [
+    "/sys/log",
+    "/tool/gen"
+  ]
+}
+```
+
+**配置项说明:**
+
+| 选项           | 类型       | 是否必须 | 描述                                                                    |
+|------------------|------------|----------|-------------------------------------------------------------------------|
+| `url`            | `string`   | 是       | 您的 Swagger/OpenAPI JSON 文档地址。                                     |
+| `outputDir`      | `string`   | 是       | 用于存放生成的 API 模块的目录。                                         |
+| `templates`      | `string`   | 否       | 指向您的自定义模板目录的路径。默认为 `init` 命令生成的目录。             |
+| `customImports`  | `string[]` | 否       | 一个自定义导入语句的数组，会被添加到每个生成的 API 文件的顶部。         |
+| `excludePaths`   | `string[]` | 否       | 一个 URL 路径前缀的数组。任何以此数组中前缀开头的 API 都将被忽略。     |
+
+
+## 👨‍💻 开发者指南
+
+如果您克隆了本仓库并希望进行二次开发、贡献或发布您自己的版本，请遵循以下步骤：
+
+### 1. 安装依赖
+在项目根目录下运行，安装所有开发和运行时所需的依赖。
+```bash
+npm install
+```
+
+### 2. 编译源码
+此命令会将 `src/` 目录下的 TypeScript 源码编译成 JavaScript，并输出到 `dist/` 目录。同时，它会自动复制必要的模板文件。
+```bash
+npm run build
+```
+
+### 3. 本地测试
+使用 `npm link` 可以将本地开发版本的包链接到全局，让您可以在任何地方通过 `czh-api` 命令来测试您的修改，而无需发布到 NPM。
+```bash
+npm link
+```
+
+### 4. 发布到 NPM
+当您准备好发布新版本时，请执行此命令。
+**注意**: 在发布前，请确保您已登录 NPM (`npm login`)，并在 `package.json` 中更新了包的版本号。
+```bash
+npm publish
+```
+
+### 5. 解除本地链接/卸载
+如果您想解除本地的链接状态，可以使用 `unlink` 命令。如果您想从全局卸载，请使用 `uninstall`。
+```bash
+# 解除本地开发链接
+npm unlink czh-api
+
+# 或，全局卸载包
+npm uninstall -g czh-api
+```

package/dist/commands/bill.js

@@ -0,0 +1 @@
+"use strict";

package/dist/commands/build.js

@@ -0,0 +1,129 @@
+"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.handleBuild = void 0;
+/*
+ * @description:
+ * @Author: czh
+ * @Date: 2025-07-02 10:39:30
+ * @LastEditors: Czh
+ * @LastEditTime: 2025-07-02 11:47:00
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const SwaggerParser = require('swagger-parser');
+const parser_1 = require("../core/parser");
+const handlebars_1 = __importDefault(require("handlebars"));
+const rimraf_1 = require("rimraf");
+const axios_1 = __importDefault(require("axios"));
+const json_schema_to_typescript_1 = require("json-schema-to-typescript");
+const handleBuild = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        console.log(chalk_1.default.blue('Building API from source...'));
+        // Load config
+        const configPath = path_1.default.join(process.cwd(), 'czh-api.config.json');
+        if (!fs_1.default.existsSync(configPath)) {
+            console.error(chalk_1.default.red('错误：找不到 czh-api.config.json 配置文件。请先运行 `czh-api init`。'));
+            process.exit(1);
+        }
+        const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        // Fetch and parse Swagger/OpenAPI document
+        console.log(chalk_1.default.blue(`正在从 ${config.url} 获取 API 文档...`));
+        const response = yield axios_1.default.get(config.url);
+        const api = yield SwaggerParser.bundle(response.data);
+        console.log(chalk_1.default.green('Swagger document fetched and bundled successfully.'));
+        // Process the API document
+        const modules = (0, parser_1.processApi)(api, config.excludePaths || []);
+        console.log(chalk_1.default.blue('API processed into modules.'));
+        // Clean output directory
+        const outputDir = path_1.default.join(process.cwd(), config.outputDir);
+        if (fs_1.default.existsSync(outputDir)) {
+            yield (0, rimraf_1.rimraf)(outputDir);
+        }
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+        console.log(chalk_1.default.yellow(`Cleaned output directory: ${outputDir}`));
+        const readTemplate = (templatePath, templateName) => {
+            const defaultPath = path_1.default.resolve(__dirname, '../templates', templateName);
+            const userPath = templatePath ? path_1.default.join(process.cwd(), templatePath, templateName) : defaultPath;
+            try {
+                return fs_1.default.readFileSync(userPath, 'utf-8');
+            }
+            catch (error) {
+                return fs_1.default.readFileSync(defaultPath, 'utf-8');
+            }
+        };
+        const apiTemplateStr = readTemplate(config.templates, 'api.hbs');
+        const apiTemplate = handlebars_1.default.compile(apiTemplateStr);
+        for (const moduleName in modules) {
+            const module = modules[moduleName];
+            const moduleDir = path_1.default.join(outputDir, moduleName);
+            fs_1.default.mkdirSync(moduleDir, { recursive: true });
+            let typesContent = '';
+            // Generate types.ts
+            if (Object.keys(module.schemas).length > 0) {
+                const schemasWithTitles = {};
+                for (const schemaName in module.schemas) {
+                    schemasWithTitles[schemaName] = Object.assign(Object.assign({}, module.schemas[schemaName]), { title: schemaName });
+                }
+                const rootSchemaForCompiler = {
+                    title: 'schemas',
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                    definitions: schemasWithTitles,
+                    components: {
+                        schemas: schemasWithTitles
+                    }
+                };
+                typesContent = yield (0, json_schema_to_typescript_1.compile)(rootSchemaForCompiler, 'schemas', {
+                    bannerComment: '/* eslint-disable */\n/**\n* This file was automatically generated by czh-api.\n* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,\n* and run czh-api build to regenerate this file.\n*/',
+                    unreachableDefinitions: true,
+                    additionalProperties: false,
+                });
+                typesContent = typesContent.replace(/export interface \w+ \{\s*\}\n/g, '');
+                const refCommentRegex = /\/\*\*\n \* This interface was referenced by `\w+`'s JSON-Schema[\s\S]*?\*\/\n/g;
+                typesContent = typesContent.replace(refCommentRegex, '');
+                typesContent = typesContent.replace(/:\s*\{\}\[\]/g, ': any[]');
+                typesContent = typesContent.replace(/\[k: string\]: \{\}/g, '[k: string]: any');
+                const inlineIndexSignatureRegex = /:\s*\{\s*\/\*\*[\s\S]*?\*\/[\s\n\r]*\[k: string\]: any;\s*\};/g;
+                typesContent = typesContent.replace(inlineIndexSignatureRegex, ': any;');
+                typesContent = typesContent.replace(/: \{\}/g, ': any');
+                typesContent = typesContent.replace(/\}\n/g, '}\n\n');
+                fs_1.default.writeFileSync(path_1.default.join(moduleDir, 'types.ts'), typesContent);
+            }
+            // Generate API file
+            const allReferencedTypes = [...new Set(module.endpoints.flatMap(e => e.referencedTypes))];
+            const customImports = config.customImports || [`import http from "${config.httpClientPath}";`];
+            let apiFileContent = '';
+            if (module.description) {
+                apiFileContent += `/**\n * @description ${module.description}\n */\n\n`;
+            }
+            apiFileContent += `${customImports.join('\n')}\n`;
+            if (allReferencedTypes.length > 0) {
+                apiFileContent += `import type { ${allReferencedTypes.join(', ')} } from './types';\n\n`;
+            }
+            apiFileContent += module.endpoints.map(endpoint => apiTemplate(endpoint)).join('\n\n');
+            fs_1.default.writeFileSync(path_1.default.join(moduleDir, `${moduleName}.ts`), apiFileContent);
+            // Generate index.ts
+            const exportTypes = typesContent ? `\nexport * from './types';` : '';
+            fs_1.default.writeFileSync(path_1.default.join(moduleDir, 'index.ts'), `export * from './${moduleName}';${exportTypes}\n`);
+        }
+        console.log(chalk_1.default.green.bold('API code generated successfully!'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('An error occurred during build process:'), error);
+    }
+});
+exports.handleBuild = handleBuild;

package/dist/commands/init.js

@@ -0,0 +1,66 @@
+"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.handleInit = void 0;
+/*
+ * @description:
+ * @Author: czh
+ * @Date: 2025-07-02 10:39:17
+ * @LastEditors: Czh
+ * @LastEditTime: 2025-07-02 11:45:10
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const defaultConfig = {
+    url: 'https://petstore.swagger.io/v2/swagger.json',
+    outputDir: './src/api',
+    templates: './czh-api-template',
+    customImports: ['import http from "@/utils/http";'],
+    excludePaths: []
+};
+const templates = ['api.hbs', 'index.hbs', 'types.hbs'];
+const handleInit = () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(chalk_1.default.green('Initializing czh-api...'));
+    const configPath = path_1.default.join(process.cwd(), 'czh-api.config.json');
+    const templatesPath = path_1.default.join(process.cwd(), 'czh-api-template');
+    try {
+        yield promises_1.default.access(configPath);
+        console.log(chalk_1.default.yellow('Config file already exists. Aborting.'));
+        return;
+    }
+    catch (error) {
+        // File doesn't exist, which is what we want.
+    }
+    try {
+        // Write config file
+        yield promises_1.default.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
+        console.log(chalk_1.default.cyan(`Created config file: ${configPath}`));
+        // Create templates directory
+        yield promises_1.default.mkdir(templatesPath, { recursive: true });
+        // Copy template files
+        for (const templateName of templates) {
+            const sourcePath = path_1.default.resolve(__dirname, '../templates', templateName);
+            const destPath = path_1.default.join(templatesPath, templateName);
+            yield promises_1.default.copyFile(sourcePath, destPath);
+            console.log(chalk_1.default.cyan(`Created template: ${destPath}`));
+        }
+        console.log(chalk_1.default.green.bold('Initialization complete!'));
+        console.log(chalk_1.default.white('You can now edit the config and templates, then run `czh-api build`.'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('An error occurred during initialization:'), error);
+    }
+});
+exports.handleInit = handleInit;

package/dist/core/parser.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processApi = void 0;
+function isReferenceObject(obj) {
+    return obj && typeof obj.$ref === 'string';
+}
+function getSchemaName(ref) {
+    return ref.split('/').pop() || '';
+}
+function addSchemaWithDependencies(name, module, allSchemas) {
+    if (module.schemas[name]) {
+        return; // Already added
+    }
+    const schema = allSchemas[name];
+    if (!schema) {
+        return; // Schema not found
+    }
+    module.schemas[name] = schema;
+    // Recursively add dependencies
+    JSON.stringify(schema, (key, value) => {
+        if (key === '$ref' && typeof value === 'string') {
+            const depName = getSchemaName(value);
+            addSchemaWithDependencies(depName, module, allSchemas);
+        }
+        return value;
+    });
+}
+function getModuleName(path) {
+    const parts = path.split('/').filter(p => p && !p.startsWith('{'));
+    return parts[0] || 'default';
+}
+function extractJsdocParamsFromSchema(schema, allSchemas) {
+    var _a;
+    const params = [];
+    if (!schema)
+        return params;
+    let targetSchema;
+    if (isReferenceObject(schema)) {
+        const schemaName = getSchemaName(schema.$ref);
+        targetSchema = allSchemas[schemaName];
+    }
+    else {
+        targetSchema = schema;
+    }
+    if (targetSchema === null || targetSchema === void 0 ? void 0 : targetSchema.properties) {
+        for (const propName in targetSchema.properties) {
+            const prop = targetSchema.properties[propName];
+            // 调试: 打印出当前处理的属性
+            // console.log(`正在处理属性: ${propName}`, '值为:', prop);
+            params.push({
+                name: propName,
+                type: (prop === null || prop === void 0 ? void 0 : prop.type) || 'any',
+                description: (prop === null || prop === void 0 ? void 0 : prop.description) || '',
+                required: (_a = targetSchema.required) === null || _a === void 0 ? void 0 : _a.includes(propName)
+            });
+        }
+    }
+    return params;
+}
+function getModuleNameFromPackage(operation) {
+    const xPackage = operation['x-package'];
+    if (typeof xPackage === 'string' && xPackage.length > 0) {
+        const parts = xPackage.split('.');
+        const lastPart = parts[parts.length - 1];
+        // "Controller" is 10 characters
+        if (lastPart && lastPart.endsWith('Controller') && lastPart.length > 10) {
+            const rawName = lastPart.slice(0, -10);
+            return rawName.charAt(0).toLowerCase() + rawName.slice(1);
+        }
+    }
+    return null;
+}
+/**
+ * Processes the validated OpenAPI document into a structured format for code generation.
+ * @param api The bundled OpenAPI document.
+ * @returns A structured representation of modules and their endpoints.
+ */
+const processApi = (api, excludePaths = []) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const modules = {};
+    const allSchemas = ((_a = api.components) === null || _a === void 0 ? void 0 : _a.schemas) || api.definitions || {};
+    const moduleFunctionNames = {};
+    for (const path in api.paths) {
+        if (excludePaths.some(exclude => path.startsWith(exclude))) {
+            continue;
+        }
+        const pathItem = api.paths[path];
+        for (const method in pathItem) {
+            // Filter for actual HTTP methods
+            if (!['get', 'post', 'put', 'delete', 'patch', 'options', 'head'].includes(method)) {
+                continue;
+            }
+            const operation = pathItem[method];
+            if (!operation.tags)
+                continue;
+            const moduleNameFromPackage = getModuleNameFromPackage(operation);
+            const moduleName = moduleNameFromPackage || getModuleName(path);
+            if (!modules[moduleName]) {
+                modules[moduleName] = {
+                    name: moduleName,
+                    endpoints: [],
+                    schemas: {},
+                    description: (operation.tags && operation.tags.length > 0) ? operation.tags[0] : '',
+                };
+                moduleFunctionNames[moduleName] = new Set();
+            }
+            // Generate function name from method and path
+            const pathParts = path.split('/').filter(p => p && !p.startsWith('{'));
+            const capitalizedPathParts = pathParts.map(part => part.split(/[._-]/)
+                .map(subPart => subPart.charAt(0).toUpperCase() + subPart.slice(1))
+                .join(''));
+            const functionNameBase = `${method}${capitalizedPathParts.join('')}`;
+            let functionName = functionNameBase;
+            let counter = 1;
+            while (moduleFunctionNames[moduleName].has(functionName)) {
+                functionName = `${functionNameBase}_${counter}`;
+                counter++;
+            }
+            moduleFunctionNames[moduleName].add(functionName);
+            const referencedTypes = [];
+            let requestParamsTypeName = undefined;
+            let requestBodyTypeName = undefined;
+            let contentType = undefined;
+            const jsdocParams = [];
+            // --- FormData Detection ---
+            let isFormData = false;
+            // Method 1: Check requestBody
+            if (operation.requestBody && !isReferenceObject(operation.requestBody)) {
+                if ((_b = operation.requestBody.content) === null || _b === void 0 ? void 0 : _b['multipart/form-data']) {
+                    isFormData = true;
+                }
+            }
+            // Method 2: Check for binary formats in parameters (non-standard but common)
+            if (!isFormData && operation.parameters) {
+                if (operation.parameters.some(p => {
+                    var _a, _b;
+                    if (isReferenceObject(p))
+                        return false;
+                    // Treat as FormData if in: 'formData' is explicitly set
+                    if (p.in === 'formData')
+                        return true;
+                    const schema = p.schema;
+                    // Treat as FormData if format is binary/byte (single file)
+                    if ((schema === null || schema === void 0 ? void 0 : schema.format) === 'binary' || (schema === null || schema === void 0 ? void 0 : schema.format) === 'byte')
+                        return true;
+                    // Treat as FormData if it's an array of binary/byte (multiple files)
+                    if ((schema === null || schema === void 0 ? void 0 : schema.type) === 'array' && (((_a = schema.items) === null || _a === void 0 ? void 0 : _a.format) === 'binary' || ((_b = schema.items) === null || _b === void 0 ? void 0 : _b.format) === 'byte')) {
+                        return true;
+                    }
+                    return false;
+                })) {
+                    isFormData = true;
+                }
+            }
+            if (isFormData) {
+                contentType = 'multipart/form-data';
+            }
+            // --- End FormData Detection ---
+            // Handle All Parameters
+            if (operation.parameters) {
+                const paramsSchema = {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                };
+                // For FormData, we will build a schema for the body from query/formData parameters
+                const formDataSchema = {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                };
+                for (const param of operation.parameters) {
+                    if (!isReferenceObject(param)) {
+                        const paramToAdd = {
+                            name: param.name,
+                            description: param.description || '',
+                            required: param.required,
+                            type: ((_c = param.schema) === null || _c === void 0 ? void 0 : _c.type) || 'any'
+                        };
+                        // If the parameter's schema is a reference, expand its properties
+                        if (param.in === 'query' && param.schema && isReferenceObject(param.schema)) {
+                            const schemaName = getSchemaName(param.schema.$ref);
+                            const refSchema = allSchemas[schemaName];
+                            if (refSchema && refSchema.properties) {
+                                if (!paramsSchema.properties)
+                                    paramsSchema.properties = {};
+                                Object.assign(paramsSchema.properties, refSchema.properties);
+                                if (refSchema.required) {
+                                    if (!paramsSchema.required)
+                                        paramsSchema.required = [];
+                                    paramsSchema.required.push(...refSchema.required);
+                                }
+                            }
+                        }
+                        else if (isFormData && (param.in === 'query' || param.in === 'formData')) {
+                            // Collect params for the FormData body type
+                            if (!formDataSchema.properties)
+                                formDataSchema.properties = {};
+                            formDataSchema.properties[param.name] = param.schema;
+                            if (param.required) {
+                                if (!formDataSchema.required)
+                                    formDataSchema.required = [];
+                                formDataSchema.required.push(param.name);
+                            }
+                        }
+                        else if (param.in === 'path' || param.in === 'query') {
+                            // Always collect path params
+                            if (!paramsSchema.properties)
+                                paramsSchema.properties = {};
+                            paramsSchema.properties[param.name] = param.schema;
+                            if (param.required) {
+                                if (!paramsSchema.required)
+                                    paramsSchema.required = [];
+                                paramsSchema.required.push(param.name);
+                            }
+                        }
+                    }
+                }
+                if (isFormData && Object.keys(formDataSchema.properties || {}).length > 0) {
+                    const typeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Data`;
+                    requestBodyTypeName = typeName;
+                    modules[moduleName].schemas[typeName] = formDataSchema;
+                    referencedTypes.push(typeName);
+                    jsdocParams.push(...extractJsdocParamsFromSchema(formDataSchema, allSchemas));
+                }
+                if (Object.keys(paramsSchema.properties || {}).length > 0) {
+                    requestParamsTypeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Params`;
+                    modules[moduleName].schemas[requestParamsTypeName] = paramsSchema;
+                    referencedTypes.push(requestParamsTypeName);
+                    jsdocParams.push(...extractJsdocParamsFromSchema(paramsSchema, allSchemas));
+                }
+            }
+            // Handle standard Request Body
+            if (operation.requestBody && !isReferenceObject(operation.requestBody) && !isFormData) {
+                const requestBody = operation.requestBody;
+                const jsonContent = (_d = requestBody.content) === null || _d === void 0 ? void 0 : _d['application/json'];
+                if (jsonContent === null || jsonContent === void 0 ? void 0 : jsonContent.schema) {
+                    if (isReferenceObject(jsonContent.schema)) {
+                        const name = getSchemaName(jsonContent.schema.$ref);
+                        requestBodyTypeName = name;
+                        addSchemaWithDependencies(name, modules[moduleName], allSchemas);
+                        referencedTypes.push(name);
+                        jsdocParams.push(...extractJsdocParamsFromSchema(jsonContent.schema, allSchemas));
+                    }
+                    else {
+                        // Handle inline schema (including arrays)
+                        const schema = jsonContent.schema;
+                        if (schema.type === 'array' || schema.type === 'object') {
+                            const typeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Data`;
+                            requestBodyTypeName = typeName;
+                            modules[moduleName].schemas[typeName] = schema;
+                            referencedTypes.push(typeName);
+                            // For arrays, extract jsdoc params from array items
+                            if (schema.type === 'array' && schema.items) {
+                                if (isReferenceObject(schema.items)) {
+                                    const itemSchemaName = getSchemaName(schema.items.$ref);
+                                    addSchemaWithDependencies(itemSchemaName, modules[moduleName], allSchemas);
+                                }
+                                else {
+                                    jsdocParams.push(...extractJsdocParamsFromSchema(schema.items, allSchemas));
+                                }
+                            }
+                            else if (schema.type === 'object') {
+                                jsdocParams.push(...extractJsdocParamsFromSchema(schema, allSchemas));
+                            }
+                        }
+                    }
+                }
+            }
+            else if (isFormData && operation.requestBody && !isReferenceObject(operation.requestBody) && !requestBodyTypeName) {
+                // Handle cases where FormData is defined in requestBody but we haven't processed it yet
+                const formDataContent = (_e = operation.requestBody.content) === null || _e === void 0 ? void 0 : _e['multipart/form-data'];
+                if (formDataContent === null || formDataContent === void 0 ? void 0 : formDataContent.schema) {
+                    const typeName = `${functionName.charAt(0).toUpperCase() + functionName.slice(1)}Data`;
+                    requestBodyTypeName = typeName;
+                    modules[moduleName].schemas[typeName] = formDataContent.schema;
+                    referencedTypes.push(typeName);
+                    jsdocParams.push(...extractJsdocParamsFromSchema(formDataContent.schema, allSchemas));
+                }
+            }
+            // Handle Response Body
+            let responseTypeName = 'void';
+            const successResponse = operation.responses['200'];
+            if (successResponse) {
+                const mediaType = ((_f = successResponse.content) === null || _f === void 0 ? void 0 : _f['*/*']) || ((_g = successResponse.content) === null || _g === void 0 ? void 0 : _g['application/json']);
+                const schema = mediaType === null || mediaType === void 0 ? void 0 : mediaType.schema;
+                if (schema && isReferenceObject(schema)) {
+                    const name = getSchemaName(schema.$ref);
+                    responseTypeName = name;
+                    addSchemaWithDependencies(name, modules[moduleName], allSchemas);
+                    referencedTypes.push(name);
+                }
+            }
+            // Convert path to template literal string for path parameters
+            const urlTemplate = path.replace(/\{(\w+)\}/g, '${params.$1}');
+            const endpoint = {
+                functionName,
+                description: operation.summary || operation.description || '',
+                method,
+                path: urlTemplate,
+                requestParamsTypeName,
+                requestBodyTypeName,
+                responseTypeName,
+                referencedTypes: [...new Set(referencedTypes)],
+                hasParams: !!requestParamsTypeName,
+                hasData: !!requestBodyTypeName,
+                contentType,
+                jsdocParams,
+            };
+            modules[moduleName].endpoints.push(endpoint);
+        }
+    }
+    return modules;
+};
+exports.processApi = processApi;

package/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * @description:
+ * @Author: czh
+ * @Date: 2025-07-02 10:39:34
+ * @LastEditors: Czh
+ * @LastEditTime: 2025-07-02 10:39:34
+ */
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const build_1 = require("./commands/build");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const program = new commander_1.Command();
+// Read package.json to get the version
+const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '../package.json'), 'utf-8'));
+program
+    .name('czh-api')
+    .description('A CLI tool to generate API code from Swagger/OpenAPI documents.')
+    .version(packageJson.version, '-v, --version', 'output the current version');
+program
+    .command('init')
+    .description('Initialize czh-api and create a config file and templates.')
+    .action(init_1.handleInit);
+program
+    .command('build')
+    .description('Generate API code based on the configuration file.')
+    .action(build_1.handleBuild);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}