gorig-cli 1.0.7 → 1.0.8

package/README.md

@@ -1,65 +1,65 @@
 # Gorig CLI
 
-Gorig CLI 是一个基于 Node.js 的脚手架工具，用于快速创建基于 Gorig 框架的 Go 项目结构和模块。
+Gorig CLI is a scaffolding tool based on Node.js, used for quickly creating the project structure and modules based on the Gorig framework for Go.
 
-## 安装
+## Installation
 
-使用 npm 全局安装：
+Install globally using npm:
 
 ```sh
 npm install -g gorig-cli
 ```
 
-或者使用 npx 直接运行：
+Or run directly using npx:
 
 ```sh
 npx gorig-cli@latest <command>
 ```
 
-## 快速开始
+## Quick Start
 
-### 初始化新项目
+### Initialize a New Project
 
-使用 `init` 命令创建一个新项目：
+Use the `init` command to create a new project:
 
 ```sh
 gorig-cli init my-new-project
 ```
 
-或者使用 npx：
+Or use npx:
 
 ```sh
 npx gorig-cli@latest init my-new-project
 ```
 
-这将在当前目录下创建一个新项目，包含 `_cmd/main.go`、`domain/init.go`、`cron/cron.go` 等基本文件和目录。
+This will create a new project in the current directory, including basic files and directories like `_cmd/main.go`, `domain/init.go`, `cron/cron.go`, etc.
 
-### 创建新模块
+### Create a New Module
 
-在项目根目录下使用 `create` 命令创建一个新模块：
+Use the `create` command in the project root directory to create a new module:
 
 ```sh
 gorig-cli create user
 ```
 
-或者使用 npx：
+Or use npx:
 
 ```sh
 npx gorig-cli@latest create user
 ```
 
-这将在项目中创建一个名为 `user` 的模块，包含 `api/`、`internal/`、`model/` 等文件夹和必要的代码。
+This will create a module named `user` in the project, including folders like `api/`, `internal/`, `model/`, and necessary code.
 
-### 运行项目
+### Run the Project
 
-进入项目目录后，可以使用以下命令运行项目：
+After entering the project directory, you can run the project using the following commands:
 
 ```sh
 cd my-new-project
 go run _cmd/main.go
 ```
 
-或者编译后运行：
+Or run it after building:
 
 ```sh
 go build -o my-new-project _cmd/main.go && ./my-new-project

package/bin/cli.js

@@ -39,6 +39,14 @@ switch (command) {
       console.error(chalk.red('无法加载 init 命令模块:', error.message));
     });
     break;
+  case 'doc':
+    import(path.join(__dirname, '../commands/doc.js')).then(module => {
+      const docModule = module.default;
+      docModule();  // 执行 doc 命令
+    }).catch(error => {
+      console.error(chalk.red('无法加载 doc 命令模块:', error.message));
+    });
+    break;
 
   default:
     console.error(chalk.red(`未知的命令: ${command}`));

package/commands/create.js

@@ -4,11 +4,11 @@ import ejs from 'ejs';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
 
-// 定义 __dirname 变量
+// Define __dirname variable
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// 获取 go.mod 文件中的模块名称
+// Get the module name from the go.mod file
 const getGoModModuleName = async () => {
   try {
     const goModPath = path.join(process.cwd(), 'go.mod');
@@ -17,35 +17,35 @@ const getGoModModuleName = async () => {
     if (moduleLine) {
       return moduleLine.split(' ')[1].trim();
     } else {
-      throw new Error('未找到模块名称');
+      throw new Error('Module name not found');
     }
   } catch (error) {
-    console.error(chalk.red('无法读取 go.mod 文件。请确认您是否在 Go 项目的根目录下运行该命令。'));
+    console.error(chalk.red('Unable to read go.mod file. Please confirm that you are running this command in the root directory of the Go project.'));
     process.exit(1);
   }
 };
 
-// 创建模块的主函数
+// Create module main function
 const createModule = async (args) => {
   if (args.length < 1) {
-    console.error(chalk.yellow('请使用正确的命令格式: npx <你的包名> create <模块名>'));
+    console.error(chalk.yellow('Please use the correct command format: npx <your package name> create <module name>'));
     process.exit(1);
   }
 
   const moduleName = args[0];
   const ModuleName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
 
-  // 获取当前工作目录，即执行命令的目录
+  // Get the current working directory, which is the directory where the command is executed
   const currentDir = process.cwd();
 
-  // 构建 domain 目录和模块目录的路径
+  // Build the paths for the domain directory and module directory
   const domainDir = path.join(currentDir, 'domain');
   const moduleDir = path.join(domainDir, moduleName);
 
-  // 定义需要创建的子目录
+  // Define the subdirectories to be created
   const subDirs = ['api', 'model', 'internal', 'api/req'];
 
-  console.log(chalk.blue(`\n开始创建模块: ${chalk.bold(moduleName)}`));
+  console.log(chalk.blue(`\nStarting to create module: ${chalk.bold(moduleName)}`));
 
   try {
     const projectName = await getGoModModuleName();
@@ -53,106 +53,107 @@ const createModule = async (args) => {
     await fs.ensureDir(domainDir);
     await fs.ensureDir(moduleDir);
 
-    // 创建子目录
+    // Create subdirectories
     const createSubDirs = subDirs.map((subDir) => {
       const subDirPath = path.join(moduleDir, subDir);
       return fs.ensureDir(subDirPath);
     });
     await Promise.all(createSubDirs);
 
-    // 创建并写入 model.go 文件
+    // Create and write model.go file
     const modelDir = path.join(moduleDir, 'model');
     const modelFilePath = path.join(modelDir, `${moduleName}.go`);
     const modelTemplatePath = path.join(__dirname, '../templates/model.go.ejs');
     const modelContent = await ejs.renderFile(modelTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(modelFilePath, modelContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('model.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('model.go')} file`));
 
-    // 创建并写入 req.go 文件
+    // Create and write req.go file
     const apiDir = path.join(moduleDir, 'api');
     const reqDir = path.join(apiDir, 'req');
     const reqFilePath = path.join(reqDir, `req.go`);
     const reqTemplatePath = path.join(__dirname, '../templates/req.go.ejs');
     const reqContent = await ejs.renderFile(reqTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(reqFilePath, reqContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('req.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('req.go')} file`));
 
-    // 创建并写入 resp.go 文件
+    // Create and write resp.go file
     const respFilePath = path.join(reqDir, `resp.go`);
     const respTemplatePath = path.join(__dirname, '../templates/resp.go.ejs');
     const respContent = await ejs.renderFile(respTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(respFilePath, respContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('resp.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('resp.go')} file`));
 
-    // 创建并写入 internal.go 文件
+    // Create and write internal.go file
     const internalDir = path.join(moduleDir, 'internal');
     const internalFilePath = path.join(internalDir, `${moduleName}.go`);
     const internalTemplatePath = path.join(__dirname, '../templates/internal.go.ejs');
     const internalContent = await ejs.renderFile(internalTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(internalFilePath, internalContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('internal.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('internal.go')} file`));
 
-    // 创建并写入 service.pub.go 文件
+    // Create and write service.pub.go file
     const serviceFilePath = path.join(apiDir, `service.pub.go`);
     const serviceTemplatePath = path.join(__dirname, '../templates/service.pub.go.ejs');
     const serviceContent = await ejs.renderFile(serviceTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(serviceFilePath, serviceContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('service.pub.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('service.pub.go')} file`));
 
-    // 创建并写入 service.go 文件
+    // Create and write service.go file
     const serviceGoFilePath = path.join(apiDir, `service.go`);
     const serviceGoTemplatePath = path.join(__dirname, '../templates/service.go.ejs');
     const serviceGoContent = await ejs.renderFile(serviceGoTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(serviceGoFilePath, serviceGoContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('service.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('service.go')} file`));
 
-    // 创建并写入 controller.go 文件
+    // Create and write controller.go file
     const controllerGoFilePath = path.join(apiDir, `controller.go`);
     const controllerGoTemplatePath = path.join(__dirname, '../templates/controller.go.ejs');
     const controllerGoContent = await ejs.renderFile(controllerGoTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(controllerGoFilePath, controllerGoContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('controller.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('controller.go')} file`));
 
-    // 创建并写入 router.go 文件
+    // Create and write router.go file
     const routerGoFilePath = path.join(apiDir, `router.go`);
     const routerGoTemplatePath = path.join(__dirname, '../templates/router.go.ejs');
     const routerGoContent = await ejs.renderFile(routerGoTemplatePath, { moduleName, ModuleName, projectName });
     await fs.writeFile(routerGoFilePath, routerGoContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('router.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('router.go')} file`));
 
-    // 检查并更新 domain/init.go 文件
+    // Check and update domain/init.go file
     const initFilePath = path.join(domainDir, 'init.go');
     if (await fs.pathExists(initFilePath)) {
       let initFileContent = await fs.readFile(initFilePath, 'utf-8');
-      
+
       const importStatement = `import _ "${projectName}/domain/${moduleName}/api"`;
 
       if (!initFileContent.includes(importStatement)) {
         const initFuncIndex = initFileContent.indexOf('func init()');
-        
+
         if (initFuncIndex !== -1) {
-          // 找到 init 函数，确保在 init 函数上方添加 import 语句
+          // Find init function, ensure import statement is added above init function
           const insertPosition = initFuncIndex;
-          initFileContent = 
-            initFileContent.slice(0, insertPosition) + 
-            `${importStatement}\n\n` + 
+          const headCode = initFileContent.slice(0, insertPosition).trimEnd();
+          initFileContent =
+            `${headCode}\n` +
+            `${importStatement}\n\n` +
             initFileContent.slice(insertPosition);
 
           await fs.writeFile(initFilePath, initFileContent);
-          console.log(chalk.green(`成功更新 ${chalk.bold('init.go')} 文件，添加 import 语句`));
+          console.log(chalk.green(`Successfully updated ${chalk.bold('init.go')} file, added import statement`));
         } else {
-          console.log(chalk.yellow(`未找到 init() 函数，跳过 import 语句添加`));
+          console.log(chalk.yellow(`init() function not found, skipping import statement addition`));
         }
       } else {
-        console.log(chalk.yellow(`init.go 文件中已存在相应的 import 语句，无需重复添加`));
+        console.log(chalk.yellow(`The corresponding import statement already exists in init.go, no need to add it again`));
       }
     } else {
-      console.log(chalk.yellow(`未找到 ${chalk.bold('init.go')} 文件，跳过 import 语句添加`));
+      console.log(chalk.yellow(`Could not find ${chalk.bold('init.go')} file, skipping import statement addition`));
     }
 
-    console.log(chalk.blue(`\n模块 ${chalk.bold(moduleName)} 已成功创建在 ${chalk.bold(`domain/${moduleName}`)} 目录下`));
+    console.log(chalk.blue(`\nModule ${chalk.bold(moduleName)} has been successfully created in ${chalk.bold(`domain/${moduleName}`)} directory`));
   } catch (error) {
-    console.error(chalk.red('创建模块时出错:'), chalk.redBright(error.message));
+    console.error(chalk.red('Error creating module:'), chalk.redBright(error.message));
   }
 };
 

package/commands/doc.js

@@ -0,0 +1,682 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ejs from 'ejs';
+import { spawn } from 'child_process'; // 从 exec 改为 spawn
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+import semver from 'semver';  // 用于处理版本号
+import { Command } from 'commander'; // 正确导入 Command
+import yaml from 'js-yaml'; // 导入 js-yaml 用于解析 YAML
+
+// 获取当前文件的目录
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 格式化日期为 "YYYY-MM-DD HH:MM:SS"
+ * @param {Date} date - 要格式化的日期对象
+ * @returns {string} - 格式化后的日期字符串
+ */
+const formatDate = (date) => {
+    const pad = (n) => n < 10 ? '0' + n : n;
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
+        `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+};
+
+/**
+ * 提取路径参数，例如 "/user/get/:id" -> ["id"]
+ */
+const extractPathParams = (pathStr) => {
+    const regex = /:([\w]+)/g;
+    const params = [];
+    let match;
+    while ((match = regex.exec(pathStr)) !== null) {
+        params.push(match[1]);
+    }
+    return params;
+};
+
+/**
+ * 解析 router.go 获取路由信息
+ */
+const scanRouterFile = async (routerFilePath) => {
+    try {
+        const routerContent = await fs.readFile(routerFilePath, 'utf-8');
+        const routeRegex = /(\w+)\.(GET|POST|PUT|DELETE)\("([^"]+)",\s*(\w+)\)/g;
+        const routes = [];
+        let match;
+        while ((match = routeRegex.exec(routerContent)) !== null) {
+            const method = match[2];
+            const path = match[3];
+            const handler = match[4];
+            const pathParams = extractPathParams(path);
+            routes.push({
+                method,
+                path,
+                handler,
+                pathParams
+            });
+        }
+        return routes;
+    } catch (error) {
+        console.error(chalk.red(`Failed to read router file: ${routerFilePath}`), error);
+        return [];
+    }
+};
+
+/**
+ * 解析结构体文件，提取带有 `form` 或 `json` 标签的字段
+ * 支持递归解析嵌套的结构体
+ * @param {string} structFilePath - 结构体文件路径
+ * @param {string} structName - 结构体名称
+ * @param {string} modelDir - 模型文件目录
+ * @returns {Array} - 字段数组，包含 name, type
+ */
+const parseStructFields = async (structFilePath, structName, modelDir) => {
+    try {
+        const structContent = await fs.readFile(structFilePath, 'utf-8');
+        // 修正正则表达式，确保能够匹配结构体内容
+        const structRegex = new RegExp(`type\\s+${structName}\\s+struct\\s*{([\\s\\S]*?)}\\s*`, 'm');
+        const match = structRegex.exec(structContent);
+        if (!match) {
+            console.warn(chalk.yellow(`Struct ${structName} definition not found`));
+            return [];
+        }
+        const fieldsContent = match[1];
+        const fields = [];
+        const fieldRegex = /\s*(\w+)\s+([\w\.\*\[\]]+)\s+`[^`]*?(?:json|form):"([^"]+)"[^`]*`/g;
+        let fieldMatch;
+        while ((fieldMatch = fieldRegex.exec(fieldsContent)) !== null) {
+            const fieldName = fieldMatch[1];
+            const fieldType = fieldMatch[2];
+            const tagName = fieldMatch[3];
+            fields.push({
+                name: tagName,
+                type: fieldType
+            });
+
+            // 检查是否为嵌入的结构体，例如 model.UserD 或 req.UserReq
+            if (fieldType.startsWith('model.') || fieldType.startsWith('req.')) {
+                const embeddedStructName = fieldType.split('.')[1].replace('*', '');
+                let embeddedStructFile = '';
+
+                if (fieldType.startsWith('model.')) {
+                    embeddedStructFile = path.join(modelDir, `${embeddedStructName.toLowerCase()}.go`);
+                } else if (fieldType.startsWith('req.')) {
+                    embeddedStructFile = structFilePath; // 如果是 req 包，使用同一个文件
+                }
+
+                // 解析嵌入的结构体
+                if (await fs.pathExists(embeddedStructFile)) {
+                    const embeddedFields = await parseStructFields(embeddedStructFile, embeddedStructName, modelDir);
+                    fields.push(...embeddedFields);
+                } else {
+                    console.warn(chalk.yellow(`Embedded struct file not found: ${embeddedStructFile}`));
+                }
+            }
+        }
+        return fields;
+    } catch (error) {
+        console.error(chalk.red(`Failed to parse struct file: ${structFilePath}`), error);
+        return [];
+    }
+};
+
+/**
+ * 解析 controller.go 获取方法中的参数
+ */
+const extractParamsFromController = async (controllerContent, reqDir, modelDir) => {
+    const functionParams = {};
+    // 正则表达式匹配处理函数
+    const functionRegex = /func\s+(\w+)\s*\(ctx\s+\*gin\.Context\)\s*{([\s\S]*?)^}/gm;
+    let funcMatch;
+    while ((funcMatch = functionRegex.exec(controllerContent)) !== null) {
+        const functionName = funcMatch[1];
+        const functionBody = funcMatch[2];
+
+        const params = [];
+        let usesGetPageReq = false;
+
+        // 建立变量名到类型的映射
+        const varTypeMap = {};
+        const varRegex = /(?:var\s+)?(\w+)\s*(?:[:=])=\s*(?:&)?([\w\.]+)\s*(?:\{\})?/g;
+        let varMatch;
+        while ((varMatch = varRegex.exec(functionBody)) !== null) {
+            const varName = varMatch[1];
+            const varType = varMatch[2];
+            varTypeMap[varName] = varType;
+        }
+
+        // 检查是否有 apix.GetPageReq 调用
+        if (/apix\.GetPageReq\(/.test(functionBody)) {
+            usesGetPageReq = true;
+        }
+
+        // 正则表达式匹配 apix.GetParamX 调用
+        const paramRegex = /(\w+),\s*e\s*:=\s*apix\.GetParam(\w+)\s*\(\s*ctx\s*,\s*"([^"]+)"(?:\s*,\s*(apix\.\w+|true|false))?\s*\)/g;
+        let paramMatch;
+        while ((paramMatch = paramRegex.exec(functionBody)) !== null) {
+            const paramName = paramMatch[1];       // 变量名，例如: id
+            const paramTypeFunc = paramMatch[2];   // 类型函数，例如: Int64, Str
+            const paramKey = paramMatch[3];        // 参数键，例如: "id"
+            const paramForce = paramMatch[4];      // 可选的强制参数，例如: apix.Force, true
+
+            // 确定是否必填
+            let required = false;
+            if (paramForce) {
+                if (paramForce === 'apix.Force' || paramForce === 'true') {
+                    required = true;
+                }
+            }
+
+            // 映射 Go 类型到 OpenAPI 类型
+            let schemaType = 'string';
+            switch (paramTypeFunc.toLowerCase()) {
+                case 'int':
+                case 'int32':
+                case 'int64':
+                    schemaType = 'integer';
+                    break;
+                case 'bool':
+                    schemaType = 'boolean';
+                    break;
+                case 'float32':
+                case 'float64':
+                    schemaType = 'number';
+                    break;
+                default:
+                    schemaType = 'string';
+            }
+
+            const paramObject = {
+                name: paramKey,
+                in: 'query', // 默认设置为 query
+                required: required,
+                schema: { type: schemaType }
+            };
+
+            params.push(paramObject);
+        }
+
+        // 处理通过 apix.BindParams 绑定的参数
+        const bindParamsRegex = /e\s*:=\s*apix\.BindParams\s*\(\s*ctx\s*,\s*&?(\w+)\s*\)/g;
+        let bindMatch;
+        while ((bindMatch = bindParamsRegex.exec(functionBody)) !== null) {
+            const varName = bindMatch[1];
+            const fullType = varTypeMap[varName] || varName; // 获取变量的类型，若未声明则使用变量名
+
+            let bindStructName = fullType;
+
+            // 如果类型包含包名，例如 req.UserReq
+            if (fullType.includes('.')) {
+                bindStructName = fullType.split('.')[1];
+            }
+
+            params.push({
+                bindStructName: bindStructName
+            });
+        }
+
+        // 将是否使用分页的标记添加到参数中
+        if (usesGetPageReq) {
+            params.push({ usesGetPageReq: true });
+        }
+
+        functionParams[functionName] = params;
+    }
+    return functionParams;
+};
+
+/**
+ * 解析模型定义
+ */
+const extractModelFields = async (modelFilePath) => {
+    try {
+        const modelContent = await fs.readFile(modelFilePath, 'utf-8');
+        const fields = [];
+        const modelRegex = /type\s+(\w+)\s+struct\s*{([\s\S]*?)^}/gm;
+        let match;
+        while ((match = modelRegex.exec(modelContent)) !== null) {
+            const modelName = match[1];
+            const modelFields = [];
+            const fieldsContent = match[2];
+            const fieldRegex = /\s*(\w+)\s+([\w\.\*\[\]]+)\s+`[^`]*?(?:json|form):"([^"]+)"[^`]*`/g;
+            let fieldMatch;
+            while ((fieldMatch = fieldRegex.exec(fieldsContent)) !== null) {
+                const fieldName = fieldMatch[1];
+                const fieldType = fieldMatch[2];
+                const tagName = fieldMatch[3];
+                modelFields.push({
+                    field: fieldName,
+                    type: fieldType,
+                    json: tagName
+                });
+            }
+            fields.push({ modelName, modelFields });
+        }
+        return fields;
+    } catch (error) {
+        console.error(chalk.red(`Failed to parse model file: ${modelFilePath}`), error);
+        return [];
+    }
+};
+
+/**
+ * 获取版本号并递增
+ */
+const getNextVersion = (existingVersion) => {
+    if (!existingVersion) return "1.0.0"; // 默认版本号
+
+    const nextVersion = semver.inc(existingVersion, 'patch');  // 按照补丁版本递增
+    return nextVersion || "1.0.0";
+};
+
+/**
+ * 生成或更新 redoc.html
+ * @param {string} docDir - 目标项目的 doc 目录路径
+ * @param {string} templatePath - redoc_template.html 的路径
+ */
+const generateRedocHtml = async (docDir, templatePath) => {
+    try {
+        // 读取模板文件
+        const redocTemplate = await fs.readFile(templatePath, 'utf-8');
+
+        // 获取 doc 文件夹下所有 JSON 文件（不包�� redoc.html）
+        const jsonFiles = await fs.readdir(docDir);
+        const openApiJsonFiles = jsonFiles.filter(file => file.endsWith('.json'));
+
+        // 生成 API_OPTIONS
+        const apiOptions = openApiJsonFiles.map(file => {
+            const apiName = path.basename(file, '.json');
+            return `<option value="./${file}">${apiName}</option>`;
+        }).join('\n');
+
+        // 替换模板中的 {{API_OPTIONS}} 占位符
+        const redocHtmlContent = redocTemplate.replace('{{API_OPTIONS}}', apiOptions);
+
+        // 写入 redoc.html 到 doc 文件夹
+        const redocHtmlPath = path.join(docDir, 'redoc.html');
+        await fs.writeFile(redocHtmlPath, redocHtmlContent, 'utf-8');
+        console.log(chalk.green(`ReDoc page generated or updated: doc/redoc.html`));
+    } catch (error) {
+        console.error(chalk.red('Error generating ReDoc page:'), chalk.redBright(error.message));
+    }
+};
+
+/**
+ * 启动 http-server 以预览文档
+ * 仅显示 'Available on:' 和 'Hit CTRL-C to stop the server' 部分
+ * 将控制台提示改为英文
+ * @param {string} docDir - 目标项目的 doc 目录路径
+ */
+const startHttpServer = (docDir) => {  // 添加 docDir 参数
+    const server = spawn('http-server', ['-p', '8080', docDir], { shell: true });
+
+    // 监听 stdout 数据
+    server.stdout.on('data', (data) => {
+        const output = data.toString();
+        const lines = output.split('\n');
+        lines.forEach(line => {
+            const trimmedLine = line.trim();
+            if (trimmedLine === 'Available on:' || trimmedLine === 'Hit CTRL-C to stop the server') {
+                console.log(line);
+                return;
+            }
+            if (trimmedLine.startsWith('http://') || trimmedLine.startsWith('https://')) {
+                console.log(`  ${trimmedLine}/redoc.html`); // 指向 redoc.html
+            }
+        });
+    });
+
+    // 监听 stderr 数据并过滤掉特定的 Deprecation Warning
+    server.stderr.on('data', (data) => {
+        const errorOutput = data.toString();
+        if (!errorOutput.includes('DEP0066')) {
+            console.error(chalk.red('http-server error:'), chalk.redBright(errorOutput));
+        }
+    });
+
+    // 监听错误事件
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(chalk.red(`Port 8080 is already in use. Please use another port.`));
+        } else {
+            console.error(chalk.red('Error starting http-server:'), chalk.redBright(err.message));
+        }
+    });
+
+    // 监听关闭事件
+    server.on('close', (code) => {
+        if (code !== 0) {
+            console.error(chalk.red(`http-server process exited with code ${code}`));
+        }
+    });
+};
+
+/**
+ * 生成 OpenAPI 文档
+ * @param {string|null} moduleName - 指定的模块名
+ */
+const generateOpenAPIDocs = async (moduleName = null) => {
+    try {
+        const cliDir = path.resolve(__dirname, '..'); // 指向 CLI 项目的根目录
+        const templatesDir = path.join(cliDir, 'templates');
+        const redocTemplatePath = path.join(templatesDir, 'redoc_template.html');
+
+        // 确保模板文件存在
+        if (!(await fs.pathExists(redocTemplatePath))) {
+            console.error(chalk.red(`Template file missing: ${redocTemplatePath}`));
+            return;
+        }
+
+        const domainDir = path.join(process.cwd(), 'domain');
+        const docDir = path.join(process.cwd(), 'doc');
+
+        // 确保 doc 目录存在
+        await fs.ensureDir(docDir);
+
+        // 读取并解析 _bin/local.yaml 获取 API 服务器地址
+        let serverUrl = 'http://localhost:8080'; // 默认值
+        const binDir = path.join(process.cwd(), '_bin');
+        const localYamlPath = path.join(binDir, 'local.yaml');
+
+        if (await fs.pathExists(localYamlPath)) {
+            try {
+                const yamlContent = await fs.readFile(localYamlPath, 'utf-8');
+                const config = yaml.load(yamlContent);
+                const addr = config?.api?.rest?.addr;
+                if (addr) {
+                    // addr 例如:9527
+                    let host = 'localhost';
+                    let port = '8080';
+                    const addrMatch = addr.match(/(.*):(\d+)/);
+                    if (addrMatch) {
+                        if (addrMatch[1]) {
+                            host = addrMatch[1];
+                        }
+                        port = addrMatch[2];
+                    }
+                    serverUrl = `http://${host}:${port}`;
+                }
+            } catch (error) {
+                console.error(chalk.red(`Failed to parse YAML file: ${localYamlPath}`), error);
+                console.warn(chalk.yellow('Using default server URL: http://localhost:8080'));
+            }
+        } else {
+            console.warn(chalk.yellow(`YAML configuration file not found: ${localYamlPath}`));
+            console.warn(chalk.yellow('Using default server URL: http://localhost:8080'));
+        }
+
+        // 扫描所有模块
+        const moduleDirs = moduleName ? [moduleName] : await fs.readdir(domainDir);
+
+        // 过滤出目录
+        const modulesToProcess = [];
+        for (const module of moduleDirs) {
+            const modulePath = path.join(domainDir, module);
+            if (await fs.pathExists(modulePath) && (await fs.lstat(modulePath)).isDirectory()) {
+                modulesToProcess.push(module);
+            }
+        }
+
+        for (const module of modulesToProcess) {
+            const modulePath = path.join(domainDir, module);
+            const routerFilePath = path.join(modulePath, 'api/router.go');
+            const controllerFilePath = path.join(modulePath, 'api/controller.go');
+            const modelFilePath = path.join(modulePath, 'model', `${module}.go`);
+            const reqFilePath = path.join(modulePath, 'api', 'req', 'req.go');
+
+            // 检查文件是否存在
+            if (!(await fs.pathExists(routerFilePath)) || !(await fs.pathExists(controllerFilePath)) || !(await fs.pathExists(modelFilePath)) || !(await fs.pathExists(reqFilePath))) {
+                console.warn(chalk.yellow(`Module "${module}" is missing required files, skipping...`));
+                continue;
+            }
+
+            // 扫描 router.go 获取路由信息
+            const routes = await scanRouterFile(routerFilePath);
+            // console.log(`Scanned routes for module "${module}":`, routes);
+
+            // 扫描 controller.go 获取方法参数
+            const controllerContent = await fs.readFile(controllerFilePath, 'utf-8');
+            const controllerParams = await extractParamsFromController(controllerContent, path.dirname(reqFilePath), path.dirname(modelFilePath));
+            // console.log(`Extracted controller parameters for module "${module}":`, controllerParams);
+
+            // 扫描 model.go 和 req.go 获取字段
+            const modelFields = await extractModelFields(modelFilePath);
+            const reqFields = await extractModelFields(reqFilePath);
+            const allFields = [...modelFields, ...reqFields];
+
+            // 生成 OpenAPI 格式文档
+            const openAPIDoc = {
+                openapi: "3.0.0",
+                info: {
+                    title: `${module} API`,
+                    version: "1.0.0", // 默认版本号，稍后会递增
+                    description: `${module} api doc, generated by gorig-cli
+                    \n last updated: ${formatDate(new Date())}`, // 添加描述信息
+                },
+                servers: [
+                    {
+                        url: serverUrl, // 使用从 YAML 获取的 serverUrl
+                        description: "API Server"
+                    }
+                ],
+                paths: {},
+                components: {
+                    schemas: {},
+                },
+            };
+
+            // 检查是否存在现有文档文件，读取并递增版本号
+            const existingDocPath = path.join(docDir, `${module}.json`);
+            if (await fs.pathExists(existingDocPath)) {
+                const existingDoc = await fs.readJson(existingDocPath);
+                openAPIDoc.info.version = getNextVersion(existingDoc.info.version);
+                // 复用 schemas
+                if (existingDoc.components && existingDoc.components.schemas) {
+                    openAPIDoc.components.schemas = existingDoc.components.schemas;
+                }
+            }
+
+            // 添加所有结构体定义到 components.schemas
+            allFields.forEach(model => {
+                const properties = {};
+                model.modelFields.forEach(field => {
+                    let fieldType = 'string';  // 默认类型
+                    const lowerType = field.type.toLowerCase();
+                    if (lowerType.includes('int')) {
+                        fieldType = 'integer';
+                    } else if (lowerType.includes('bool')) {
+                        fieldType = 'boolean';
+                    } else if (lowerType.includes('float')) {
+                        fieldType = 'number';
+                    } else if (lowerType.startsWith('[]')) {
+                        fieldType = 'array';
+                    }
+
+                    if (fieldType === 'array') {
+                        // 假设数组元素类型为 string，实际应根据具体类型调整
+                        properties[field.json] = {
+                            type: 'array',
+                            items: { type: 'string' }
+                        };
+                    } else {
+                        properties[field.json] = { type: fieldType };
+                    }
+                });
+                openAPIDoc.components.schemas[model.modelName] = {
+                    type: 'object',
+                    properties,
+                };
+            });
+
+            // 手动合并嵌套结构体字段到 UserReq
+            if (openAPIDoc.components.schemas['UserReq'] && openAPIDoc.components.schemas['UserD']) {
+                const userReqProperties = openAPIDoc.components.schemas['UserReq'].properties;
+                const userDProperties = openAPIDoc.components.schemas['UserD'].properties;
+
+                // 合并 UserD 的字段到 UserReq
+                openAPIDoc.components.schemas['UserReq'].properties = {
+                    ...userReqProperties,
+                    ...userDProperties
+                };
+
+                // 如果不需要独立定义 UserD，可以删除它
+                // delete openAPIDoc.components.schemas['UserD'];
+            }
+
+            // 替换 'filter' schema reference with 'UserReq'
+            for (const [handler, params] of Object.entries(controllerParams)) {
+                for (const param of params) {
+                    if (param.bindStructName === 'filter') {
+                        param.bindStructName = 'UserReq';
+                    }
+                }
+            }
+
+            // 生成完整路径并修复嵌套结构问题
+            for (const route of routes) {
+                const basePath = `/${module}`;  // 从 groupRouter.Group("user") 获取
+                const fullPath = `${basePath}/${route.path}`.replace(/\/+/g, '/');  // 确保路径格式正确
+                const pathParamsList = route.pathParams; // 从路由中获取 path 参数列表
+
+                // 获取对应处理函数的参数
+                const funcParams = controllerParams[route.handler] || [];
+
+                let parameters = [];
+                let requestBody = undefined;
+                let usesGetPageReq = false;
+
+                // 分离参数和 requestBody
+                for (const param of funcParams) {
+                    if (param.usesGetPageReq) {
+                        usesGetPageReq = true;
+                    } else if (param.bindStructName) {
+                        // 处理绑定的结构体，作为 requestBody 或 query 参数
+                        if (['POST', 'PUT'].includes(route.method.toUpperCase())) {
+                            // POST 和 PUT 请求使用 requestBody
+                            requestBody = {
+                                required: true,
+                                content: {
+                                    'application/json': {
+                                        schema: {
+                                            $ref: `#/components/schemas/${param.bindStructName}`,
+                                        },
+                                    },
+                                },
+                            };
+                        } else if (['GET', 'DELETE'].includes(route.method.toUpperCase())) {
+                            // GET 和 DELETE 请求使用 query 参数
+                            const schema = openAPIDoc.components.schemas[param.bindStructName];
+                            if (schema && schema.properties) {
+                                for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+                                    parameters.push({
+                                        name: fieldName,
+                                        in: 'query',
+                                        required: false, // 根据实际情况调整
+                                        schema: fieldSchema
+                                    });
+                                }
+                            } else {
+                                console.warn(chalk.yellow(`Function "${route.handler}" has undefined bindStructName "${param.bindStructName}"`));
+                            }
+                        }
+                    } else {
+                        // 确定参数位置
+                        if (pathParamsList.includes(param.name)) {
+                            param.in = 'path';
+                        } else {
+                            param.in = 'query';
+                        }
+                        parameters.push(param);
+                    }
+                }
+
+                // 如果函数中使用了 apix.GetPageReq，则添加分页参数
+                if (usesGetPageReq) {
+                    parameters = parameters.concat([
+                        { name: "page", in: "query", required: false, schema: { type: "integer" } },
+                        { name: "size", in: "query", required: false, schema: { type: "integer" } },
+                        { name: "lastID", in: "query", required: false, schema: { type: "integer" } },
+                    ]);
+                }
+
+                // 去重参数
+                const uniqueParameters = [];
+                const paramNames = new Set();
+                parameters.forEach(param => {
+                    if (!paramNames.has(param.name)) {
+                        paramNames.add(param.name);
+                        uniqueParameters.push(param);
+                    }
+                });
+
+                // 定义响应
+                const responses = {
+                    '200': {
+                        description: 'Success',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {} // 可以根据需要进一步完善响应体
+                                },
+                            },
+                        },
+                    },
+                };
+
+                // 如果有 requestBody，添加到 operation
+                const operation = {
+                    summary: route.handler,
+                    parameters: uniqueParameters.length > 0 ? uniqueParameters : undefined,
+                    responses,
+                };
+
+                if (requestBody) {
+                    operation.requestBody = requestBody;
+                }
+
+                // 初始化路径对象
+                if (!openAPIDoc.paths[fullPath]) {
+                    openAPIDoc.paths[fullPath] = {};
+                }
+
+                openAPIDoc.paths[fullPath][route.method.toLowerCase()] = operation;
+            }
+
+            // 写入 OpenAPI JSON 文件
+            await fs.writeJson(existingDocPath, openAPIDoc, { spaces: 2 });
+            console.log(chalk.green(`OpenAPI documentation generated: doc/${path.basename(existingDocPath)}`));
+        }
+
+        // 生成或更新 redoc.html 一次
+        await generateRedocHtml(docDir, redocTemplatePath);
+
+        // 启动 http-server 以预览文档
+        startHttpServer(docDir);
+    } catch (error) {
+        console.error(chalk.red('Error generating API documentation:'), chalk.redBright(error.message));
+    }
+};
+
+/**
+ * 处理命令行输入
+ */
+const docCommand = async () => {
+    const program = new Command();
+
+    program
+        .command('doc')
+        .description('Generate API documentation')
+        .argument('[moduleName]', 'Module name. If specified, only generate documentation for that module.')
+        .action(async (moduleName) => {
+            await generateOpenAPIDocs(moduleName);
+        });
+
+    program.parse(process.argv);
+};
+
+// 默认导出一个函数
+export default docCommand;

package/commands/init.js

@@ -15,7 +15,7 @@ const checkGoEnvironment = () => {
   return new Promise((resolve, reject) => {
     exec('go version', (error, stdout, stderr) => {
       if (error) {
-        reject(new Error('未检测到 Go 环境，请先安装 Go 语言环境，访问 https://golang.org/dl/ 进行安装。'));
+        reject(new Error('Go environment not detected, please install Go language environment first, visit https://golang.org/dl/ for installation.'));
       } else {
         resolve(stdout);
       }
@@ -28,7 +28,7 @@ const addGorigDependency = (projectDir) => {
   return new Promise((resolve, reject) => {
     exec('go get github.com/jom-io/gorig@latest', { cwd: projectDir }, (error, stdout, stderr) => {
       if (error) {
-        reject(new Error(`无法添加 gorig 依赖: ${stderr}`));
+        reject(new Error(`Failed to add gorig dependency: ${stderr}`));
       } else {
         resolve(stdout);
       }
@@ -41,7 +41,7 @@ const runGoModTidy = (projectDir) => {
   return new Promise((resolve, reject) => {
     exec('go mod tidy', { cwd: projectDir }, (error, stdout, stderr) => {
       if (error) {
-        reject(new Error(`运行 go mod tidy 失败: ${stderr}`));
+        reject(new Error(`Failed to run go mod tidy: ${stderr}`));
       } else {
         resolve(stdout);
       }
@@ -57,7 +57,7 @@ const askOverwriteConfirmation = (projectDir) => {
       output: process.stdout
     });
     rl.question(
-      chalk.yellow(`目录 ${chalk.bold(projectDir)} 已经存在，是否覆盖？（y/N）: `),
+      chalk.yellow(`Directory ${chalk.bold(projectDir)} already exists, do you want to overwrite? (y/N): `),
       (answer) => {
         rl.close();
         if (answer.toLowerCase() === 'y') {
@@ -73,7 +73,7 @@ const askOverwriteConfirmation = (projectDir) => {
 // 初始化项目的主函数
 const initModule = async (args) => {
   if (args.length < 1) {
-    console.error(chalk.yellow('请使用正确的命令格式: npx <你的包名> init <项目名>'));
+    console.error(chalk.yellow('Please use the correct command format: npx <your package name> init <project name>'));
     process.exit(1);
   }
 
@@ -85,22 +85,22 @@ const initModule = async (args) => {
   // 定义需要创建的子目录
   const subDirs = ['_bin', '_cmd', 'domain', 'global', 'cron'];
 
-  console.log(chalk.blue(`\n开始初始化项目: ${chalk.bold(projectName)}`));
+  console.log(chalk.blue(`\nStarting project initialization: ${chalk.bold(projectName)}`));
 
   try {
     // 检查本地是否存在 Go 环境
     await checkGoEnvironment();
-    console.log(chalk.green('检测到 Go 环境，继续进行项目初始化...'));
+    console.log(chalk.green('Go environment detected, continuing project initialization...'));
 
     // 检查项目目录是否已存在
     if (await fs.pathExists(projectDir)) {
       const shouldOverwrite = await askOverwriteConfirmation(projectDir);
       if (!shouldOverwrite) {
-        console.log(chalk.red('项目初始化已取消。'));
+        console.log(chalk.red('Project initialization has been canceled.'));
         process.exit(0);
       } else {
         await fs.remove(projectDir);  // 删除已有的目录
-        console.log(chalk.yellow(`已删除现有目录: ${chalk.bold(projectDir)}`));
+        console.log(chalk.yellow(`Deleted existing directory: ${chalk.bold(projectDir)}`));
       }
     }
 
@@ -118,12 +118,12 @@ const initModule = async (args) => {
     const goModPath = path.join(projectDir, 'go.mod');
     const goModContent = `module ${projectName}\n\ngo 1.20\n`;
     await fs.writeFile(goModPath, goModContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('go.mod')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('go.mod')} file`));
 
     // 添加 gorig 依赖
-    console.log(chalk.blue('添加 gorig 依赖中，请稍候...'));
+    console.log(chalk.blue('Adding gorig dependency, please wait...'));
     await addGorigDependency(projectDir);
-    console.log(chalk.green(`成功添加 github.com/jom-io/gorig 最新版本的依赖`));
+    console.log(chalk.green(`Successfully added the latest version of github.com/jom-io/gorig dependency`));
 
     // 创建 _bin 目录下的配置文件
     const binDir = path.join(projectDir, '_bin');
@@ -138,7 +138,7 @@ const initModule = async (args) => {
         mode: env,
       });
       await fs.writeFile(configFilePath, configContent);
-      console.log(chalk.green(`成功创建 ${chalk.bold(`${env}.yaml`)} 文件`));
+      console.log(chalk.green(`Successfully created ${chalk.bold(`${env}.yaml`)} file`));
     }
 
     // 创建 domain/init.go 文件
@@ -147,7 +147,7 @@ const initModule = async (args) => {
     const initGoTemplatePath = path.join(__dirname, '../templates/init.go.ejs');
     const initGoContent = await ejs.renderFile(initGoTemplatePath, { projectNameUpper });
     await fs.writeFile(initGoPath, initGoContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('init.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('init.go')} file`));
 
     // 创建 _cmd/main.go 文件
     const cmdDir = path.join(projectDir, '_cmd');
@@ -155,7 +155,7 @@ const initModule = async (args) => {
     const mainGoTemplatePath = path.join(__dirname, '../templates/main.go.ejs');
     const mainGoContent = await ejs.renderFile(mainGoTemplatePath, { projectName });
     await fs.writeFile(mainGoPath, mainGoContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('main.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('main.go')} file`));
 
     // 创建 global/config.go 文件
     const globalDir = path.join(projectDir, 'global');
@@ -163,7 +163,7 @@ const initModule = async (args) => {
     const configGoTemplatePath = path.join(__dirname, '../templates/config.go.ejs');
     const configGoContent = await ejs.renderFile(configGoTemplatePath, { projectNameUpper });
     await fs.writeFile(configGoPath, configGoContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('config.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('config.go')} file`));
 
     // 创建 cron/cron.go 文件
     const cronDir = path.join(projectDir, 'cron');
@@ -171,23 +171,23 @@ const initModule = async (args) => {
     const cronGoTemplatePath = path.join(__dirname, '../templates/cron.go.ejs');
     const cronGoContent = await ejs.renderFile(cronGoTemplatePath, {});
     await fs.writeFile(cronGoPath, cronGoContent);
-    console.log(chalk.green(`成功创建 ${chalk.bold('cron.go')} 文件`));
+    console.log(chalk.green(`Successfully created ${chalk.bold('cron.go')} file`));
 
     // 运行 go mod tidy
-    console.log(chalk.blue('整理 Go 模块依赖中 (go mod tidy)，请稍候...'));
+    console.log(chalk.blue('Organizing Go module dependencies (go mod tidy), please wait...'));
     await runGoModTidy(projectDir);
-    console.log(chalk.green('成功整理 Go 模块依赖'));
+    console.log(chalk.green('Successfully organized Go module dependencies'));
 
     // 提示用户如何运行项目
-    console.log(chalk.blue(`\n项目 ${chalk.bold(projectName)} 已成功创建在 ${chalk.bold(projectDir)} 目录下`));
-    console.log(chalk.yellow('\n运行项目的方法:'));
-    console.log(chalk.green(`1. 进入项目目录: cd ${projectName}`));
-    console.log(chalk.green(`2. 使用 Go 命令运行项目:`));
+    console.log(chalk.blue(`\nProject ${chalk.bold(projectName)} has been successfully created in ${chalk.bold(projectDir)} directory`));
+    console.log(chalk.yellow('\nHow to run the project:'));
+    console.log(chalk.green(`1. Enter the project directory: cd ${projectName}`));
+    console.log(chalk.green(`2. Use Go command to run the project:`));
     console.log(chalk.cyan(`   go run _cmd/main.go`));
-    console.log(chalk.green(`\n或者直接编译并运行:`));
+    console.log(chalk.green(`\nOr compile and run directly:`));
     console.log(chalk.cyan(`   go build -o ${projectName} _cmd/main.go && ./${projectName}`));
   } catch (error) {
-    console.error(chalk.red('初始化项目时出错:'), chalk.redBright(error.message));
+    console.error(chalk.red('Error during project initialization:'), chalk.redBright(error.message));
   }
 };
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "gorig-cli",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "type": "module",
-  "description": "gorig构建工具",
+  "description": "gorig build tool",
   "main": "bin/cli.js",
   "bin": {
     "gorig-cli": "./bin/cli.js"
@@ -21,6 +21,9 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "ejs": "^3.1.10",
-    "fs-extra": "^11.2.0"
+    "fs-extra": "^11.2.0",
+    "http-server": "^14.1.1",
+    "js-yaml": "^4.1.0",
+    "semver": "^7.6.3"
   }
 }

package/templates/controller.go.ejs

@@ -32,12 +32,12 @@ func List<%= ModuleName %>(ctx *gin.Context) {
 
 func Save<%= ModuleName %>(ctx *gin.Context) {
 	defer apix.HandlePanic(ctx)
-	<%= ModuleName %>Req := &req.<%= ModuleName %>Req{}
-	e := apix.BindParams(ctx, <%= ModuleName %>Req)
+	<%= moduleName %>Req := &req.<%= ModuleName %>Req{}
+	e := apix.BindParams(ctx, <%= moduleName %>Req)
 	if e != nil {
 		return
 	}
-	err := gService.Save<%= ModuleName %>(ctx, <%= ModuleName %>Req)
+	err := gService.Save<%= ModuleName %>(ctx, <%= moduleName %>Req)
 	apix.HandleData(ctx, consts.CurdUpdateFailCode, nil, err)
 }
 

package/templates/model.go.ejs

@@ -1,7 +1,7 @@
 package model
 
 type <%= moduleName.charAt(0).toUpperCase() + moduleName.slice(1) %>D struct {
-    UserID   int64  `gorm:"column:user_id;type:bigint(20);comment:user_id" json:"userID"`
-    FiledStr string `gorm:"column:fieldStr;type:varchar(255);comment:fieldStr" json:"fieldStr"`
-    FieldInt int64  `gorm:"column:fieldInt;type:bigint(20);comment:fieldInt" json:"fieldInt"`
+    UserID   int64  `gorm:"column:user_id;type:bigint(20);comment:user_id" json:"userID" form:"userID"`
+    FiledStr string `gorm:"column:fieldStr;type:varchar(255);comment:fieldStr" json:"fieldStr" form:"fieldStr"`
+    FieldInt int64  `gorm:"column:fieldInt;type:bigint(20);comment:fieldInt" json:"fieldInt" form:"fieldInt"`
 }

package/templates/redoc_template.html

@@ -0,0 +1,102 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>API Documentation</title>
+    <!-- Include ReDoc CDN -->
+    <script src="https://cdn.redoc.ly/redoc/latest/bundles/redoc.standalone.js"></script>
+    <style>
+      body { 
+        margin: 0; 
+        padding: 0; 
+        font-family: Arial, sans-serif; 
+        background-color: #f9f9f9; 
+        color: #333; 
+      }
+      #header { 
+        padding: 15px; 
+        background-color: #007bff; 
+        position: fixed; 
+        top: 0; 
+        width: 100%; 
+        z-index: 1000; 
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1); 
+      }
+      #header label { 
+        color: white; 
+        font-weight: bold; 
+      }
+      #spec-selector { 
+        padding: 8px; 
+        font-size: 16px; 
+        border: none; 
+        border-radius: 4px; 
+        margin-left: 10px; 
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.2); 
+      }
+      #view-source, #go-home { 
+        margin-left: 10px; 
+        cursor: pointer; 
+        color: white; 
+        text-decoration: underline; 
+        font-weight: bold; 
+      }
+      #redoc-container { 
+        height: calc(100vh - 70px); 
+        margin-top: 70px; 
+        padding: 20px; 
+        border-radius: 8px; 
+        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1); 
+      }
+    </style>
+  </head>
+  <body>
+    <div id="header">
+      <label for="spec-selector">Select API Documentation: </label>
+      <select id="spec-selector">
+        <option value="">-- Select API --</option>
+        {{API_OPTIONS}}
+      </select>
+      <span id="view-source">View Source Data</span>
+      <span id="go-home" class="view-source">All List</span>
+    </div>
+    <div id="redoc-container">
+      <!-- ReDoc will render here -->
+    </div>
+    <script>
+      const selector = document.getElementById('spec-selector');
+      const container = document.getElementById('redoc-container');
+      const viewSource = document.getElementById('view-source');
+      const goHome = document.getElementById('go-home');
+
+      // Default select the first document
+      selector.selectedIndex = 1;
+      const defaultSpecUrl = selector.value;
+      if (defaultSpecUrl) {
+        // Render the default API documentation using ReDoc
+        Redoc.init(defaultSpecUrl, { scrollYOffset: 50 }, container);
+      }
+
+      selector.addEventListener('change', function() {
+        const specUrl = this.value;
+        if (specUrl) {
+          // Clear existing ReDoc rendering
+          container.innerHTML = '';
+          // Render the new API documentation using ReDoc
+          Redoc.init(specUrl, { scrollYOffset: 50 }, container);
+        }
+      });
+
+      viewSource.addEventListener('click', function() {
+        const specUrl = selector.value;
+        if (specUrl) {
+          // Redirect to the corresponding API source data
+          window.location.href = specUrl.replace('.json', '.json');  // Assuming source data is in JSON format
+        }
+      });
+
+      goHome.addEventListener('click', function() {
+        window.location.href = '/';
+      });
+    </script>
+  </body>
+</html>

package/templates/router.go.ejs

@@ -7,12 +7,12 @@ import (
 
 func init() {
 	httpx.RegisterRouter(func(groupRouter *gin.RouterGroup) {
-		<%= ModuleName %> := groupRouter.Group("<%= moduleName %>")
-		//<%= ModuleName %>.Use(mid.SignMP())
-		<%= ModuleName %>.GET("page", Page<%= ModuleName %>)
-		<%= ModuleName %>.GET("list", List<%= ModuleName %>)
-		<%= ModuleName %>.POST("save", Save<%= ModuleName %>)
-		<%= ModuleName %>.GET("info", Get<%= ModuleName %>)
-		<%= ModuleName %>.DELETE("delete", Delete<%= ModuleName %>)
+		<%= moduleName %> := groupRouter.Group("<%= moduleName %>")
+		//<%= moduleName %>.Use(mid.SignMP())
+		<%= moduleName %>.GET("page", Page<%= ModuleName %>)
+		<%= moduleName %>.GET("list", List<%= ModuleName %>)
+		<%= moduleName %>.POST("save", Save<%= ModuleName %>)
+		<%= moduleName %>.GET("info", Get<%= ModuleName %>)
+		<%= moduleName %>.DELETE("delete", Delete<%= ModuleName %>)
 	})
 }