swagger2api-v3 1.0.6 → 1.0.7

package/README.md

@@ -128,18 +128,20 @@ export interface UserInfo {
 ### 生成的 API 接口
 
 ```typescript
-// auth/index.ts
+// authController/index.ts
 import { request } from '@/utils/request';
-import type { LoginDto, UserInfo } from '../types';
+import type { LoginDto, LoginRespDto } from '../types';
 
 /**
- * 用户登录
+ * 登录
  * @param data 登录参数
+ * @param config 可选的请求配置
  */
-export const login = (data: LoginDto) => {
-  return request.post<UserInfo>({
-    url: '/auth/login',
-    data
+export const authControllerLoginPost = (data: LoginDto, config?: any) => {
+  return request.post<LoginRespDto>({
+    url: '/admin/auth/login',
+    data,
+    ...config
   });
 };
 ```

package/dist/core/generator.d.ts

@@ -67,12 +67,25 @@ export declare class CodeGenerator {
      * @returns 使用的类型名称数组
      */
     private collectUsedTypes;
+    /**
+     * 从类型字符串中提取所有类型名称（包括泛型参数）
+     * @param typeStr 类型字符串，如 "ResOp<UserListRespDto>"
+     * @returns 类型名称数组，如 ["ResOp", "UserListRespDto"]
+     */
+    private extractTypeNames;
     /**
      * 判断是否为基础类型
      * @param type 类型名称
      * @returns 是否为基础类型
      */
     private isPrimitiveType;
+    /**
+     * 检测是否为通用响应容器类型
+     * @param type 类型信息
+     * @param definition 类型定义
+     * @returns 是否为通用响应容器类型
+     */
+    private isGenericResponseContainer;
     /**
      * 生成请求配置
      * @param api API接口信息

package/dist/core/generator.js

@@ -102,11 +102,19 @@ class CodeGenerator {
             ''
         ].join('\n');
         const typeDefinitions = types
-            .map(type => {
+            .map((type) => {
             const comment = type.description
                 ? `/**\n * ${type.description}\n */\n`
                 : '';
-            return `${comment}${type.definition}`;
+            // 通用处理：检测通用响应容器类型并转换为泛型接口
+            let definition = type.definition;
+            if (this.isGenericResponseContainer(type, definition)) {
+                const typeName = type.name;
+                definition = definition
+                    .replace(`export interface ${typeName} {`, `export interface ${typeName}<T = Record<string, any>> {`)
+                    .replace('data: Record<string, any>;', 'data: T;');
+            }
+            return `${comment}${definition}`;
         })
             .join('\n\n');
         return `${header}${typeDefinitions}\n`;
@@ -163,7 +171,9 @@ class CodeGenerator {
             header.push(`import type { ${typeNames} } from '${typesPath}';`);
         }
         header.push('');
-        const apiImplementations = apis.map(api => this.generateApiFunction(api)).join('\n\n');
+        const apiImplementations = apis
+            .map((api) => this.generateApiFunction(api))
+            .join('\n\n');
         return `${header.join('\n')}${apiImplementations}\n`;
     }
     /**
@@ -175,7 +185,7 @@ class CodeGenerator {
         const parts = [];
         // 生成注释
         if (this.config.options?.addComments !== false) {
-            const swaggerParams = api.parameters.map(p => ({
+            const swaggerParams = api.parameters.map((p) => ({
                 name: p.name,
                 in: p.in,
                 required: p.required,
@@ -186,7 +196,7 @@ class CodeGenerator {
             parts.push(comment);
         }
         // 生成函数签名
-        const swaggerParameters = api.parameters.map(p => ({
+        const swaggerParameters = api.parameters.map((p) => ({
             name: p.name,
             in: p.in,
             required: p.required,
@@ -211,34 +221,36 @@ class CodeGenerator {
      */
     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');
+        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 => {
+                .map((p) => {
                 const optional = p.required ? '' : '?';
                 return `${p.name}${optional}: ${p.type}`;
             })
                 .join(', ');
             // 检查是否所有参数都是可选的
-            const allOptional = allParams.every(p => !p.required);
+            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;
+            const bodyType = bodyParam.schema
+                ? this.getTypeFromSchema(bodyParam.schema)
+                : bodyParam.type;
             params.push(`data: ${bodyType}`);
         }
         // 表单参数
         if (formParams.length > 0) {
             const formType = formParams
-                .map(p => {
+                .map((p) => {
                 const optional = p.required ? '' : '?';
                 return `${p.name}${optional}: ${p.type}`;
             })
@@ -267,17 +279,22 @@ class CodeGenerator {
      */
     collectUsedTypes(apis) {
         const usedTypes = new Set();
-        apis.forEach(api => {
+        apis.forEach((api) => {
             // 收集响应类型
             if (api.responseType && api.responseType !== 'any') {
-                usedTypes.add(api.responseType);
+                // 提取泛型类型中的所有类型名称
+                this.extractTypeNames(api.responseType).forEach((typeName) => {
+                    usedTypes.add(typeName);
+                });
             }
             // 收集参数类型
-            api.parameters.forEach(param => {
+            api.parameters.forEach((param) => {
                 if (param.schema) {
                     const type = this.getTypeFromSchema(param.schema);
                     if (type && type !== 'any' && !this.isPrimitiveType(type)) {
-                        usedTypes.add(type);
+                        this.extractTypeNames(type).forEach((typeName) => {
+                            usedTypes.add(typeName);
+                        });
                     }
                 }
                 else if (param.type && !this.isPrimitiveType(param.type)) {
@@ -287,15 +304,60 @@ class CodeGenerator {
         });
         return Array.from(usedTypes).sort();
     }
+    /**
+     * 从类型字符串中提取所有类型名称（包括泛型参数）
+     * @param typeStr 类型字符串，如 "ResOp<UserListRespDto>"
+     * @returns 类型名称数组，如 ["ResOp", "UserListRespDto"]
+     */
+    extractTypeNames(typeStr) {
+        const typeNames = new Set();
+        // 匹配所有标识符（类型名称）
+        const matches = typeStr.match(/[A-Za-z_][A-Za-z0-9_]*/g);
+        if (matches) {
+            matches.forEach((match) => {
+                if (!this.isPrimitiveType(match)) {
+                    typeNames.add(match);
+                }
+            });
+        }
+        return Array.from(typeNames);
+    }
     /**
      * 判断是否为基础类型
      * @param type 类型名称
      * @returns 是否为基础类型
      */
     isPrimitiveType(type) {
-        const primitiveTypes = ['string', 'number', 'boolean', 'object', 'array', 'any', 'void', 'null', 'undefined'];
+        const primitiveTypes = [
+            'string',
+            'number',
+            'boolean',
+            'object',
+            'array',
+            'any',
+            'void',
+            'null',
+            'undefined'
+        ];
         return primitiveTypes.includes(type.toLowerCase());
     }
+    /**
+     * 检测是否为通用响应容器类型
+     * @param type 类型信息
+     * @param definition 类型定义
+     * @returns 是否为通用响应容器类型
+     */
+    isGenericResponseContainer(type, definition) {
+        // 检查是否为接口定义
+        if (!definition.includes(`export interface ${type.name} {`)) {
+            return false;
+        }
+        // 检查是否包含 data 字段且类型为 Record<string, any>
+        const hasDataField = definition.includes('data: Record<string, any>;');
+        // 检查是否包含其他常见的响应容器字段
+        const hasCommonFields = ['code', 'message', 'success', 'status'].some((field) => definition.includes(`${field}:`));
+        return hasDataField && hasCommonFields;
+    }
     /**
      * 生成请求配置
      * @param api API接口信息
@@ -309,11 +371,11 @@ class CodeGenerator {
         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');
+        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 => {
+            pathParams.forEach((param) => {
                 url = url.replace(`{${param.name}}`, `\${params.${param.name}}`);
             });
             config.push(`url: \`${url}\``);
@@ -327,8 +389,8 @@ class CodeGenerator {
             config.push('params');
         }
         // 请求体数据
-        const bodyParams = api.parameters.filter(p => p.in === 'body');
-        const formParams = api.parameters.filter(p => p.in === 'formData');
+        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');
         }

package/dist/core/parser.js

@@ -161,7 +161,22 @@ class SwaggerParser {
         else if (schema.enum) {
             // 枚举类型
             const enumValues = schema.enum
-                .map((value) => `  ${value.toUpperCase()} = '${value}'`)
+                .map((value, index) => {
+                let key = value;
+                // 优先使用 x-enum-varnames 或 x-enumNames 扩展字段
+                if ((schema['x-enum-varnames'] && schema['x-enum-varnames'][index]) ||
+                    (schema['x-enumNames'] && schema['x-enumNames'][index])) {
+                    key = schema['x-enum-varnames']?.[index] || schema['x-enumNames']?.[index];
+                }
+                else if (/^\d+$/.test(value)) {
+                    // 对于数字枚举，使用 VALUE_ 前缀
+                    key = `VALUE_${value}`;
+                }
+                else {
+                    key = value.toUpperCase();
+                }
+                return `  ${key} = '${value}'`;
+            })
                 .join(',\n');
             definition = `export enum ${typeName} {\n${enumValues}\n}`;
         }

package/dist/utils/index.js

@@ -122,10 +122,35 @@ function swaggerTypeToTsType(schema) {
     }
     // 处理 allOf 类型组合
     if (schema.allOf && schema.allOf.length > 0) {
-        // 对于 allOf，通常第一个元素是引用类型
+        // 检查是否为泛型模式：第一个是引用类型，第二个定义了扩展属性
         const firstSchema = schema.allOf[0];
-        if (firstSchema.$ref) {
+        if (firstSchema.$ref && schema.allOf.length > 1) {
             const refName = firstSchema.$ref.split('/').pop();
+            const secondSchema = schema.allOf[1];
+            // 检查第二个 schema 是否定义了对象属性（可能没有 type 字段）
+            if (secondSchema.properties) {
+                // 获取所有扩展属性的类型
+                const propertyTypes = [];
+                for (const [propName, propSchema] of Object.entries(secondSchema.properties)) {
+                    const propType = swaggerTypeToTsType(propSchema);
+                    propertyTypes.push(propType);
+                }
+                // 如果只有一个属性，直接作为泛型参数
+                if (propertyTypes.length === 1) {
+                    return `${refName}<${propertyTypes[0]}>`;
+                }
+                // 如果有多个属性，组合成联合类型或对象类型
+                else if (propertyTypes.length > 1) {
+                    const combinedType = `{ ${Object.entries(secondSchema.properties)
+                        .map(([key, value]) => {
+                        const optional = secondSchema.required?.includes(key) ? '' : '?';
+                        const type = swaggerTypeToTsType(value);
+                        return `${key}${optional}: ${type}`;
+                    })
+                        .join('; ')} }`;
+                    return `${refName}<${combinedType}>`;
+                }
+            }
             return refName || 'any';
         }
         // 如果不是引用，尝试合并所有类型

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger2api-v3",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "从 Swagger/OpenAPI 文档生成 TypeScript API 接口的命令行工具",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",