gorig-cli 1.0.7 → 1.0.9

package/README.md

@@ -1,65 +1,87 @@
 # 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.
 
-### 运行项目
+### Generate API Documentation
 
-进入项目目录后，可以使用以下命令运行项目：
+Use the `doc` command to generate OpenAPI documentation:
+
+```sh
+# Generate documentation for all modules
+gorig-cli doc
+
+# Generate documentation for a specific module
+gorig-cli doc user
+```
+
+Or use npx:
+
+```sh
+npx gorig-cli@latest doc
+npx gorig-cli@latest doc user
+```
+
+After generating the documentation, you can access it through:
+http://127.0.0.1:8080/redoc.html
+
+### 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));
   }
 };