gen-api-types 1.0.1 → 1.0.4

package/README.md

@@ -38,7 +38,7 @@ export class TestApi {
 	}
 
 	@gen_type_m()
-	static getWeather(): Promise<Res_TestApi_getWeather> {
+	static getWeather(): Promise<Response__TestApi_getWeather> {
 		return fetch('http://t.weather.sojson.com/api/weather/city/101030100').then(r => r.json())
 	}
 }
@@ -65,8 +65,8 @@ npx gen-api-types  -o output_dir -O output_file_name ./api_dir1 ./api_dir2
 Options:
   -h, --help                  输出帮助信息
   -r, --project_root <path>   项目根目录
-  -o, --output_file <path>    输出文件,默认index.d.ts
-  -d, --output_dir <path>     输出目录,默认当前根目录
+  -O, --output_file <path>    输出文件名
+  -o, --output_dir <path>     输出目录
   -t, --ts_config_path <path> tsconfig.json 文件路径
 ```
 

package/bin/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// 强制使用 tsx 执行当前目录下的 TypeScript 文件
+
+
+const { exec,execFile,spawn } = require('child_process');
+const path = require('path');
+const { promisify } = require('util')
+const p_exec = promisify(exec);
+const args = process.argv.slice(2);
+; (async function () {
+
+  try {
+    await p_exec('tsx -v')
+    try {
+      const cli_path = path.resolve(__dirname,'../src/cli/index.ts')
+      // const cli_path = path.resolve(__dirname,'../dist/gen_api_types.cli.min.js')
+
+      const cp = spawn('tsx',[cli_path,...args],{ stdio: 'inherit',shell: true })
+      cp.on('error',err => console.error('执行 tsx 命令失败',err))
+
+
+
+    } catch (error) {
+      // console.error('执行 tsx 命令失败',error)
+    }
+
+
+  } catch (error) {
+    console.error('请安装 tsx',error)
+  }
+
+})();
+

package/package.json

@@ -1,34 +1,41 @@
-{
-  "name": "gen-api-types",
-  "version": "1.0.1",
-  "description": "",
-  "main": "./src/index.ts",
-  "bin": {
-    "gen-api-types": "src/cli/index.ts"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "webpack",
-    "publish:patch": "npm version patch  && npm publish"
-  },
-  "keywords": [],
-  "files": [
-    "src",
-    "tsconfig.json",
-    "package.json"
-  ],
-  "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.7.1",
-  "dependencies": {
-    "reflect-metadata": "^0.2.2",
-    "ts-morph": "^27.0.0",
-    "tsx": "^4.20.5"
-  },
-  "devDependencies": {
-    "@types/node": "^24.3.1",
-    "ts-loader": "^9.5.4",
-    "webpack": "^5.101.0",
-    "webpack-cli": "^6.0.1"
-  }
-}
+{
+  "name": "gen-api-types",
+  "version": "1.0.4",
+  "description": "",
+  "main": "./src/index.ts",
+  "bin": {
+    "gen-api-types": "src/cli/index.ts",
+    "gat": "bin/index.js"
+  },
+  "scripts": {
+    "test": "vitest",
+    "build": "webpack",
+    "publish:patch": "npm version patch  && npm publish"
+  },
+  "keywords": [
+    "generate types",
+    "TypeScript",
+    "Cli",
+    "API"
+  ],
+  "files": [
+    "src",
+    "tsconfig.json",
+    "package.json"
+  ],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.7.1",
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "ts-morph": "^27.0.0",
+    "tsx": "^4.20.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.1",
+    "ts-loader": "^9.5.4",
+    "vitest": "^3.2.4",
+    "webpack": "^5.101.0",
+    "webpack-cli": "^6.0.1"
+  }
+}

package/src/argv/index.ts

@@ -51,8 +51,8 @@ if (help) {
   Options:
     -h, --help                  输出帮助信息
     -r, --project_root <path>   项目根目录
-    -o, --output_file <path>    输出文件
-    -d, --output_dir <path>     输出目录
+    -O, --output_file <path>    输出文件名
+    -o, --output_dir <path>     输出目录
     -t, --ts_config_path <path> tsconfig.json 文件路径
     `
   )

package/src/cli/index.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env tsx
 
 
-// scripts/generate-api-types.ts
 import * as path from 'path';
 import { Decorator, Project } from 'ts-morph';
 import { pathToFileURL } from 'url';
@@ -9,10 +8,12 @@ import { output_dir, output_file, positionals } from '../argv';
 import { C_DECO_NAME, M_DECO_NAME } from '../constant';
 import { GenTypeOptions } from '../decotators';
 import { TypeTransformer } from '../transformer';
+import { formatResultList } from '../utils';
 
-
+// console.log('positionals', positionals)
 
 const sourceFilesGlob = positionals.map(dir => path.normalize(`${dir}/**/*.ts`))
+const out_put_target = path.resolve(output_dir, output_file)
 
 // console.log('arg', _arg)
 // console.log('sourceFilesGlob', sourceFilesGlob)
@@ -49,6 +50,7 @@ function getApiMethodsInfo() {
   const project = new Project({});
 
   project.addSourceFilesAtPaths(sourceFilesGlob);
+  // console.log('project.getSourceFiles().length', project.getSourceFiles().length)
   // debugger
   // 3. 遍历所有源文件
   for (const sourceFile of project.getSourceFiles()) {
@@ -84,11 +86,10 @@ function getApiMethodsInfo() {
   return apiMethodsInfo
 }
 
-type ExcuteApiMethodsResult = {
-  successList: { data: any, typeName: string, fullMethodName: string }[],
-  errorList: { fullMethodName: string, error: any }[]
+type ExecuteApiMethodResult = {
+  data?: any, typeName: string, fullMethodName: string, error?: any
 }
-async function excuteApiMethods(apiMethodsInfo: ApiMethodInfo[]): Promise<ExcuteApiMethodsResult> {
+async function executeApiMethods(apiMethodsInfo: ApiMethodInfo[]): Promise<ExecuteApiMethodResult[]> {
   const apiModuleMap = new Map<string, any>();
   const taskList = apiMethodsInfo.map(async (apiMethodInfo) => {
     const { className, methodName, fullMethodName, modulePath, args, typeName } = apiMethodInfo
@@ -103,69 +104,89 @@ async function excuteApiMethods(apiMethodsInfo: ApiMethodInfo[]): Promise<Excute
 
       try {
         apiModule = await import(pathToFileURL(modulePath).href)
-        console.log('apiMethod', apiModule)
+        // console.log('apiMethod', apiModule)
         if (apiModule) apiModuleMap.set(modulePath, apiModule)
       } catch (error) {
-        console.log('import modulePath error', error)
+        console.log(`import ${modulePath} error \r\n`, error)
+        return { error: `module error`, fullMethodName, typeName }
       }
-
     }
+
+
     const apiMethod = apiModule?.[className]?.[methodName]
     if (apiMethod && typeof apiMethod === 'function') {
       try {
-        console.log(`🔍 Calling ${fullMethodName} with args:`, args);
+        // console.log(`🔍 Calling ${fullMethodName} with args:`, args);
         const result = apiMethod.apply(apiModule, args)
         if (result instanceof Promise) {
           const data = await result
           // console.log(`${fullMethodName} result`)
           return { data, typeName, fullMethodName }
         }
-        return { error: 'not Promise method', fullMethodName }
+        return { error: 'not Promise method', fullMethodName, typeName }
       } catch (error) {
         console.error(`❌ ${fullMethodName} execute error:`, error)
-        return { error, fullMethodName }
+        return { error, fullMethodName, typeName }
       }
     } else {
-      console.error(`❌ 无法获取 ${fullMethodName}或 非 可调用方法 `)
+      console.error(`❌ 无法获取 ${fullMethodName} 方法， 或不是可调用方法 `)
       return {
-        error: `method error`, fullMethodName
+        error: `method error`, fullMethodName, typeName
       }
     }
   })
 
-  const resultList = await Promise.all(taskList)
-  return {
-    successList: resultList.filter(item => !item.error) as ExcuteApiMethodsResult['successList'],
-    errorList: resultList.filter(item => item.error) as ExcuteApiMethodsResult['errorList'],
-  }
+  return Promise.all(taskList)
+
 }
 
-function createDeclarationFile(successList: ExcuteApiMethodsResult['successList']) {
-  const out_put_target = path.resolve(output_dir, output_file)
-  // console.log('out_put_target', out_put_target)
+
+function createDeclarationFile(successList: ExecuteApiMethodResult[]) {
   const ttf = new TypeTransformer({ filePath: out_put_target })
-  const tasks = successList.map(item => ttf.transform(item.data, item.typeName))
+  const tasks = successList.map(async ({ data, typeName, fullMethodName }) => {
+    try {
+      await ttf.transform(data, typeName)
+      return { fullMethodName }
+    } catch (error) {
+      console.error('transform error', error)
+      return { fullMethodName, error }
+    }
+  })
   return Promise.all(tasks)
 }
 
+
+
+
 async function main() {
   try {
     console.log('🚀 开始生成API类型...');
     const apiMethodsInfo = getApiMethodsInfo();
-    const { successList, errorList } = await excuteApiMethods(apiMethodsInfo);
-
-    console.group('请求结果：')
-    console.table({
-      "✔️  successList": successList.map(item => item.fullMethodName).join(' '),
-      "❌ errorList": errorList.map(item => item.fullMethodName).join(' ')
-    })
-    console.groupEnd()
-    await createDeclarationFile(successList)
-
-    console.log('✅ API 类型生成完成');
-
+    if (apiMethodsInfo.length == 0) return console.warn('⚠️ 未找到需要转换的API,请检查api_dir 和 get_type装饰器标注是否正确!')
+    const executeList = await executeApiMethods(apiMethodsInfo);
+
+    const { successList: executeSuccessList, errorList: executeErrorList } = formatResultList(executeList)
+    if (executeErrorList.length) {
+      console.group('请求结果：')
+      console.table({
+        "✔️ executeSuccessList": executeSuccessList.map(item => item.fullMethodName).join(' '),
+        "❌ executeErrorList": executeErrorList.map(item => item.fullMethodName).join(' ')
+      })
+      console.groupEnd()
+    }
+    const transformList = await createDeclarationFile(executeSuccessList)
+    const { successList: transformSuccessList, errorList: transformErrorList } = formatResultList(transformList)
 
+    if (transformErrorList.length) {
+      console.group('转换结果：')
+      console.table({
+        "✔️ transformSuccessList": transformSuccessList.map(item => item.fullMethodName).join(' '),
+        "❌ transformErrorList": transformErrorList.map(item => item.fullMethodName).join(' ')
+      })
+      console.groupEnd()
 
+    }
+    if (transformSuccessList.length) console.log('✅ API 类型生成完成：', out_put_target);
   } catch (error) {
     console.error('❌ 出错了', error)
   }

package/src/transformer/index.ts

@@ -14,8 +14,10 @@ function inferType(value: any): string {
     return "number";
   } else if (typeof value === "boolean") {
     return "boolean";
-  } else if (!value) {
+  } else if (value === null) {
     return "null";
+  } else if (!value) {
+    return "undefined";
   } else {
     return "any";
   }
@@ -25,9 +27,11 @@ function inferType(value: any): string {
 export class TypeTransformer {
   project: Project;
   sourceFile: SourceFile;
-  constructor({ projectOptions = {}, filePath = "types.d.ts" } = {}) {
+  isExported: boolean
+  constructor({ projectOptions = {}, filePath = "types.d.ts", isExported = false } = {}) {
     this.project = new Project(projectOptions);
     this.sourceFile = this.createSourceFile(filePath);
+    this.isExported = isExported
   }
 
   createSourceFile(filePath: string) {
@@ -45,14 +49,14 @@ export class TypeTransformer {
     // 4. 添加类型别名
     this.sourceFile.addTypeAlias({
       name: typeName,
-      // isExported: true,
+      isExported: this.isExported,
       type: inferType(val)
     });
+    // if (typeName == 'Res_Weather') throw Error('res_weather  test error')
   }
-  transform(res: any, typeName: string, isAsync = true) {
-
+  async transform(res: any, typeName: string, isAsync = true) {
     this.generateTypeFromObject(res, typeName)
-    return this.sourceFile.save();
+    await this.sourceFile.save();
   }
 
 }

package/src/utils/index.ts

@@ -1,12 +1,8 @@
-
-export function testHello() {
-  if (Math.random() > 0.5) throw new Error('test error')
-
-  return { hello: 'hello' };
+type ResultInfoBase = { error?: any }
+export function formatResultList<T extends ResultInfoBase>(list: T[]) {
+  return list.reduce((acc, item) => {
+    if (item.error) acc.errorList.push(item)
+    else acc.successList.push(item)
+    return acc
+  }, { successList: [] as Omit<T, 'error'>[], errorList: [] as T[] })
 }
-
-let val = Array(10).fill(testHello())
-console.log('val', val)
-
-
-console.log('999', 123)