swagger2api-v3 1.0.0

package/dist/core/generator.js

@@ -0,0 +1,412 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerator = void 0;
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+/**
+ * 代码生成器
+ */
+class CodeGenerator {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * 生成所有文件
+     * @param apis API接口数组
+     * @param types 类型定义数组
+     * @param groupedApis 按标签分组的API
+     */
+    async generateAll(apis, types, groupedApis) {
+        // 根据overwrite配置决定是否清空目录
+        if (this.config.overwrite !== false) {
+            // 默认为true，清空输出目录
+            (0, utils_1.removeDirectory)(this.config.output);
+        }
+        // 确保输出目录存在
+        (0, utils_1.ensureDirectoryExists)(this.config.output);
+        // 生成类型文件
+        if (this.config.options?.generateModels !== false) {
+            await this.generateTypesFile(types);
+        }
+        // 生成API文件
+        if (this.config.options?.generateApis !== false) {
+            if (this.config.groupByTags) {
+                await this.generateApiFilesByTags(groupedApis, types);
+            }
+            else {
+                await this.generateSingleApiFile(apis, types);
+            }
+        }
+        // 生成入口文件
+        if (this.config.options?.generateIndex !== false) {
+            await this.generateIndexFile(groupedApis);
+        }
+        // 在所有文件生成完成后执行lint
+        if (this.config.lint) {
+            await this.runLintOnAllFiles();
+        }
+    }
+    /**
+     * 生成类型定义文件
+     * @param types 类型定义数组
+     */
+    async generateTypesFile(types) {
+        const content = this.generateTypesContent(types);
+        const filePath = path.join(this.config.output, 'types.ts');
+        (0, utils_1.writeFile)(filePath, content);
+    }
+    /**
+     * 生成类型文件内容
+     * @param types 类型定义数组
+     * @returns 类型文件内容
+     */
+    generateTypesContent(types) {
+        const header = [
+            '/**',
+            ' * API 类型定义',
+            ' * 此文件由 swagger2api 自动生成，请勿手动修改',
+            ' */',
+            ''
+        ].join('\n');
+        const typeDefinitions = types
+            .map(type => {
+            const comment = type.description
+                ? `/**\n * ${type.description}\n */\n`
+                : '';
+            return `${comment}${type.definition}`;
+        })
+            .join('\n\n');
+        return `${header}${typeDefinitions}\n`;
+    }
+    /**
+     * 按标签生成API文件
+     * @param groupedApis 按标签分组的API
+     * @param types 类型定义数组
+     */
+    async generateApiFilesByTags(groupedApis, types) {
+        for (const [tag, apis] of groupedApis) {
+            const folderName = this.getTagFileName(tag);
+            const tagFolderPath = path.join(this.config.output, folderName);
+            // 确保tag文件夹存在
+            (0, utils_1.ensureDirectoryExists)(tagFolderPath);
+            const filePath = path.join(tagFolderPath, 'index.ts');
+            const content = this.generateApiFileContent(apis, types, tag);
+            (0, utils_1.writeFile)(filePath, content);
+        }
+    }
+    /**
+     * 生成单个API文件
+     * @param apis API接口数组
+     * @param types 类型定义数组
+     */
+    async generateSingleApiFile(apis, types) {
+        const filePath = path.join(this.config.output, 'api.ts');
+        const content = this.generateApiFileContent(apis, types);
+        (0, utils_1.writeFile)(filePath, content);
+    }
+    /**
+     * 生成API文件内容
+     * @param apis API接口数组
+     * @param types 类型定义数组
+     * @param tag 标签名称（可选）
+     * @returns API文件内容
+     */
+    generateApiFileContent(apis, types, tag) {
+        const importTemplate = this.config.importTemplate || "import { request } from '@/utils'";
+        const header = [
+            '/**',
+            ` * ${tag ? `${tag} ` : ''}API 接口`,
+            ' * 此文件由 swagger2api 自动生成，请勿手动修改',
+            ' */',
+            '',
+            importTemplate + ';'
+        ];
+        // 收集当前文件实际使用的类型
+        const usedTypes = this.collectUsedTypes(apis);
+        // 添加类型导入
+        if (usedTypes.length > 0) {
+            const typeNames = usedTypes.join(', ');
+            const typesPath = tag ? '../types' : './types';
+            header.push(`import type { ${typeNames} } from '${typesPath}';`);
+        }
+        header.push('');
+        const apiImplementations = apis.map(api => this.generateApiFunction(api)).join('\n\n');
+        return `${header.join('\n')}${apiImplementations}\n`;
+    }
+    /**
+     * 生成单个API函数
+     * @param api API接口信息
+     * @returns API函数代码
+     */
+    generateApiFunction(api) {
+        const parts = [];
+        // 生成注释
+        if (this.config.options?.addComments !== false) {
+            const swaggerParams = api.parameters.map(p => ({
+                name: p.name,
+                in: p.in,
+                required: p.required,
+                type: p.type,
+                description: p.description
+            }));
+            const comment = (0, utils_1.generateApiComment)({ summary: api.description, deprecated: false }, swaggerParams);
+            parts.push(comment);
+        }
+        // 生成函数签名
+        const swaggerParameters = api.parameters.map(p => ({
+            name: p.name,
+            in: p.in,
+            required: p.required,
+            type: p.type,
+            schema: p.schema || { type: p.type }
+        }));
+        // 生成直接参数形式
+        const functionParams = this.generateDirectParameters(swaggerParameters);
+        const responseType = api.responseType || 'any';
+        const functionName = (0, utils_1.toCamelCase)(api.name);
+        parts.push(`export const ${functionName} = (${functionParams}) => {`);
+        // 生成请求配置
+        const requestConfig = this.generateRequestConfig(api);
+        parts.push(`  return request.${api.method.toLowerCase()}<${responseType}>(${requestConfig});`);
+        parts.push('}');
+        return parts.join('\n');
+    }
+    /**
+     * 生成直接参数形式
+     * @param parameters Swagger参数数组
+     * @returns 函数参数字符串
+     */
+    generateDirectParameters(parameters) {
+        const params = [];
+        const queryParams = parameters.filter(p => p.in === 'query');
+        const pathParams = parameters.filter(p => p.in === 'path');
+        const bodyParams = parameters.filter(p => p.in === 'body');
+        const formParams = parameters.filter(p => p.in === 'formData');
+        // 合并路径参数和查询参数为一个params对象
+        const allParams = [...pathParams, ...queryParams];
+        if (allParams.length > 0) {
+            const paramType = allParams
+                .map(p => {
+                const optional = p.required ? '' : '?';
+                return `${p.name}${optional}: ${p.type}`;
+            })
+                .join(', ');
+            // 检查是否所有参数都是可选的
+            const allOptional = allParams.every(p => !p.required);
+            const optionalModifier = allOptional ? '?' : '';
+            params.push(`params${optionalModifier}: { ${paramType} }`);
+        }
+        // 请求体参数
+        if (bodyParams.length > 0) {
+            const bodyParam = bodyParams[0];
+            const bodyType = bodyParam.schema ? this.getTypeFromSchema(bodyParam.schema) : bodyParam.type;
+            params.push(`data: ${bodyType}`);
+        }
+        // 表单参数
+        if (formParams.length > 0) {
+            const formType = formParams
+                .map(p => {
+                const optional = p.required ? '' : '?';
+                return `${p.name}${optional}: ${p.type}`;
+            })
+                .join(', ');
+            params.push(`data: { ${formType} }`);
+        }
+        // 添加可选的config参数
+        params.push('config?: any');
+        return params.join(', ');
+    }
+    /**
+     * 从schema获取类型
+     * @param schema Swagger schema
+     * @returns 类型字符串
+     */
+    getTypeFromSchema(schema) {
+        if (schema.$ref) {
+            return schema.$ref.split('/').pop() || 'any';
+        }
+        return (0, utils_1.swaggerTypeToTsType)(schema);
+    }
+    /**
+     * 收集API数组中实际使用的类型
+     * @param apis API接口数组
+     * @returns 使用的类型名称数组
+     */
+    collectUsedTypes(apis) {
+        const usedTypes = new Set();
+        apis.forEach(api => {
+            // 收集响应类型
+            if (api.responseType && api.responseType !== 'any') {
+                usedTypes.add(api.responseType);
+            }
+            // 收集参数类型
+            api.parameters.forEach(param => {
+                if (param.schema) {
+                    const type = this.getTypeFromSchema(param.schema);
+                    if (type && type !== 'any' && !this.isPrimitiveType(type)) {
+                        usedTypes.add(type);
+                    }
+                }
+                else if (param.type && !this.isPrimitiveType(param.type)) {
+                    usedTypes.add(param.type);
+                }
+            });
+        });
+        return Array.from(usedTypes).sort();
+    }
+    /**
+     * 判断是否为基础类型
+     * @param type 类型名称
+     * @returns 是否为基础类型
+     */
+    isPrimitiveType(type) {
+        const primitiveTypes = ['string', 'number', 'boolean', 'object', 'array', 'any', 'void', 'null', 'undefined'];
+        return primitiveTypes.includes(type.toLowerCase());
+    }
+    /**
+     * 生成请求配置
+     * @param api API接口信息
+     * @returns 请求配置代码
+     */
+    generateRequestConfig(api) {
+        const config = [];
+        // URL处理
+        let url = api.path;
+        // 添加prefix前缀
+        if (this.config.prefix) {
+            url = this.config.prefix + url;
+        }
+        const pathParams = api.parameters.filter(p => p.in === 'path');
+        const queryParams = api.parameters.filter(p => p.in === 'query');
+        if (pathParams.length > 0) {
+            // 替换路径参数，从params对象中获取
+            pathParams.forEach(param => {
+                url = url.replace(`{${param.name}}`, `\${params.${param.name}}`);
+            });
+            config.push(`url: \`${url}\``);
+        }
+        else {
+            config.push(`url: '${url}'`);
+        }
+        // 查询参数和路径参数都从params对象中获取
+        if (queryParams.length > 0) {
+            // 直接传递params对象，让axios自动过滤undefined值
+            config.push('params');
+        }
+        // 请求体数据
+        const bodyParams = api.parameters.filter(p => p.in === 'body');
+        const formParams = api.parameters.filter(p => p.in === 'formData');
+        if (bodyParams.length > 0) {
+            config.push('data');
+        }
+        else if (formParams.length > 0) {
+            config.push('data');
+        }
+        // 添加config参数合并
+        config.push('...config');
+        return `{\n    ${config.join(',\n    ')}\n  }`;
+    }
+    /**
+     * 生成入口文件
+     * @param groupedApis 按标签分组的API
+     */
+    async generateIndexFile(groupedApis) {
+        const exports = [];
+        // 导出类型
+        exports.push("export * from './types';");
+        if (this.config.groupByTags) {
+            // 按标签导出
+            for (const tag of groupedApis.keys()) {
+                const folderName = this.getTagFileName(tag);
+                exports.push(`export * from './${folderName}';`);
+            }
+        }
+        else {
+            // 导出单个API文件
+            exports.push("export * from './api';");
+        }
+        const content = [
+            '/**',
+            ' * API 入口文件',
+            ' * 此文件由 swagger2api 自动生成，请勿手动修改',
+            ' */',
+            '',
+            ...exports,
+            ''
+        ].join('\n');
+        const filePath = path.join(this.config.output, 'index.ts');
+        (0, utils_1.writeFile)(filePath, content);
+    }
+    /**
+     * 获取标签对应的文件名
+     * @param tag 标签名
+     * @returns 文件名
+     */
+    getTagFileName(tag) {
+        const cleanTag = (0, utils_1.sanitizeFilename)(tag);
+        switch (this.config.tagGrouping?.fileNaming) {
+            case 'camelCase':
+                return (0, utils_1.toCamelCase)(cleanTag);
+            case 'kebab-case':
+                return (0, utils_1.toKebabCase)(cleanTag);
+            case 'tag':
+            default:
+                return cleanTag.toLowerCase();
+        }
+    }
+    /**
+     * 在所有文件生成完成后运行lint命令
+     */
+    async runLintOnAllFiles() {
+        if (!this.config.lint)
+            return;
+        try {
+            const { exec } = require('child_process');
+            const util = require('util');
+            const execPromise = util.promisify(exec);
+            console.log(`🎨 Running lint command: ${this.config.lint} ${this.config.output}`);
+            const result = await execPromise(`${this.config.lint} ${this.config.output}`);
+            if (result.stdout) {
+                console.log(result.stdout);
+            }
+            console.log('✅ Lint completed successfully');
+        }
+        catch (error) {
+            console.warn(`⚠️  Failed to run lint command:`, error.message);
+        }
+    }
+}
+exports.CodeGenerator = CodeGenerator;

package/dist/core/parser.d.ts

@@ -0,0 +1,61 @@
+import { SwaggerDocument, ApiInfo, TypeInfo, SwaggerConfig } from '../types';
+/**
+ * Swagger文档解析器
+ */
+export declare class SwaggerParser {
+    private document;
+    private config;
+    constructor(document: SwaggerDocument, config: SwaggerConfig);
+    /**
+     * 解析所有API接口
+     * @returns API接口信息数组
+     */
+    parseApis(): ApiInfo[];
+    /**
+     * 解析单个操作
+     * @param method HTTP方法
+     * @param path 路径
+     * @param operation 操作对象
+     * @param globalParameters 全局参数
+     * @returns API接口信息
+     */
+    private parseOperation;
+    /**
+     * 解析所有类型定义
+     * @returns 类型信息数组
+     */
+    parseTypes(): TypeInfo[];
+    /**
+     * 解析单个类型定义
+     * @param name 类型名称
+     * @param schema 模式对象
+     * @returns 类型信息
+     */
+    private parseTypeDefinition;
+    /**
+     * 按标签分组API
+     * @param apis API接口数组
+     * @returns 按标签分组的API映射
+     */
+    groupApisByTags(apis: ApiInfo[]): Map<string, ApiInfo[]>;
+    /**
+     * 获取所有标签
+     * @returns 标签数组
+     */
+    getTags(): string[];
+    /**
+     * 获取基础URL
+     * @returns 基础URL字符串
+     */
+    getBaseUrl(): string;
+    /**
+     * 获取API文档信息
+     * @returns API文档基本信息
+     */
+    getApiInfo(): {
+        title: string;
+        description: string | undefined;
+        version: string;
+        baseUrl: string;
+    };
+}

package/dist/core/parser.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerParser = void 0;
+const utils_1 = require("../utils");
+/**
+ * Swagger文档解析器
+ */
+class SwaggerParser {
+    constructor(document, config) {
+        this.document = document;
+        this.config = config;
+    }
+    /**
+     * 解析所有API接口
+     * @returns API接口信息数组
+     */
+    parseApis() {
+        const apis = [];
+        const paths = this.document.paths;
+        for (const [path, pathItem] of Object.entries(paths)) {
+            const methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+            for (const method of methods) {
+                const operation = pathItem[method];
+                if (!operation)
+                    continue;
+                const apiInfo = this.parseOperation(method, path, operation, pathItem.parameters);
+                apis.push(apiInfo);
+            }
+        }
+        return apis;
+    }
+    /**
+     * 解析单个操作
+     * @param method HTTP方法
+     * @param path 路径
+     * @param operation 操作对象
+     * @param globalParameters 全局参数
+     * @returns API接口信息
+     */
+    parseOperation(method, path, operation, globalParameters) {
+        // 合并全局参数和操作参数
+        const allParameters = [
+            ...(globalParameters || []),
+            ...(operation.parameters || [])
+        ];
+        // 处理 OpenAPI 3.0 requestBody
+        if (operation.requestBody) {
+            const requestBody = operation.requestBody;
+            if (requestBody.content && requestBody.content['application/json']) {
+                const schema = requestBody.content['application/json'].schema;
+                if (schema) {
+                    const bodyParam = {
+                        name: 'body',
+                        in: 'body',
+                        required: requestBody.required || false,
+                        schema: schema,
+                        type: 'object'
+                    };
+                    allParameters.push(bodyParam);
+                }
+            }
+        }
+        // 生成函数名
+        const functionName = operation.operationId || (0, utils_1.pathToFunctionName)(method, path);
+        // 获取响应类型
+        const responseType = (0, utils_1.getResponseType)(operation.responses);
+        // 获取请求体类型
+        const bodyParam = allParameters.find(p => p.in === 'body');
+        const requestBodyType = bodyParam ? (0, utils_1.swaggerTypeToTsType)(bodyParam.schema) : undefined;
+        // 解析参数信息
+        const parameters = allParameters.map(param => {
+            const type = param.schema ? (0, utils_1.swaggerTypeToTsType)(param.schema) : (0, utils_1.swaggerTypeToTsType)({ type: param.type || 'string' });
+            return {
+                name: param.name,
+                type,
+                in: param.in,
+                required: param.required || false,
+                description: param.description,
+                schema: param.schema
+            };
+        });
+        return {
+            name: functionName,
+            method: method.toUpperCase(),
+            path,
+            description: operation.summary || operation.description,
+            tags: operation.tags || [],
+            parameters,
+            responseType,
+            requestBodyType
+        };
+    }
+    /**
+     * 解析所有类型定义
+     * @returns 类型信息数组
+     */
+    parseTypes() {
+        const types = [];
+        // 解析 Swagger 2.0 definitions
+        if (this.document.definitions) {
+            for (const [name, schema] of Object.entries(this.document.definitions)) {
+                const typeInfo = this.parseTypeDefinition(name, schema);
+                types.push(typeInfo);
+            }
+        }
+        // 解析 OpenAPI 3.0 components.schemas
+        if (this.document.components?.schemas) {
+            for (const [name, schema] of Object.entries(this.document.components.schemas)) {
+                const typeInfo = this.parseTypeDefinition(name, schema);
+                types.push(typeInfo);
+            }
+        }
+        return types;
+    }
+    /**
+     * 解析单个类型定义
+     * @param name 类型名称
+     * @param schema 模式对象
+     * @returns 类型信息
+     */
+    parseTypeDefinition(name, schema) {
+        const typeName = (0, utils_1.toPascalCase)(name);
+        let definition;
+        if (schema.type === 'object' && schema.properties) {
+            // 对象类型
+            const properties = Object.entries(schema.properties)
+                .map(([key, value]) => {
+                const optional = schema.required?.includes(key) ? '' : '?';
+                const type = (0, utils_1.swaggerTypeToTsType)(value);
+                const comment = value.description ? ` /** ${value.description} */` : '';
+                return `${comment}\n  ${key}${optional}: ${type};`;
+            })
+                .join('\n');
+            definition = `export interface ${typeName} {\n${properties}\n}`;
+        }
+        else if (schema.type === 'array') {
+            // 数组类型
+            const itemType = (0, utils_1.swaggerTypeToTsType)(schema.items);
+            definition = `export type ${typeName} = ${itemType}[];`;
+        }
+        else if (schema.enum) {
+            // 枚举类型
+            const enumValues = schema.enum
+                .map((value) => `  ${JSON.stringify(value)}`)
+                .join(' |\n');
+            definition = `export type ${typeName} =\n${enumValues};`;
+        }
+        else {
+            // 其他类型
+            const type = (0, utils_1.swaggerTypeToTsType)(schema);
+            definition = `export type ${typeName} = ${type};`;
+        }
+        return {
+            name: typeName,
+            definition,
+            description: schema.description
+        };
+    }
+    /**
+     * 按标签分组API
+     * @param apis API接口数组
+     * @returns 按标签分组的API映射
+     */
+    groupApisByTags(apis) {
+        const groupedApis = new Map();
+        for (const api of apis) {
+            const tags = api.tags.length > 0 ? api.tags : ['default'];
+            for (const tag of tags) {
+                if (!groupedApis.has(tag)) {
+                    groupedApis.set(tag, []);
+                }
+                groupedApis.get(tag).push(api);
+            }
+        }
+        return groupedApis;
+    }
+    /**
+     * 获取所有标签
+     * @returns 标签数组
+     */
+    getTags() {
+        const tags = new Set();
+        // 从文档标签中获取
+        if (this.document.tags) {
+            this.document.tags.forEach(tag => tags.add(tag.name));
+        }
+        // 从路径操作中获取
+        for (const pathItem of Object.values(this.document.paths)) {
+            const methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+            for (const method of methods) {
+                const operation = pathItem[method];
+                if (operation?.tags) {
+                    operation.tags.forEach(tag => tags.add(tag));
+                }
+            }
+        }
+        return Array.from(tags);
+    }
+    /**
+     * 获取基础URL
+     * @returns 基础URL字符串
+     */
+    getBaseUrl() {
+        if (this.document.host) {
+            const scheme = this.document.schemes?.[0] || 'https';
+            const basePath = this.document.basePath || '';
+            return `${scheme}://${this.document.host}${basePath}`;
+        }
+        return '';
+    }
+    /**
+     * 获取API文档信息
+     * @returns API文档基本信息
+     */
+    getApiInfo() {
+        return {
+            title: this.document.info.title,
+            description: this.document.info.description,
+            version: this.document.info.version,
+            baseUrl: this.getBaseUrl()
+        };
+    }
+}
+exports.SwaggerParser = SwaggerParser;