gen-api-types 1.0.13 → 1.0.16

package/README.en.md

@@ -10,8 +10,8 @@ With this tool, we can mark request interface classes and methods through TypeSc
 
 > Note:
 >
-> 1. Because this tool uses TypeScript decorators, and decorators currently (TypeScript 5.0) do not support decorating plain functions directly, APIs must be written as **API classes + static API methods**.
-> 2. This tool needs to dynamically execute TypeScript code (importing API classes and calling the marked static API methods), so it runs through the bundled `tsx` dependency. No global `tsx` installation is required.
+> 1. Because this tool uses TypeScript decorators, and decorators currently (TypeScript 5.0) do not support decorating plain functions directly, APIs must be written as **API classes + API methods**.
+> 2. This tool needs to dynamically execute TypeScript code (importing API classes and calling the marked API methods), so it runs through the bundled `tsx` dependency. No global `tsx` installation is required.
 
 #### Installation
 
@@ -90,13 +90,13 @@ Command output:
 ```shell
 🚀 Start generating API types...
 sourceFilesGlob [ 'src\\**\\*.ts' ]
-📋 Processing UserApi.getList ...
-📋 Processing UserApi.getWeather ...
+📋 Processing TestApi.getList ...
+📋 Processing TestApi.getWeather ...
 Request results:
   ┌────────────────┬──────────────────────────────────────┐
   │ (index)        │ Values                               │
   ├────────────────┼──────────────────────────────────────┤
-  │ ✔️ successList │ 'UserApi.getList UserApi.getWeather' │
+  │ ✔️ successList │ 'TestApi.getList TestApi.getWeather' │
   │ ❌ errorList   │ ''                                   │
   └────────────────┴──────────────────────────────────────┘
 ✅ API type generation completed
@@ -147,3 +147,30 @@ Generated output example:
 export type XXX = { name: string };
 export type Response_TestApi_getWeather = {...}
 ```
+
+#### VS Code Extension
+
+If you use `gen-api-types` in VS Code, you can install the companion extension [gen-api-types-vsce](https://github.com/xuejiangping/gen-api-types-vsce) to generate API return types from the context menu.
+
+![alt text](docs/images/image.png)
+
+The extension does not bundle the CLI. It invokes the version of `gen-api-types` installed locally in the current project.
+
+After installing the extension, right-click in a `.ts` or `.tsx` file containing the decorated APIs and select `Generate API Return Types (gen-api-types)`. By default, the extension will:
+
+- Use the directory containing the current TypeScript file as the `api_dirs` argument
+- Generate the type file in the same directory as the current TypeScript file
+- Use `api-types.d.ts` as the default output file name
+- Ask for confirmation before overwriting an existing output file
+
+You can configure the CLI arguments in the VS Code settings:
+
+| Extension setting            | CLI argument           | Default behavior                                      |
+| ---------------------------- | ---------------------- | ----------------------------------------------------- |
+| `gen-api-types.projectRoot`  | `-r, --project_root`   | Workspace root containing the current TypeScript file |
+| `gen-api-types.outputFile`   | `-O, --output_file`    | `api-types.d.ts`                                      |
+| `gen-api-types.outputDir`    | `-o, --output_dir`     | Directory containing the current TypeScript file      |
+| `gen-api-types.tsConfigPath` | `-t, --ts_config_path` | Not passed; the CLI uses its default value            |
+| `gen-api-types.isExported`   | `--isExported`         | `false`                                               |
+
+The extension is essentially a VS Code entry point for the CLI. Type analysis, API execution, and type-file generation are still handled by `gen-api-types`.

package/README.md

@@ -10,8 +10,8 @@
 
 > 注意：
 >
-> 1. 由于需要使用到ts装饰器特性，而装饰器目前（ts 5.0）不支持直接标记普通函数，所以我们的接口必须以 **接口类+静态api方法** 的形式书写
-> 2. 该工具需要动态执行 ts 代码（import接口类，然后调用标记的静态api方法），因此会通过内置依赖的 `tsx` 执行工具运行，无需额外全局安装 `tsx`。
+> 1. 由于需要使用到ts装饰器特性，而装饰器目前（ts 5.0）不支持直接标记普通函数，所以我们的接口必须以 **接口类+api方法** 的形式书写
+> 2. 该工具需要动态执行 ts 代码（import接口类，然后调用标记的api方法），因此会通过内置依赖的 `tsx` 执行工具运行，无需额外全局安装 `tsx`。
 
 #### 安装教程
 
@@ -19,7 +19,6 @@
 
 ```shell
 npm install gen-api-types -D
-
 ```
 
 #### 使用说明
@@ -49,8 +48,8 @@ export class TestApi {
 
 - `@gen_type_c`装饰器函数，用来标记接口类。因为工具会动态分析指定目录下的所有 ts 文件，标记接口类，可以帮助我们快速定位接口类
 - `@gen_type_m`装饰器函数标记需要转换的请求方法。它可以接收一个配置对象，包含两个字段。
-  1.  `typeName: string` 接口返回类型名称，若不指定该字段，默认生成名称为： `Response_${类名}_${方法名}`
-  2.  `args：any[] ` 方法参数列表,工具调用请求方法时，会将参数列表传入
+  1. `typeName: string` 接口返回类型名称，若不指定该字段，默认生成名称为： `Response_${类名}_${方法名}`
+  2. `args：any[] ` 方法参数列表,工具调用请求方法时，会将参数列表传入
 
 > 注意：
 
@@ -148,3 +147,29 @@ npx gen-api-types --isExported -o output_dir -O output_file_name ./api_dir1 ./ap
 export type XXX = { name: string };
 export type Response_TestApi_getWeather = {...}
 ```
+
+#### VS Code 插件
+
+如果你在 VS Code 中使用 `gen-api-types` ，可以安装配套插件 [gen-api-types-vsce](https://github.com/xuejiangping/gen-api-types-vsce)，通过右键菜单生成 API 返回类型。
+![alt text](docs/images/image.png)
+
+插件不会内置 CLI，它会调用当前业务项目本地安装的 `gen-api-types`：
+
+安装插件后，在已标记装饰器的 `.ts` / `.tsx` 文件中右键选择 `生成 API 返回类型(gen-api-types)` 即可。插件会默认：
+
+- 将当前 TypeScript 文件所在目录作为 `api_dirs` 参数
+- 将类型文件生成到当前 TypeScript 文件同目录
+- 使用 `api-types.d.ts` 作为默认输出文件名
+- 输出文件已存在时弹出覆盖确认
+
+插件支持在 VS Code 设置中配置 CLI 参数：
+
+| 插件配置项                   | 对应 CLI 参数          | 默认行为                          |
+| ---------------------------- | ---------------------- | --------------------------------- |
+| `gen-api-types.projectRoot`  | `-r, --project_root`   | 当前 TS 文件所在 workspace 根目录 |
+| `gen-api-types.outputFile`   | `-O, --output_file`    | `api-types.d.ts`                  |
+| `gen-api-types.outputDir`    | `-o, --output_dir`     | 当前 TS 文件所在目录              |
+| `gen-api-types.tsConfigPath` | `-t, --ts_config_path` | 不传，由 CLI 使用默认值           |
+| `gen-api-types.isExported`   | `--isExported`         | `false`                           |
+
+插件本质上是对 CLI 的 VS Code 入口封装，类型分析、接口执行和类型文件生成仍由 `gen-api-types` 完成。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gen-api-types",
-  "version": "1.0.13",
+  "version": "1.0.16",
   "description": "一个自动生成请求接口返回类型的 cli 小工具",
   "main": "./src/index.ts",
   "exports": {
@@ -30,6 +30,7 @@
   "files": [
     "bin",
     "src",
+    "docs",
     "tsconfig.json",
     "package.json"
   ],

package/src/cli/index.ts

@@ -26,6 +26,7 @@ type ApiMethodInfo = {
   modulePath: string,
   args: any[],
   typeName: string,
+  isStatic: boolean
 }
 
 function parserDecoArgs(deco: Decorator): GenTypeOptions {
@@ -61,15 +62,14 @@ function getApiMethodsInfo() {
       if (!c_deco) continue
       const methods = classDeclaration.getMethods();
       for (const method of methods) {
-
         const className = classDeclaration.getName()!;
         const methodName = method.getName();
         const fullMethodName = `${className}.${methodName}`;
 
-        if (!method.isStatic()) {
-          console.warn(`⚠️  ${fullMethodName} is not static method,only static method can be transformed`)
-          continue
-        }
+        // if (!method.isStatic()) {
+        //   console.warn(`⚠️  ${fullMethodName} is not static method,only static method can be transformed`)
+        //   continue
+        // }
         // 4. 检查方法是否被我们的装饰器标记
         const m_deco = method.getDecorator(M_DECO_NAME)
         if (!m_deco) continue
@@ -77,7 +77,7 @@ function getApiMethodsInfo() {
         const { args = [], typeName = `Response_${className}_${methodName}` } = parserDecoArgs(m_deco)
         apiMethodsInfo.push({
           className, methodName, fullMethodName, modulePath: sourceFile.getFilePath(),
-          typeName, args
+          typeName, args, isStatic: method.isStatic()
         })
 
       }
@@ -91,10 +91,13 @@ type ExecuteApiMethodResult = {
 }
 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
+  // debugger
+  const taskList: ExecuteApiMethodResult[] = []
+  for (const apiMethodInfo of apiMethodsInfo) {
+    const { className, methodName, fullMethodName, modulePath, args, typeName, isStatic } = apiMethodInfo
     console.log(`📋 处理 ${fullMethodName} ...`);
     let apiModule = null
+    // debugger
     if (apiModuleMap.has(modulePath)) apiModule = apiModuleMap.get(modulePath)
     else {
       // apiModule = await import(modulePath)
@@ -108,31 +111,35 @@ async function executeApiMethods(apiMethodsInfo: ApiMethodInfo[]): Promise<Execu
         if (apiModule) apiModuleMap.set(modulePath, apiModule)
       } catch (error) {
         console.log(`import ${modulePath} error \r\n`, error)
-        return { error: `module error`, fullMethodName, typeName }
+        taskList.push({ error: `module error`, fullMethodName, typeName })
       }
     }
 
-
-    const apiMethod = apiModule?.[className]?.[methodName]
+    const apiMethod = isStatic ?
+      apiModule?.[className][methodName]
+      : apiModule?.[className].prototype[methodName]
     if (apiMethod && typeof apiMethod === 'function') {
       try {
         // console.log(`🔍 Calling ${fullMethodName} with args:`, args);
         const result = apiMethod.apply(apiModule, args)
         const data = await Promise.resolve(result)
-        return { data, typeName, fullMethodName }
+        taskList.push({ data, typeName, fullMethodName })
       } catch (error) {
         console.error(`❌ ${fullMethodName} execute error:`, error)
-        return { error, fullMethodName, typeName }
+        taskList.push({ error, fullMethodName, typeName })
       }
     } else {
       console.error(`❌ 无法获取 ${fullMethodName} 方法， 或不是可调用方法 `)
-      return {
+      taskList.push({
         error: `method error`, fullMethodName, typeName
-      }
+      })
     }
-  })
+  }
+
+
+
 
-  return Promise.all(taskList)
+  return taskList
 
 }