swagger2api-v3 1.0.0

package/dist/utils/index.js

@@ -0,0 +1,318 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToFunctionName = pathToFunctionName;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.toCamelCase = toCamelCase;
+exports.swaggerTypeToTsType = swaggerTypeToTsType;
+exports.generateParameterTypes = generateParameterTypes;
+exports.ensureDirectoryExists = ensureDirectoryExists;
+exports.removeDirectory = removeDirectory;
+exports.loadSwaggerDocument = loadSwaggerDocument;
+exports.writeFile = writeFile;
+exports.generateApiComment = generateApiComment;
+exports.sanitizeFilename = sanitizeFilename;
+exports.getResponseType = getResponseType;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const axios_1 = __importDefault(require("axios"));
+/**
+ * 工具函数集合
+ */
+/**
+ * 将路径转换为小驼峰命名的函数名
+ * @param method HTTP方法
+ * @param path 接口路径
+ * @returns 小驼峰命名的函数名
+ */
+function pathToFunctionName(method, path) {
+    // 移除路径参数的大括号
+    const cleanPath = path.replace(/\{([^}]+)\}/g, '$1');
+    // 分割路径并过滤空字符串
+    const segments = cleanPath.split('/').filter(segment => segment.length > 0);
+    // 将方法名添加到开头
+    const parts = [method.toLowerCase(), ...segments];
+    // 转换为小驼峰命名
+    return parts
+        .map((part, index) => {
+        // 移除特殊字符并转换为小驼峰
+        const cleanPart = part.replace(/[^a-zA-Z0-9]/g, '');
+        if (index === 0) {
+            return cleanPart.toLowerCase();
+        }
+        return cleanPart.charAt(0).toUpperCase() + cleanPart.slice(1).toLowerCase();
+    })
+        .join('');
+}
+/**
+ * 将字符串转换为kebab-case
+ * @param str 输入字符串
+ * @returns kebab-case字符串
+ */
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+/**
+ * 将字符串转换为PascalCase
+ * @param str 输入字符串
+ * @returns PascalCase字符串
+ */
+function toPascalCase(str) {
+    return str
+        .replace(/[\s-_]+(.)?/g, (_, char) => char ? char.toUpperCase() : '')
+        .replace(/^(.)/, char => char.toUpperCase());
+}
+/**
+ * 将字符串转换为camelCase
+ * @param str 输入字符串
+ * @returns camelCase字符串
+ */
+function toCamelCase(str) {
+    const pascalCase = toPascalCase(str);
+    return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+}
+/**
+ * 将Swagger类型转换为TypeScript类型
+ * @param schema Swagger模式
+ * @returns TypeScript类型字符串
+ */
+function swaggerTypeToTsType(schema) {
+    if (!schema) {
+        return 'any';
+    }
+    // 处理引用类型
+    if (schema.$ref) {
+        const refName = schema.$ref.split('/').pop();
+        return refName || 'any';
+    }
+    // 处理数组类型
+    if (schema.type === 'array') {
+        const itemType = swaggerTypeToTsType(schema.items);
+        return `${itemType}[]`;
+    }
+    // 处理对象类型
+    if (schema.type === 'object') {
+        if (schema.properties) {
+            const properties = Object.entries(schema.properties)
+                .map(([key, value]) => {
+                const optional = schema.required?.includes(key) ? '' : '?';
+                const type = swaggerTypeToTsType(value);
+                return `  ${key}${optional}: ${type};`;
+            })
+                .join('\n');
+            return `{\n${properties}\n}`;
+        }
+        return 'Record<string, any>';
+    }
+    // 处理基本类型
+    switch (schema.type) {
+        case 'integer':
+        case 'number':
+            return 'number';
+        case 'string':
+            if (schema.enum) {
+                return schema.enum.map(value => `'${value}'`).join(' | ');
+            }
+            return 'string';
+        case 'boolean':
+            return 'boolean';
+        case 'file':
+            return 'File';
+        default:
+            return 'any';
+    }
+}
+/**
+ * 从Swagger参数生成TypeScript参数类型
+ * @param parameters Swagger参数数组
+ * @returns TypeScript参数类型定义
+ */
+function generateParameterTypes(parameters) {
+    if (!parameters || parameters.length === 0) {
+        return '';
+    }
+    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 types = [];
+    // 路径参数
+    if (pathParams.length > 0) {
+        const pathType = pathParams
+            .map(p => `${p.name}: ${swaggerTypeToTsType({ type: p.type || 'string' })}`)
+            .join(', ');
+        types.push(`pathParams: { ${pathType} }`);
+    }
+    // 查询参数
+    if (queryParams.length > 0) {
+        const queryType = queryParams
+            .map(p => {
+            const optional = p.required ? '' : '?';
+            return `${p.name}${optional}: ${swaggerTypeToTsType({ type: p.type || 'string' })}`;
+        })
+            .join(', ');
+        types.push(`queryParams${queryParams.every(p => !p.required) ? '?' : ''}: { ${queryType} }`);
+    }
+    // 请求体参数
+    if (bodyParams.length > 0) {
+        const bodyParam = bodyParams[0];
+        const bodyType = swaggerTypeToTsType(bodyParam.schema);
+        types.push(`data: ${bodyType}`);
+    }
+    // 表单参数
+    if (formParams.length > 0) {
+        const formType = formParams
+            .map(p => {
+            const optional = p.required ? '' : '?';
+            return `${p.name}${optional}: ${swaggerTypeToTsType({ type: p.type || 'string' })}`;
+        })
+            .join(', ');
+        types.push(`data: { ${formType} }`);
+    }
+    return types.join(', ');
+}
+/**
+ * 确保目录存在，如果不存在则创建
+ * @param dirPath 目录路径
+ */
+function ensureDirectoryExists(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * 删除目录及其所有内容
+ * @param dirPath 目录路径
+ */
+function removeDirectory(dirPath) {
+    if (fs.existsSync(dirPath)) {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+}
+/**
+ * 读取Swagger文档
+ * @param input 文件路径或URL
+ * @returns Swagger文档对象
+ */
+async function loadSwaggerDocument(input) {
+    try {
+        if (input.startsWith('http://') || input.startsWith('https://')) {
+            // 从URL加载
+            const response = await axios_1.default.get(input);
+            return response.data;
+        }
+        else {
+            // 从文件加载
+            const content = fs.readFileSync(input, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load Swagger document from ${input}: ${error}`);
+    }
+}
+/**
+ * 写入文件
+ * @param filePath 文件路径
+ * @param content 文件内容
+ */
+function writeFile(filePath, content) {
+    const dir = path.dirname(filePath);
+    ensureDirectoryExists(dir);
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+/**
+ * 生成接口注释
+ * @param operation Swagger操作对象
+ * @param parameters 参数列表
+ * @returns 注释字符串
+ */
+function generateApiComment(operation, parameters) {
+    const comments = ['/**'];
+    if (operation.summary) {
+        comments.push(` * ${operation.summary}`);
+    }
+    if (operation.description && operation.description !== operation.summary) {
+        comments.push(` * ${operation.description}`);
+    }
+    if (parameters && parameters.length > 0) {
+        comments.push(' *');
+        parameters.forEach(param => {
+            const description = param.description || '';
+            comments.push(` * @param ${param.name} ${description}`);
+        });
+    }
+    if (operation.deprecated) {
+        comments.push(' * @deprecated');
+    }
+    comments.push(' */');
+    return comments.join('\n');
+}
+/**
+ * 清理文件名，移除非法字符
+ * @param filename 文件名
+ * @returns 清理后的文件名
+ */
+function sanitizeFilename(filename) {
+    return filename.replace(/[<>:"/\\|?*]/g, '-').replace(/\s+/g, '-');
+}
+/**
+ * 获取响应类型
+ * @param responses Swagger响应对象
+ * @returns TypeScript类型字符串
+ */
+function getResponseType(responses) {
+    // 优先获取200响应
+    const successResponse = responses['200'] || responses['201'] || responses['default'];
+    if (!successResponse) {
+        return 'any';
+    }
+    // 支持OpenAPI 3.0格式 (content.application/json.schema)
+    if (successResponse.content && successResponse.content['application/json'] && successResponse.content['application/json'].schema) {
+        return swaggerTypeToTsType(successResponse.content['application/json'].schema);
+    }
+    // 支持Swagger 2.0格式 (直接schema)
+    if (successResponse.schema) {
+        return swaggerTypeToTsType(successResponse.schema);
+    }
+    return 'any';
+}

package/dist/utils/request.d.ts

@@ -0,0 +1,17 @@
+import { type AxiosRequestConfig, type AxiosResponse, type CreateAxiosDefaults, type InternalAxiosRequestConfig } from 'axios';
+export interface IReqBoay<T> {
+    code: number;
+    data: T;
+    message: string;
+}
+declare class HttpRequest {
+    private instance;
+    constructor(options: CreateAxiosDefaults);
+    requestInterceptors(config: InternalAxiosRequestConfig): InternalAxiosRequestConfig<any>;
+    responseInterceptors(response: AxiosResponse): any;
+    private request;
+    get<T = any>({ ...config }: AxiosRequestConfig): Promise<IReqBoay<T>>;
+    post<T = any>({ ...config }: AxiosRequestConfig): Promise<IReqBoay<T>>;
+}
+export declare const request: HttpRequest;
+export {};

package/dist/utils/request.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = void 0;
+const axios_1 = __importDefault(require("axios"));
+class HttpRequest {
+    constructor(options) {
+        this.instance = axios_1.default.create(options);
+        this.instance.interceptors.request.use(this.requestInterceptors);
+        this.instance.interceptors.response.use(this.responseInterceptors);
+    }
+    requestInterceptors(config) {
+        return config;
+    }
+    responseInterceptors(response) {
+        return response.data;
+    }
+    request(config) {
+        return new Promise((resolve, reject) => {
+            this.instance
+                .request(config)
+                .then((res) => {
+                console.log('request:', res);
+                resolve(res);
+            })
+                .catch((err) => {
+                reject(err.message);
+            });
+        });
+    }
+    get({ ...config }) {
+        return this.request({
+            ...config,
+            method: 'GET'
+        });
+    }
+    post({ ...config }) {
+        return this.request({
+            ...config,
+            method: 'POST'
+        });
+    }
+}
+exports.request = new HttpRequest({
+    baseURL: ``,
+    timeout: 20000
+});

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "swagger2api-v3",
+  "version": "1.0.0",
+  "description": "从 Swagger/OpenAPI 文档生成 TypeScript API 接口的命令行工具",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "swagger2api-v3": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false",
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean",
+    "start": "node dist/cli/index.js",
+    "dev": "npm run build && npm start",
+    "lint": "prettier --write",
+    "generate": "npm run build && node dist/cli/index.js generate",
+    "init": "npm run build && node dist/cli/index.js init",
+    "validate": "npm run build && node dist/cli/index.js validate",
+    "swagger:generate": "npm run generate",
+    "swagger:run": "npm run generate",
+    "swagger:init": "npm run init",
+    "swagger:validate": "npm run validate"
+  },
+  "keywords": [
+    "swagger",
+    "openapi",
+    "typescript",
+    "api",
+    "generator",
+    "cli",
+    "code-generation"
+  ],
+  "author": "xiaoyang",
+  "license": "MIT",
+  "homepage": "https://github.com/xiaoyang33/swagger2api#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xiaoyang33/swagger2api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xiaoyang33/swagger2api/issues"
+  },
+  "packageManager": "pnpm@10.11.0",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^24.3.1",
+    "jest": "^29.5.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "axios": "^1.11.0",
+    "commander": "^12.0.0"
+  }
+}