refactor: update toolkit generator

Author: fecommunity

toolkit/README.md

@@ -89,9 +89,9 @@ The toolkit provides clients for all ReactPress backend modules:
 You can create a custom API instance with specific configuration:
 
 ```typescript
-import { createApiInstance } from '@fecommunity/reactpress-toolkit';
+import { api } from '@fecommunity/reactpress-toolkit';
 
-const customApi = createApiInstance({
+const customApi = api.createApiInstance({
   baseURL: 'https://api.yourdomain.com',
   timeout: 5000,
   // ... other axios configuration options

toolkit/demos/simple.ts

@@ -1,15 +1,15 @@
 // src/services/articleService.ts
-import api, { types, utils } from '../dist';
+import api, { types, utils, http, HttpClient, createApiInstance } from '../dist';
 
 // 文章服务层
 export class ArticleService {
   // 获取所有文章
   static async getAllArticles() {
     try {
-      const articles = await api.article.getRecommendArticles({});
-      
+      const articles = await api.article.checkPassword('test');
+
       // 格式化数据
-      return articles.data.map(article => ({
+      return articles.data.map((article) => ({
         ...article,
         formattedDate: utils.formatDate(new Date(article.createdAt || Date.now())),
       }));
@@ -59,7 +59,7 @@ export class ArticleService {
     if (utils.ApiError.isInstance(error)) {
       return error;
     }
-    
-    return new utils.ApiError(500, defaultMessage, error);
+
+    return new utils.ApiError(defaultMessage, 500, error);
   }
-}
+}

toolkit/scripts/generate-api-types.js

@@ -35,12 +35,28 @@ async function generateApiTypes() {
       httpClientType: 'axios',
       typePrefix: 'I',
       generateClient: true,
+      generateResponses: true,
+      extractRequestParams: true,
+      extractResponseBody: true,
+      singleHttpClient: true,
+      unwrapResponseData: true,
       hooks: {
         onPrepareConfig: (currentConfiguration) => {
           const config = currentConfiguration.config;
-          config.fileNames.httpClient = 'HttpClient'; // 使用大驼峰命名
+          config.fileNames.httpClient = 'HttpClient';
           return { ...currentConfiguration, config };
         },
+        onParseSchema: (originalSchema, parsedSchema) => {
+          // 确保所有属性都有类型
+          if (parsedSchema.properties) {
+            Object.keys(parsedSchema.properties).forEach(prop => {
+              if (!parsedSchema.properties[prop].type) {
+                parsedSchema.properties[prop].type = 'any';
+              }
+            });
+          }
+          return parsedSchema;
+        },
       },
     });
 
@@ -86,13 +102,14 @@ async function organizeGeneratedFiles() {
         // API 文件：首字母大写的文件或特定的客户端文件
         fs.moveSync(filePath, path.join(apiDir, file), { overwrite: true });
         console.log(`📄 移动 API 文件: ${file} -> api/`);
-      } else if (file.includes('contract') || file === 'types.ts') {
+      } else if (file.includes('contract') || file === 'types.ts' || file.includes('response')) {
         // 类型定义文件
-        fs.moveSync(filePath, path.join(typesDir, file === 'types.ts' ? 'index.ts' : file), { overwrite: true });
-        console.log(`📄 移动类型文件: {file} -> types/`);
+        const targetName = file === 'types.ts' ? 'index.ts' : file;
+        fs.moveSync(filePath, path.join(typesDir, targetName), { overwrite: true });
+        console.log(`📄 移动类型文件: ${file} -> types/`);
       } else {
         // 其他文件留在根目录
-        console.log(`📄 保留文件: {file}`);
+        console.log(`📄 保留文件: ${file}`);
       }
     }
   });
@@ -103,9 +120,15 @@ async function organizeGeneratedFiles() {
   // 修复 API 文件中的导入路径
   await fixApiImports();
 
+  // 修复缺失的类型导入
+  await fixMissingImports();
+
   // 重命名 API 方法，使其更专业
   await renameApiMethods();
 
+  // 修复请求和响应类型
+  await fixRequestResponseTypes();
+
   // 创建统一的类型索引
   await createTypeIndex();
 
@@ -171,6 +194,12 @@ async function fixApiImports() {
       "from '../types/data-contracts'"
     );
 
+    // 修复响应类型导入路径
+    content = content.replace(
+      /from '\.\/(.*responses.*)'/g,
+      "from '../types/$1'"
+    );
+    
     // 修复 HttpClient 导入路径
     content = content.replace(
       /from '\.\/httpClient'/g,
@@ -182,7 +211,7 @@ async function fixApiImports() {
       /from '\.\/([^']+)'/g,
       (match, importPath) => {
         // 如果导入路径是类型文件，则重定向到 types 目录
-        if (importPath.includes('contract') || importPath === 'types') {
+        if (importPath.includes('contract') || importPath.includes('response') || importPath === 'types') {
           return `from '../types/${importPath}'`;
         }
         return match;
@@ -197,6 +226,63 @@ async function fixApiImports() {
   console.log('✅ 所有 API 文件的导入路径已修复');
 }
 
+// 修复缺失的类型导入
+async function fixMissingImports() {
+  console.log('🔧 修复缺失的类型导入...');
+  
+  const apiDir = path.join(CONFIG.output, 'api');
+  const typesDir = path.join(CONFIG.output, 'types');
+  
+  // 获取所有 API 文件
+  const apiFiles = fs.readdirSync(apiDir).filter(file => file.endsWith('.ts') && file !== 'index.ts');
+  
+  // 读取数据契约文件，获取所有可用的类型
+  const dataContractsPath = path.join(typesDir, 'data-contracts.ts');
+  let availableTypes = [];
+  
+  if (fs.existsSync(dataContractsPath)) {
+    const dataContractsContent = fs.readFileSync(dataContractsPath, 'utf8');
+    // 提取所有接口和类型定义
+    const typeRegex = /(export interface|export type) (I[A-Z][a-zA-Z]*)/g;
+    let match;
+    while ((match = typeRegex.exec(dataContractsContent)) !== null) {
+      availableTypes.push(match[2]);
+    }
+  }
+  
+  for (const file of apiFiles) {
+    const filePath = path.join(apiDir, file);
+    let content = fs.readFileSync(filePath, 'utf8');
+    
+    // 检查当前导入语句
+    const importMatch = content.match(/import\s*{([^}]+)}\s*from\s*['"]\.\.\/types\/data-contracts['"]/);
+    
+    if (importMatch) {
+      const importedTypes = importMatch[1].split(',').map(t => t.trim());
+      
+      // 查找文件中使用的类型
+      const usedTypes = [];
+      for (const type of availableTypes) {
+        if (content.includes(type) && !importedTypes.includes(type)) {
+          usedTypes.push(type);
+        }
+      }
+      
+      // 如果有缺失的类型，添加到导入语句中
+      if (usedTypes.length > 0) {
+        const newImport = `import { ${importedTypes.join(', ')}, ${usedTypes.join(', ')} } from '../types/data-contracts';`;
+        content = content.replace(/import\s*{([^}]+)}\s*from\s*['"]\.\.\/types\/data-contracts['"]/, newImport);
+        
+        // 写入修复后的内容
+        fs.writeFileSync(filePath, content);
+        console.log(`✅ 为 ${file} 添加缺失的类型导入: ${usedTypes.join(', ')}`);
+      }
+    }
+  }
+  
+  console.log('✅ 缺失的类型导入已修复');
+}
+
 // 重命名 API 方法，使其更专业
 async function renameApiMethods() {
   console.log('🔧 重命名 API 方法...');
@@ -215,24 +301,113 @@ async function renameApiMethods() {
     const filePath = path.join(apiDir, file);
     let content = fs.readFileSync(filePath, 'utf8');
 
-    // 使用更精确的正则表达式匹配并重命名方法
-    // 匹配模式: 方法名以 Controller 开头，后面跟着大写字母
-    // 例如: articleControllerFindById -> findById
+    // 提取控制器名称 (从文件名)
+    const controllerName = file.replace('.ts', '');
+    
+    // 构建正则表达式来匹配方法定义
+    const methodRegex = new RegExp(`${controllerName.toLowerCase()}Controller([A-Z]\\w+)\\s*=`, 'g');
+    
+    // 替换方法名
+    content = content.replace(methodRegex, (match, methodPart) => {
+      // 将方法名的首字母小写
+      const newMethodName = methodPart.charAt(0).toLowerCase() + methodPart.slice(1);
+      return `${newMethodName} =`;
+    });
+    
+    // 写入修复后的内容
+    fs.writeFileSync(filePath, content);
+    console.log(`✅ 重命名 ${file} 中的方法`);
+  }
+  
+  console.log('✅ 所有 API 方法已重命名');
+}
+
+// 修复请求和响应类型
+async function fixRequestResponseTypes() {
+  console.log('🔧 修复请求和响应类型...');
+  
+  const apiDir = path.join(CONFIG.output, 'api');
+  const typesDir = path.join(CONFIG.output, 'types');
+  
+  // 获取所有 API 文件
+  const apiFiles = fs.readdirSync(apiDir).filter(file => 
+    file.endsWith('.ts') && 
+    file !== 'index.ts' && 
+    file !== 'HttpClient.ts' &&
+    /[A-Z]/.test(file[0]) // 首字母大写的文件
+  );
+  
+  // 读取数据契约类型
+  let dataContractsContent = '';
+  const dataContractsPath = path.join(typesDir, 'data-contracts.ts');
+  if (fs.existsSync(dataContractsPath)) {
+    dataContractsContent = fs.readFileSync(dataContractsPath, 'utf8');
+  }
+  
+  for (const file of apiFiles) {
+    const filePath = path.join(apiDir, file);
+    let content = fs.readFileSync(filePath, 'utf8');
+    
+    // 修复 GET 请求的错误数据参数
+    content = content.replace(
+      /(GET|DELETE|HEAD|OPTIONS).*\n.*\(data:.*params: RequestParams = {}\)/g,
+      (match) => {
+        // 对于 GET/DELETE/HEAD/OPTIONS 请求，不应该有 data 参数
+        return match.replace('data: any, ', '').replace('data: I\\w+, ', '');
+      }
+    );
+    
+    // 修复请求和响应类型
+    content = content.replace(
+      /this\.http\.request<([^,]+),\s*any>\({/g,
+      (match, responseType) => {
+        // 如果响应类型是 void 或 any，尝试推断正确的类型
+        if (responseType === 'void' || responseType === 'any') {
+          // 根据方法名和类名推断类型
+          const className = file.replace('.ts', '');
+          const methodMatch = content.match(/(\w+)\s*=\s*\([^)]*\)\s*=>/);
+          if (methodMatch) {
+            const methodName = methodMatch[1];
+            
+            // 根据方法名推断响应类型
+            let inferredType = 'any';
+            if (methodName.includes('find') || methodName.includes('get')) {
+              inferredType = `I${className}[]`;
+            } else if (methodName.includes('create') || methodName.includes('update')) {
+              inferredType = `I${className}`;
+            }
+            
+            return match.replace(responseType, inferredType);
+          }
+        }
+        return match;
+      }
+    );
+    
+    // 修复请求参数类型
     content = content.replace(
-      /(\w+)Controller([A-Z]\w+)/g,
-      (match, className, methodName) => {
-        // 将方法名的首字母小写
-        const newMethodName = methodName.charAt(0).toLowerCase() + methodName.slice(1);
-        return newMethodName;
+      /\(params:\s*RequestParams\s*=\s*{}\)\s*=>/g,
+      (match) => {
+        // 根据方法名推断请求体类型
+        const methodMatch = content.match(/(\w+)\s*=\s*\([^)]*\)\s*=>/);
+        if (methodMatch) {
+          const methodName = methodMatch[1];
+          const className = file.replace('.ts', '');
+          
+          if (methodName.includes('create') || methodName.includes('update')) {
+            return `(data: I${className}, params: RequestParams = {}) =>`;
+          }
+        }
+        return match;
       }
     );
 
     // 写入修复后的内容
     fs.writeFileSync(filePath, content);
-    console.log(`✅ 重命名 ${file} 中的方法`);
+    console.log(`✅ 修复 ${file} 的请求和响应类型`);
   }
 
-  console.log('✅ 所有 API 方法已重命名');
+  console.log('✅ 所有 API 的请求和响应类型已修复');
 }
 
 // 创建统一的类型索引
@@ -398,7 +573,7 @@ async function generateUtils() {
   const utilsDir = path.join(CONFIG.output, 'utils');
   fs.ensureDirSync(utilsDir);
 
-  // HTTP 客户端配置 - 修复类型错误
+  // HTTP 客户端配置
   const httpUtilsContent = `import axios, { AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
 
 // 创建自定义 axios 实例
@@ -411,7 +586,7 @@ export const createHttpClient = (baseURL?: string) => {
     },
   });
 
-  // 请求拦截器 - 修复类型错误
+  // 请求拦截器
   instance.interceptors.request.use(
     (config: InternalAxiosRequestConfig) => {
       // 添加认证令牌