TypeScript 接口和类型生成

export interface AppResetPasswordReq {
  email: string
  password: string
  code: string
}

export function resetPassword(params: AppResetPasswordReq): Promise<Result<boolean>> {
  return axios.post('/app/reset/password', params)
}

// more...

import fs from 'fs';
import axios from 'axios';
import type { OpenApi, OpenApiReference, OpenApiSchema, OpenApiOperation, OpenApiResponse, OpenApiMediaType, OpenApiRequestBody, OpenApiResponses } from 'openapi-v3';

const genericityList: string[] = ['ListResult', 'Result', 'PageResult', 'PageData', 'TreeNodeResult'];
const typeMapping: Record<string, string> = {
  'integer': 'number',
  'Integer': 'number',
};

let tsContent = `import axios from 'axios';
import type { Result, ListResult, PageResult, TreeNodeResult } from '@/core/types/global';\n\n`;

/**
 * 生成类型
 */
function generateType(openapi: OpenApi): string {
  let typeContent = '';
  if (!openapi.components?.schemas) {
    return typeContent;
  }
  Object.entries(openapi.components.schemas).forEach(([typeName, schema]) => {
    if (shouldSkipType(typeName)) {
      return;
    }

    schema = schema as OpenApiSchema;
    const properties = schema.properties || {};
    const requiredFields = schema.required || [];

    const paramsTypeDefinition = Object.entries(properties)
      .map(([name, prop]) => {
        const required = requiredFields.includes(name) ? '' : '?';
        return `${name}${required}: ${getPropertyType(prop)};`;
      })
      .join('\n  ');

    typeContent += `export interface ${typeName} {\n  ${paramsTypeDefinition}\n}\n\n`;
  });
  return typeContent;
}

/**
 * 生成接口
 */
function generateApi(openapi: OpenApi): string {
  let apiContent = '';
  Object.entries(openapi.paths).forEach(([path, methods]) => {
    Object.entries(methods as Record<string, OpenApiOperation>).forEach(([method, operation]) => {
      const operationId = operation.operationId;
      const summary = operation.summary || operation.description;
      const requestBody = operation.requestBody as OpenApiRequestBody;
      const responses = operation.responses as OpenApiResponses;

      // 获取请求体的类型
      let requestType = '';
      if (requestBody?.content) {
        for (const contentType in requestBody.content) {
          if (requestBody.content[contentType].schema) {
            const requestBodySchema = requestBody.content[contentType].schema as OpenApiReference;
            const ref = requestBodySchema.$ref;
            if (ref) {
              const parts = ref.split('/');
              requestType = parts[parts.length - 1];
              requestType = handleSpecialTypes(openapi, requestType);
            }
            break;
          }
        }
      }

      // 获取响应体的类型
      let responseType = '';
      const response200 = responses['200'] as OpenApiResponse;
      for (const contentType in response200.content) {
        const mediaType = response200.content[contentType] as OpenApiMediaType;
        if (mediaType.schema) {
          const responseSchema = mediaType.schema as OpenApiReference;
          const ref = responseSchema.$ref;
          if (ref) {
            const parts = ref.split('/');
            responseType = parts[parts.length - 1];
            responseType = handleSpecialTypes(openapi, responseType);
          }
          break;
        }
      }

      // 构建函数名称
      const functionName = operationId && operationId.replace(/[^\w]/g, '');

      // 构建函数注释
      const functionComment = `/**\n * ${summary}\n */`;

      // 构建请求函数
      const paramsType = requestType ? `params: ${requestType}` : 'params?: any';
      const responseTypeDefinition = responseType ? `Promise<${responseType}>` : 'Promise<any>';
      const axiosConfig = method.toLowerCase() === 'get' ? '{ params }' : 'params';
      const functionDefinition = `${functionComment}\nexport function ${functionName}(\n  ${paramsType}\n): ${responseTypeDefinition} {\n  return axios.${method.toLowerCase()}('${path}', ${axiosConfig});\n}\n\n`;

      apiContent += functionDefinition;
    });
  });
  return apiContent;
}

/**
 * 获取属性类型
 */
function getPropertyType(property: OpenApiSchema | OpenApiReference): string {
  // 类型为数组，则递归生成数组项类型
  if ('type' in property && property.type === 'array' && property.items) {
    return `${getPropertyType(property.items)}[]`;
  }
  // 类型为对象，则递归生成各子属性类型
  if ('type' in property && property.type === 'object' && property.properties) {
    return `{ ${Object.entries(property.properties).map(([name, prop]) => `${name}: ${getPropertyType(prop)}`).join(', ')} }`;
  }
  // Java 基础类型则转为 JS 基础类型
  if ('type' in property && property.type && typeMapping[property.type]) {
    return typeMapping[property.type];
  }
  // 属性指向其他 schema，则取所指向的类型
  if ((property as OpenApiReference).$ref) {
    const ref = (property as OpenApiReference).$ref || '';
    const parts = ref.split('/');
    const refType = parts[parts.length - 1];
    return refType;
  }
  return 'type' in property && property.type || 'any';
}

/**
 * 是否跳过公共类型
 * 公共类型被提取为泛型，无需生成
 */
function shouldSkipType(typeName: string): boolean {
  return genericityList.some(item => typeName.startsWith(item));
}

/**
 * 处理特殊类型
 */
function handleSpecialTypes(openapi: OpenApi, typeName: string): string {
  // 如果以泛型做前缀，则解析为泛型
  genericityList.forEach(item => {
    if (typeName.startsWith(item)) {
      typeName = `${item}<${getInnerType(openapi, typeName, item)}>`;
    }
  });
  return typeName;
}

/**
 * 获取泛型参数类型
 */
function getInnerType(openapi: OpenApi, typeName: string, prefix: string): string {
  const innerType = typeName.substring(prefix.length);
  // Java 基础类型则转为 JS 基础类型
  if (typeMapping[innerType]) {
    return typeMapping[innerType];
  }

  if (openapi.components?.schemas) {
    // schemas 中已存在的自定义类型，使用原类型名称
    const ref = openapi.components.schemas[innerType as a];
    type a = keyof typeof openapi.components.schemas
    if (ref) {
      return innerType;
    }
  }

  // 基础类型转换为小写开头
  return innerType.charAt(0).toLowerCase() + innerType.slice(1);
}

const username: string = 'aaa';
const password: string = '111';
async function getOpenApiDoc() {
  const res = await axios.get<OpenApi>('https://aaa.com/v3/api-docs/app', {
    headers: {
      'Authorization': `Basic ${btoa(`${username}:${password}`)}`
    }
  });
  const openapi = res.data
  tsContent += generateType(openapi);
  tsContent += generateApi(openapi);

  const outputFile = 'generated-api.ts';
  fs.writeFile(outputFile, tsContent, (err) => {
    if (err) {
      console.error(`写入文件时出错: ${err}`);
    } else {
      console.log(`TypeScript Axios 接口已生成到 ${outputFile}`);
    }
  });
}

getOpenApiDoc();