czh-api 1.0.0

package/dist/templates/api.hbs

@@ -0,0 +1,23 @@
+/**
+ * @description {{description}}
+ {{#if jsdocParams}}
+ {{#each jsdocParams}}
+ * @param { {{this.type}} } {{#unless this.required}}[{{/unless}}{{this.name}}{{#unless this.required}}]{{/unless}} - {{this.description}}
+ {{/each}}
+ {{/if}}
+ */
+export const {{functionName}} = ({{#if hasParams}}params: {{requestParamsTypeName}}{{/if}}{{#if hasData}}{{#if hasParams}}, {{/if}}data: {{requestBodyTypeName}}{{/if}}) => {
+  return http.request<{{responseTypeName}}>({
+    url: `{{path}}`,
+    method: '{{method}}',
+    {{#if hasParams}}
+    params,
+    {{/if}}
+    {{#if hasData}}
+    data,
+    {{/if}}
+    {{#if contentType}}
+    headers: { 'Content-Type': '{{contentType}}' },
+    {{/if}}
+  });
+}; 

package/dist/templates/index.hbs

@@ -0,0 +1,3 @@
+{{#each files}}
+export * from './{{this}}';
+{{/each}} 

package/dist/templates/types.hbs

@@ -0,0 +1 @@
+{{{content}}} 

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "czh-api",
+  "version": "1.0.0",
+  "description": "A CLI tool to generate TypeScript API clients from Swagger/OpenAPI documents.",
+  "main": "dist/index.js",
+  "bin": {
+    "czh-api": "dist/index.js"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc && node scripts/postbuild.js",
+    "dev": "ts-node src/index.ts",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "api",
+    "typescript"
+  ],
+  "author": "Czh",
+  "license": "ISC",
+  "dependencies": {
+    "@types/pinyin": "^2.10.2",
+    "axios": "^1.10.0",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.0",
+    "handlebars": "^4.7.8",
+    "json-schema-to-typescript": "^15.0.4",
+    "pinyin": "^4.0.0",
+    "rimraf": "^6.0.1",
+    "swagger-parser": "^10.0.3",
+    "typescript": "^5.8.3"
+  },
+  "devDependencies": {
+    "@types/handlebars": "^4.0.40",
+    "@types/node": "^24.0.10",
+    "@types/swagger-parser": "^4.0.3",
+    "openapi-types": "^12.1.3",
+    "ts-node": "^10.9.2"
+  }
+}

package/scripts/postbuild.js

@@ -0,0 +1,49 @@
+/*
+ * @description: 
+ * @Author: czh
+ * @Date: 2025-07-02 14:16:56
+ * @LastEditors: Czh
+ * @LastEditTime: 2025-07-02 15:12:03
+ */
+const fs = require('fs');
+const path = require('path');
+
+const filePath = path.join(__dirname, '../dist/index.js');
+const shebang = '#!/usr/bin/env node\n';
+
+try {
+    let data = fs.readFileSync(filePath, 'utf8');
+
+    if (!data.startsWith(shebang)) {
+        data = shebang + data;
+        fs.writeFileSync(filePath, data, 'utf8');
+        console.log('Shebang added to dist/index.js');
+    } else {
+        console.log('Shebang already exists in dist/index.js');
+    }
+} catch (error) {
+    console.error('Error adding shebang:', error);
+    process.exit(1);
+}
+
+const sourceDir = path.join(__dirname, '../src/templates');
+const destDir = path.join(__dirname, '../dist/templates');
+
+try {
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+
+    const templateFiles = fs.readdirSync(sourceDir);
+
+    for (const file of templateFiles) {
+        const srcFile = path.join(sourceDir, file);
+        const destFile = path.join(destDir, file);
+        fs.copyFileSync(srcFile, destFile);
+    }
+
+    console.log('Successfully copied templates to dist/templates');
+} catch (error) {
+    console.error('Error copying templates:', error);
+    process.exit(1);
+} 

package/src/commands/bill.ts

@@ -0,0 +1 @@
+ 

package/src/commands/build.ts

@@ -0,0 +1,148 @@
+/*
+ * @description: 
+ * @Author: czh
+ * @Date: 2025-07-02 10:39:30
+ * @LastEditors: Czh
+ * @LastEditTime: 2025-07-02 11:47:00
+ */
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+const SwaggerParser = require('swagger-parser');
+import { OpenAPI, OpenAPIV3 } from 'openapi-types';
+import { processApi } from '../core/parser';
+import Handlebars from 'handlebars';
+import { rimraf } from 'rimraf';
+import axios from 'axios';
+import { compile } from 'json-schema-to-typescript';
+
+interface IConfig {
+    url: string;
+    outputDir: string;
+    httpClientPath: string;
+    templates?: string;
+    customImports?: string[];
+    excludePaths?: string[];
+}
+
+export const handleBuild = async () => {
+    try {
+        console.log(chalk.blue('Building API from source...'));
+
+        // Load config
+        const configPath = path.join(process.cwd(), 'czh-api.config.json');
+        if (!fs.existsSync(configPath)) {
+            console.error(chalk.red('错误：找不到 czh-api.config.json 配置文件。请先运行 `czh-api init`。'));
+            process.exit(1);
+        }
+        const config:IConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+        // Fetch and parse Swagger/OpenAPI document
+        console.log(chalk.blue(`正在从 ${config.url} 获取 API 文档...`));
+        const response = await axios.get(config.url);
+        const api = await SwaggerParser.bundle(response.data);
+        console.log(chalk.green('Swagger document fetched and bundled successfully.'));
+
+        // Process the API document
+        const modules = processApi(api, config.excludePaths || []);
+        console.log(chalk.blue('API processed into modules.'));
+
+        // Clean output directory
+        const outputDir = path.join(process.cwd(), config.outputDir);
+        if (fs.existsSync(outputDir)) {
+            await rimraf(outputDir);
+        }
+        fs.mkdirSync(outputDir, { recursive: true });
+        console.log(chalk.yellow(`Cleaned output directory: ${outputDir}`));
+
+
+        const readTemplate = (templatePath: string | undefined, templateName: string): string => {
+            const defaultPath = path.resolve(__dirname, '../templates', templateName);
+            const userPath = templatePath ? path.join(process.cwd(), templatePath, templateName) : defaultPath;
+            try {
+                return fs.readFileSync(userPath, 'utf-8');
+            } catch (error) {
+                return fs.readFileSync(defaultPath, 'utf-8');
+            }
+        }
+        
+        const apiTemplateStr = readTemplate(config.templates, 'api.hbs');
+        const apiTemplate = Handlebars.compile(apiTemplateStr);
+
+
+        for (const moduleName in modules) {
+            const module = modules[moduleName];
+            const moduleDir = path.join(outputDir, moduleName);
+            fs.mkdirSync(moduleDir, { recursive: true });
+
+            let typesContent = '';
+            // Generate types.ts
+            if (Object.keys(module.schemas).length > 0) {
+                const schemasWithTitles: { [key: string]: OpenAPIV3.SchemaObject } = {};
+                for (const schemaName in module.schemas) {
+                    schemasWithTitles[schemaName] = {
+                        ...module.schemas[schemaName],
+                        title: schemaName, 
+                    };
+                }
+    
+                const rootSchemaForCompiler = {
+                    title: 'schemas',
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                    definitions: schemasWithTitles,
+                    components: {
+                        schemas: schemasWithTitles
+                    }
+                };
+    
+                 typesContent = await compile(rootSchemaForCompiler as any, 'schemas', {
+                    bannerComment: '/* eslint-disable */\n/**\n* This file was automatically generated by czh-api.\n* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,\n* and run czh-api build to regenerate this file.\n*/',
+                    unreachableDefinitions: true,
+                    additionalProperties: false, 
+                 });
+    
+                typesContent = typesContent.replace(/export interface \w+ \{\s*\}\n/g, '');
+                const refCommentRegex = /\/\*\*\n \* This interface was referenced by `\w+`'s JSON-Schema[\s\S]*?\*\/\n/g;
+                typesContent = typesContent.replace(refCommentRegex, '');
+                typesContent = typesContent.replace(/:\s*\{\}\[\]/g, ': any[]'); 
+                typesContent = typesContent.replace(/\[k: string\]: \{\}/g, '[k: string]: any'); 
+                const inlineIndexSignatureRegex = /:\s*\{\s*\/\*\*[\s\S]*?\*\/[\s\n\r]*\[k: string\]: any;\s*\};/g;
+                typesContent = typesContent.replace(inlineIndexSignatureRegex, ': any;');
+                typesContent = typesContent.replace(/: \{\}/g, ': any'); 
+                typesContent = typesContent.replace(/\}\n/g, '}\n\n');
+
+                fs.writeFileSync(path.join(moduleDir, 'types.ts'), typesContent);
+            }
+            
+            // Generate API file
+            const allReferencedTypes = [...new Set(module.endpoints.flatMap(e => e.referencedTypes))];
+            const customImports = config.customImports || [`import http from "${config.httpClientPath}";`];
+            
+            let apiFileContent = '';
+
+            if (module.description) {
+                apiFileContent += `/**\n * @description ${module.description}\n */\n\n`;
+            }
+            
+            apiFileContent += `${customImports.join('\n')}\n`;
+    
+            if (allReferencedTypes.length > 0) {
+                apiFileContent += `import type { ${allReferencedTypes.join(', ')} } from './types';\n\n`;
+            }
+    
+            apiFileContent += module.endpoints.map(endpoint => apiTemplate(endpoint)).join('\n\n');
+            fs.writeFileSync(path.join(moduleDir, `${moduleName}.ts`), apiFileContent);
+    
+            // Generate index.ts
+            const exportTypes = typesContent ? `\nexport * from './types';` : '';
+            fs.writeFileSync(path.join(moduleDir, 'index.ts'), `export * from './${moduleName}';${exportTypes}\n`);
+        }
+
+        console.log(chalk.green.bold('API code generated successfully!'));
+
+    } catch (error) {
+        console.error(chalk.red('An error occurred during build process:'), error);
+    }
+}; 

package/src/commands/init.ts

@@ -0,0 +1,58 @@
+/*
+ * @description: 
+ * @Author: czh
+ * @Date: 2025-07-02 10:39:17
+ * @LastEditors: Czh
+ * @LastEditTime: 2025-07-02 11:45:10
+ */
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+
+const defaultConfig = {
+  url: 'https://petstore.swagger.io/v2/swagger.json',
+  outputDir: './src/api',
+  templates: './czh-api-template',
+  customImports: ['import http from "@/utils/http";'],
+  excludePaths: []
+};
+
+const templates = ['api.hbs', 'index.hbs', 'types.hbs'];
+
+export const handleInit = async () => {
+  console.log(chalk.green('Initializing czh-api...'));
+
+  const configPath = path.join(process.cwd(), 'czh-api.config.json');
+  const templatesPath = path.join(process.cwd(), 'czh-api-template');
+
+  try {
+    await fs.access(configPath);
+    console.log(chalk.yellow('Config file already exists. Aborting.'));
+    return;
+  } catch (error) {
+    // File doesn't exist, which is what we want.
+  }
+
+  try {
+    // Write config file
+    await fs.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
+    console.log(chalk.cyan(`Created config file: ${configPath}`));
+
+    // Create templates directory
+    await fs.mkdir(templatesPath, { recursive: true });
+
+    // Copy template files
+    for (const templateName of templates) {
+      const sourcePath = path.resolve(__dirname, '../templates', templateName);
+      const destPath = path.join(templatesPath, templateName);
+      await fs.copyFile(sourcePath, destPath);
+      console.log(chalk.cyan(`Created template: ${destPath}`));
+    }
+
+    console.log(chalk.green.bold('Initialization complete!'));
+    console.log(chalk.white('You can now edit the config and templates, then run `czh-api build`.'));
+
+  } catch (error) {
+    console.error(chalk.red('An error occurred during initialization:'), error);
+  }
+};