gorig-cli 1.0.24 → 1.0.26

package/commands/create.js

@@ -8,6 +8,88 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+const readOptionValue = (args, index, name) => {
+  const arg = args[index];
+  const prefix = `${name}=`;
+  if (arg.startsWith(prefix)) {
+    return { value: arg.slice(prefix.length), nextIndex: index };
+  }
+  if (index + 1 >= args.length || args[index + 1].startsWith('--')) {
+    throw new Error(`Missing value for ${name}`);
+  }
+  return { value: args[index + 1], nextIndex: index + 1 };
+};
+
+const toModuleName = (moduleName) => moduleName
+  .split('_')
+  .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+  .join('');
+
+export const parseCreateArgs = (args) => {
+  if (args.length < 1) {
+    throw new Error('Please use the correct command format: gorig-cli create <module name>');
+  }
+
+  const moduleName = args[0];
+  if (!/^[a-z][a-z0-9_]*$/.test(moduleName)) {
+    throw new Error('Module name must use lower snake_case, for example: user or supply_order');
+  }
+
+  const options = {
+    moduleName,
+    ModuleName: toModuleName(moduleName),
+    crud: false,
+    db: '',
+    dbName: '',
+    http: true,
+  };
+
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--crud') {
+      options.crud = true;
+      continue;
+    }
+    if (arg === '--no-http') {
+      options.http = false;
+      continue;
+    }
+
+    const valueOptions = ['--db', '--database', '--store', '--db-name'];
+    const optionName = valueOptions.find((name) => arg === name || arg.startsWith(`${name}=`));
+    if (!optionName) {
+      throw new Error(`Unknown create option: ${arg}`);
+    }
+
+    const { value, nextIndex } = readOptionValue(args, i, optionName);
+    i = nextIndex;
+
+    if (['--db', '--database', '--store'].includes(optionName)) {
+      options.crud = true;
+      options.db = value.toLowerCase();
+    } else if (optionName === '--db-name') {
+      options.dbName = value;
+    }
+  }
+
+  if (options.crud) {
+    if (!['mysql', 'mongo', 'mongodb'].includes(options.db)) {
+      throw new Error('Persistent CRUD modules require --db mysql or --db mongo');
+    }
+    if (options.db === 'mongodb') {
+      options.db = 'mongo';
+    }
+    if (!options.dbName) {
+      options.dbName = options.db === 'mysql' ? 'Main' : 'main';
+    }
+    if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(options.dbName)) {
+      throw new Error('Database connection name must start with a letter and contain only letters, numbers, or underscores');
+    }
+  }
+
+  return options;
+};
+
 // Get the module name from the go.mod file
 const getGoModModuleName = async () => {
   try {
@@ -25,135 +107,208 @@ const getGoModModuleName = async () => {
   }
 };
 
-// Create module main function
-const createModule = async (args) => {
-  if (args.length < 1) {
-    console.error(chalk.yellow('Please use the correct command format: npx <your package name> create <module name>'));
-    process.exit(1);
+const renderTemplate = async (templateName, destination, data) => {
+  const templatePath = path.join(__dirname, '../templates', templateName);
+  const content = await ejs.renderFile(templatePath, data);
+  await fs.ensureDir(path.dirname(destination));
+  await fs.writeFile(destination, content);
+};
+
+const renderTemplateContent = async (templateName, data) => {
+  const templatePath = path.join(__dirname, '../templates', templateName);
+  return ejs.renderFile(templatePath, data);
+};
+
+const insertYamlConnection = (content, topKey, connectionName, connectionBlock) => {
+  const normalized = content.endsWith('\n') ? content : `${content}\n`;
+  const lines = normalized.split('\n');
+  const topIndex = lines.findIndex((line) => line === `${topKey}:`);
+
+  if (topIndex < 0) {
+    return `${normalized.trimEnd()}\n\n${topKey}:\n${connectionBlock.trimEnd()}\n`;
   }
 
-  const moduleName = args[0];
-  const ModuleName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+  let endIndex = lines.length - 1;
+  for (let i = topIndex + 1; i < lines.length; i += 1) {
+    if (/^[A-Za-z0-9_.-]+\s*:/.test(lines[i])) {
+      endIndex = i;
+      break;
+    }
+  }
 
-  // Get the current working directory, which is the directory where the command is executed
-  const currentDir = process.cwd();
+  const connectionPattern = new RegExp(`^  ${connectionName}:\\s*$`);
+  if (lines.slice(topIndex + 1, endIndex).some((line) => connectionPattern.test(line))) {
+    return content;
+  }
 
-  // Build the paths for the domain directory and module directory
-  const domainDir = path.join(currentDir, 'domain');
-  const moduleDir = path.join(domainDir, moduleName);
+  lines.splice(endIndex, 0, ...connectionBlock.trimEnd().split('\n'));
+  return `${lines.join('\n').trimEnd()}\n`;
+};
 
-  // Define the subdirectories to be created
-  const subDirs = ['api', 'model', 'internal', 'api/req'];
+const ensureCrudConfig = async (projectDir, data) => {
+  const topKey = data.db === 'mysql' ? 'Mysql' : 'mongo';
+  const templateName = data.db === 'mysql'
+    ? 'crud.mysql.config.yaml.ejs'
+    : 'crud.mongo.config.yaml.ejs';
+  const connectionBlock = await renderTemplateContent(templateName, data);
+  const configPaths = [
+    '_bin/local.yaml',
+    '_bin/dev.yaml',
+    '_bin/prod.yaml',
+    'test/_bin/local.yaml',
+  ];
 
-  console.log(chalk.blue(`\nStarting to create module: ${chalk.bold(moduleName)}`));
+  for (const relativePath of configPaths) {
+    const configPath = path.join(projectDir, relativePath);
+    if (!await fs.pathExists(configPath)) {
+      console.log(chalk.yellow(`Could not find ${relativePath}, skipping database configuration`));
+      continue;
+    }
 
-  try {
-    const projectName = await getGoModModuleName();
+    const original = await fs.readFile(configPath, 'utf8');
+    const updated = insertYamlConnection(original, topKey, data.dbName, connectionBlock);
+    if (updated !== original) {
+      await fs.writeFile(configPath, updated);
+      console.log(chalk.green(`Successfully updated ${chalk.bold(relativePath)} database configuration`));
+    }
+  }
+};
 
-    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);
-
-    // 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(`Successfully created ${chalk.bold('model.go')} file`));
-
-    // 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(`Successfully created ${chalk.bold('req.go')} file`));
-
-    // 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(`Successfully created ${chalk.bold('resp.go')} file`));
-
-    // 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(`Successfully created ${chalk.bold('internal.go')} file`));
-
-    // 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(`Successfully created ${chalk.bold('service.pub.go')} file`));
-
-    // 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(`Successfully created ${chalk.bold('service.go')} file`));
-
-    // 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);
+const updateDomainInit = async (domainDir, projectName, moduleName) => {
+  const initFilePath = path.join(domainDir, 'init.go');
+  if (!await fs.pathExists(initFilePath)) {
+    console.log(chalk.yellow(`Could not find ${chalk.bold('init.go')} file, skipping import statement addition`));
+    return;
+  }
+
+  let initFileContent = await fs.readFile(initFilePath, 'utf-8');
+  const importStatement = `import _ "${projectName}/domain/${moduleName}"`;
+
+  if (initFileContent.includes(importStatement)) {
+    console.log(chalk.yellow('The corresponding import statement already exists in init.go, no need to add it again'));
+    return;
+  }
+
+  const packageMatch = initFileContent.match(/^package\s+\w+\s*$/m);
+  if (!packageMatch) {
+    console.log(chalk.yellow('package declaration not found, skipping import statement addition'));
+    return;
+  }
+
+  const insertPosition = packageMatch.index + packageMatch[0].length;
+  const rest = initFileContent.slice(insertPosition).trimStart();
+  initFileContent =
+    `${initFileContent.slice(0, insertPosition).trimEnd()}\n\n` +
+    `${importStatement}\n` +
+    (rest ? `\n${rest}` : '');
+
+  await fs.writeFile(initFilePath, initFileContent);
+  console.log(chalk.green(`Successfully updated ${chalk.bold('init.go')} file, added import statement`));
+};
+
+const createSimpleModule = async (moduleDir, data) => {
+  const { moduleName } = data;
+
+  await renderTemplate('model.go.ejs', path.join(moduleDir, 'model', `${moduleName}.go`), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('model.go')} file`));
+
+  await renderTemplate('dto.go.ejs', path.join(moduleDir, 'dto.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('dto.go')} file`));
+
+  await renderTemplate('service.go.ejs', path.join(moduleDir, 'service.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('service.go')} file`));
+
+  await renderTemplate('controller.go.ejs', path.join(moduleDir, 'controller.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('controller.go')} file`));
+
+  await renderTemplate('router.go.ejs', path.join(moduleDir, 'router.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('router.go')} file`));
+};
+
+const createCrudModule = async (moduleDir, projectDir, data, options) => {
+  const { moduleName } = data;
+  const crudData = {
+    ...data,
+    ...options,
+    dbTitle: options.db === 'mysql' ? 'MySQL' : 'MongoDB',
+    dbEnvName: options.dbName.replace(/[^A-Za-z0-9]/g, '_').toUpperCase(),
+    dbSchema: path.basename(projectDir).replace(/[^a-z0-9]/gi, '_').toLowerCase(),
+  };
+
+  await ensureCrudConfig(projectDir, crudData);
+
+  await renderTemplate('crud.model.go.ejs', path.join(moduleDir, 'model', `${moduleName}.go`), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('model.go')} file`));
+
+  await renderTemplate('crud.dto.go.ejs', path.join(moduleDir, 'dto.go'), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('dto.go')} file`));
+
+  await renderTemplate('crud.service.go.ejs', path.join(moduleDir, 'service.go'), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('service.go')} file`));
+
+  await renderTemplate('crud.module.README.md.ejs', path.join(moduleDir, 'README.md'), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('README.md')} file`));
+
+  await renderTemplate('crud.test.go.ejs', path.join(projectDir, 'test', `${moduleName}_test.go`), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('test file')} file`));
+
+  const integrationInitPath = path.join(projectDir, 'test', `init_${options.db}_integration_test.go`);
+  if (!await fs.pathExists(integrationInitPath)) {
+    await renderTemplate('crud.integration.init_test.go.ejs', integrationInitPath, crudData);
+    console.log(chalk.green(`Successfully created ${chalk.bold('database integration init file')} file`));
+  }
+
+  await renderTemplate(
+    'crud.integration_test.go.ejs',
+    path.join(projectDir, 'test', `${moduleName}_integration_test.go`),
+    crudData,
+  );
+  console.log(chalk.green(`Successfully created ${chalk.bold('database integration test file')} file`));
+
+  if (options.http) {
+    await renderTemplate('crud.controller.go.ejs', path.join(moduleDir, 'controller.go'), crudData);
     console.log(chalk.green(`Successfully created ${chalk.bold('controller.go')} file`));
 
-    // 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);
+    await renderTemplate('crud.router.go.ejs', path.join(moduleDir, 'router.go'), crudData);
     console.log(chalk.green(`Successfully created ${chalk.bold('router.go')} file`));
 
-    // 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) {
-          // Find init function, ensure import statement is added above init function
-          const insertPosition = initFuncIndex;
-          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(`Successfully updated ${chalk.bold('init.go')} file, added import statement`));
-        } else {
-          console.log(chalk.yellow(`init() function not found, skipping import statement addition`));
-        }
-      } else {
-        console.log(chalk.yellow(`The corresponding import statement already exists in init.go, no need to add it again`));
-      }
+    await renderTemplate('crud.doc.md.ejs', path.join(projectDir, 'doc', `${moduleName}.md`), crudData);
+    console.log(chalk.green(`Successfully created ${chalk.bold('doc file')} file`));
+  }
+};
+
+// Create module main function
+const createModule = async (args) => {
+  try {
+    const options = parseCreateArgs(args);
+    const { moduleName, ModuleName } = options;
+    const currentDir = process.cwd();
+    const domainDir = path.join(currentDir, 'domain');
+    const moduleDir = path.join(domainDir, moduleName);
+
+    console.log(chalk.blue(`\nStarting to create module: ${chalk.bold(moduleName)}`));
+
+    const projectName = await getGoModModuleName();
+    const data = { moduleName, ModuleName, projectName };
+
+    await fs.ensureDir(domainDir);
+    await fs.ensureDir(path.join(moduleDir, 'model'));
+
+    if (options.crud) {
+      await createCrudModule(moduleDir, currentDir, data, options);
     } else {
-      console.log(chalk.yellow(`Could not find ${chalk.bold('init.go')} file, skipping import statement addition`));
+      await createSimpleModule(moduleDir, data);
+    }
+
+    if (!options.crud || options.http) {
+      await updateDomainInit(domainDir, projectName, moduleName);
     }
 
-    console.log(chalk.blue(`\nModule ${chalk.bold(moduleName)} has been successfully created in ${chalk.bold(`domain/${moduleName}`)} directory`));
+    const profile = options.crud ? `persistent CRUD (${options.db})` : 'basic';
+    console.log(chalk.blue(`\nModule ${chalk.bold(moduleName)} has been successfully created in ${chalk.bold(`domain/${moduleName}`)} directory [${profile}]`));
   } catch (error) {
     console.error(chalk.red('Error creating module:'), chalk.redBright(error.message));
+    process.exitCode = 1;
   }
 };
 

package/commands/doc.js

@@ -422,16 +422,27 @@ const generateOpenAPIDocs = async (moduleName = null) => {
 
         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 flatRouterFilePath = path.join(modulePath, 'router.go');
+            const flatControllerFilePath = path.join(modulePath, 'controller.go');
+            const legacyRouterFilePath = path.join(modulePath, 'api/router.go');
+            const legacyControllerFilePath = path.join(modulePath, 'api/controller.go');
+            const routerFilePath = await fs.pathExists(flatRouterFilePath) ? flatRouterFilePath : legacyRouterFilePath;
+            const controllerFilePath = await fs.pathExists(flatControllerFilePath) ? flatControllerFilePath : legacyControllerFilePath;
             const modelFilePath = path.join(modulePath, 'model', `${module}.go`);
+            const dtoFilePath = path.join(modulePath, 'dto.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))) {
+            if (!(await fs.pathExists(routerFilePath)) || !(await fs.pathExists(controllerFilePath)) || !(await fs.pathExists(modelFilePath))) {
                 console.warn(chalk.yellow(`Module "${module}" is missing required files, skipping...`));
                 continue;
             }
+            const schemaFilePaths = [modelFilePath];
+            if (await fs.pathExists(dtoFilePath)) {
+                schemaFilePaths.push(dtoFilePath);
+            } else if (await fs.pathExists(reqFilePath)) {
+                schemaFilePaths.push(reqFilePath);
+            }
 
             // 扫描 router.go 获取路由信息
             const routes = await scanRouterFile(routerFilePath);
@@ -439,13 +450,15 @@ const generateOpenAPIDocs = async (moduleName = null) => {
 
             // 扫描 controller.go 获取方法参数
             const controllerContent = await fs.readFile(controllerFilePath, 'utf-8');
-            const controllerParams = await extractParamsFromController(controllerContent, path.dirname(reqFilePath), path.dirname(modelFilePath));
+            const reqDir = await fs.pathExists(reqFilePath) ? path.dirname(reqFilePath) : modulePath;
+            const controllerParams = await extractParamsFromController(controllerContent, reqDir, 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];
+            // 扫描 model.go 和 dto.go/req.go 获取字段
+            const allFields = [];
+            for (const schemaFilePath of schemaFilePaths) {
+                allFields.push(...await extractModelFields(schemaFilePath));
+            }
 
             // 生成 OpenAPI 格式文档
             const openAPIDoc = {