go-gin-cli 1.0.0

package/src/bin/index.js

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const prompts = require("prompts");
+const fs = require("fs");
+
+const { displayVersion } = require("../lib/utils/display");
+
+// Colors for output
+const COLORS = {
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  RED: "\x1b[31m",
+  CYAN: "\x1b[36m",
+  MAGENTA: "\x1b[35m",
+  NC: "\x1b[0m",
+};
+
+// Command-line arguments
+const args = process.argv.slice(2);
+
+// Script paths
+const scriptDir = path.join(__dirname);
+const scripts = {
+  help: path.join(scriptDir, "./../lib/utils/help.js"),
+  createResource: path.join(scriptDir, "./../lib/utils/create-resource.js"),
+  createService: path.join(scriptDir, "./../lib/utils/create-service.js"),
+  createAuth: path.join(scriptDir, "./../lib/utils/create-auth.js"),
+  addAuthToResource: path.join(
+    scriptDir,
+    "./../lib/utils/add-auth-to-resource.js",
+  ),
+  removeModule: path.join(scriptDir, "./../lib/utils/remove-module.js"),
+  setup: path.join(scriptDir, "./../lib/utils/setup.js"),
+};
+
+// Utility functions
+const utils = {
+  validateName: (name) => {
+    const isValid = /^[a-z][a-z-]*$/.test(name);
+    if (!isValid) {
+      console.error(
+        `${COLORS.RED}❌ Invalid name format: Use lowercase with hyphens (e.g., user-profile)${COLORS.NC}`
+      );
+    }
+    return isValid;
+  },
+
+  processName: (name) => ({
+    lower: name,
+    pascal: name
+      .split("-")
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+      .join(""),
+    camel: name
+      .split("-")
+      .map((part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1))
+      .join(""),
+    snake: name.replace(/-/g, "_"),
+  }),
+
+  showStructure: () => {
+    try {
+      console.log(`${COLORS.GREEN}✅ Operation completed!${COLORS.NC}`);
+      console.log(`${COLORS.YELLOW}📂 Project structure:${COLORS.NC}`);
+      const cmd =
+        process.platform === "win32"
+          ? "dir /ad"
+          : "tree -d -L 3 || find . -type d -maxdepth 3";
+      require("child_process").execSync(cmd, { stdio: "inherit", shell: true });
+    } catch (error) {
+      console.error(
+        `${COLORS.RED}❌ Structure display failed:${COLORS.NC} ${error.message}`
+      );
+    }
+  },
+
+  checkProjectExists: (name) => {
+    return fs.existsSync(path.join(process.cwd(), name));
+  },
+};
+
+async function setupProject() {
+  try {
+    while (true) {
+      const { project } = await prompts({
+        type: "text",
+        name: "project",
+        message: "Enter your project name:",
+        validate: utils.validateName,
+        hint: "Use lowercase with hyphens (e.g., my-project)",
+        onState: (state) => {
+          if (state.aborted) {
+            console.log(`${COLORS.CYAN}Exiting setup process${COLORS.NC}`);
+            console.clear();
+            process.exit(0);
+          }
+        },
+      });
+
+      if (!project) continue;
+
+      if (utils.checkProjectExists(project)) {
+        console.error(
+          `${COLORS.RED}❌ Project '${project}' already exists${COLORS.NC}`
+        );
+        continue;
+      }
+
+      // Get module name for go.mod
+      const { moduleName } = await prompts({
+        type: "text",
+        name: "moduleName",
+        message: "Enter Go module name (e.g., github.com/username/project):",
+        initial: `github.com/example/${project}`,
+        onState: (state) => {
+          if (state.aborted) {
+            console.log(`${COLORS.CYAN}Exiting setup process${COLORS.NC}`);
+            console.clear();
+            process.exit(0);
+          }
+        },
+      });
+
+      if (!moduleName) continue;
+
+      console.log(`
+  ${COLORS.CYAN}✨ Project Details ✨${COLORS.NC}
+  ├─ 📋 ${COLORS.YELLOW}Name:${COLORS.NC} ${project}
+  ├─ 📦 ${COLORS.YELLOW}Module:${COLORS.NC} ${moduleName}
+  ├─ 🚀 ${COLORS.YELLOW}Framework:${COLORS.NC} Gin-Gonic
+  └─ 💾 ${COLORS.YELLOW}Database:${COLORS.NC} PostgreSQL (GORM)
+`);
+
+      const ProjectSetup = require(scripts.setup);
+      const setup = new ProjectSetup(project, moduleName);
+      await setup.execute();
+
+      console.log(`\n🎉 Project setup complete!`);
+      console.log(`\n🚀 To get started:`);
+      console.log(`  ${COLORS.CYAN}cd ${project}${COLORS.NC}`);
+      console.log(`  ${COLORS.CYAN}go mod tidy${COLORS.NC}`);
+      console.log(`  ${COLORS.CYAN}go run src/main.go${COLORS.NC}`);
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(`${COLORS.RED}❌ Setup failed:${COLORS.NC} ${error.message}`);
+  }
+}
+
+async function generateResource() {
+  try {
+    const { name } = await prompts({
+      type: "text",
+      name: "name",
+      message: `Enter resource name:`,
+      validate: utils.validateName,
+      hint: "Use lowercase with hyphens (e.g., user-profile)",
+    });
+
+    if (!name) return;
+    const folders = getRepositoryFolders();
+    const findmodule = folders.find((folder) => folder === name);
+    if (findmodule) {
+      console.error(
+        `${COLORS.RED}❌ Resource '${name}' already exists${COLORS.NC}`
+      );
+      return;
+    }
+
+    const names = utils.processName(name);
+    const ModuleGenerator = require(scripts.createResource);
+    const generator = new ModuleGenerator(
+      names.lower,
+      names.pascal,
+      names.camel,
+      names.snake
+    );
+    await generator.execute();
+    return;
+  } catch (error) {
+    console.error(
+      `${COLORS.RED}❌ Resource setup failed:${COLORS.NC} ${error.message}`
+    );
+  }
+}
+
+async function generateService() {
+  try {
+    const ServiceGenerator = require(scripts.createService);
+    const generator = new ServiceGenerator();
+    await generator.execute();
+    return;
+  } catch (error) {
+    console.error(
+      `${COLORS.RED}❌ Service setup failed:${COLORS.NC} ${error.message}`
+    );
+  }
+}
+
+async function generateAuth() {
+  try {
+    const AuthGenerator = require(scripts.createAuth);
+    const generator = new AuthGenerator();
+    await generator.execute();
+    return;
+  } catch (error) {
+    console.error(
+      `${COLORS.RED}❌ Auth setup failed:${COLORS.NC} ${error.message}`,
+    );
+  }
+}
+
+async function addAuthToResource() {
+  try {
+    const folders = getRepositoryFolders();
+    if (folders[0].startsWith("No") || folders[0].startsWith("Error")) {
+      console.log(`${COLORS.YELLOW}${folders[0]}${COLORS.NC}`);
+      return;
+    }
+
+    // Filter out 'auth' folder since it's not a resource
+    const resourceFolders = folders.filter((f) => f !== "auth");
+    if (resourceFolders.length === 0) {
+      console.log(
+        `${COLORS.YELLOW}No resources found to add authentication${COLORS.NC}`,
+      );
+      return;
+    }
+
+    const { selectedResource } = await prompts({
+      type: "select",
+      name: "selectedResource",
+      message: "Select a resource to add authentication:",
+      choices: resourceFolders.map((folder) => ({
+        title: folder,
+        value: folder,
+      })),
+      initial: 0,
+      onState: (state) => {
+        if (state.aborted) {
+          console.log(`${COLORS.CYAN}Exiting...${COLORS.NC}`);
+          console.clear();
+          process.exit(0);
+        }
+      },
+    });
+
+    if (!selectedResource) {
+      console.log(`${COLORS.CYAN}Selection cancelled${COLORS.NC}`);
+      return;
+    }
+
+    const names = utils.processName(selectedResource);
+    const AddAuthToResource = require(scripts.addAuthToResource);
+    const generator = new AddAuthToResource(
+      names.lower,
+      names.pascal,
+      names.camel,
+    );
+    await generator.execute();
+  } catch (error) {
+    console.error(
+      `${COLORS.RED}❌ Add auth failed:${COLORS.NC} ${error.message}`,
+    );
+  }
+}
+
+// Function to List All Modules from Folder (matching NestJS structure)
+const getRepositoryFolders = () => {
+  try {
+    const repoPath = "src/infrastructure/repositories";
+    
+    if (!fs.existsSync(repoPath)) {
+      return ["No resource found"];
+    }
+
+    const folders = fs.readdirSync(repoPath, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name)
+      .filter(folder => folder !== "base");
+
+    return folders.length > 0 ? folders : ["No resource found"];
+  } catch (error) {
+    console.error(
+      `${COLORS.RED}❌ Error listing resource:${COLORS.NC} ${error.message}`
+    );
+    return ["Error listing resource"];
+  }
+};
+
+const listModules = async () => {
+  const folders = getRepositoryFolders();
+  if (folders[0].startsWith("No") || folders[0].startsWith("Error")) {
+    console.log(`${COLORS.YELLOW}${folders[0]}${COLORS.NC}`);
+    return null;
+  }
+
+  const { selectedRepo } = await prompts({
+    type: "select",
+    name: "selectedRepo",
+    message: "Select a resource to remove:",
+    choices: folders.map((folder) => ({
+      title: folder,
+      value: folder,
+    })),
+    initial: 0,
+    onState: (state) => {
+      if (state.aborted) {
+        console.log(`${COLORS.CYAN}Exiting setup process${COLORS.NC}`);
+        console.clear();
+        process.exit(0);
+      }
+    },
+  });
+  if (!selectedRepo) {
+    console.log(`${COLORS.CYAN}Selection cancelled${COLORS.NC}`);
+    return null;
+  }
+
+  return selectedRepo;
+};
+
+// Command-line mode
+async function commandLineMode() {
+  if (args[0] === "-v" || args[0] === "--version") {
+    displayVersion();
+    return;
+  }
+
+  if (args[0] === "-h" || args[0] === "--help") {
+    require(scripts.help);
+    return;
+  }
+
+  try {
+    switch (args[0]) {
+      case "g":
+        if (!args[1])
+          throw new Error("Usage: gcg g [res|resource|s|service|au|auth]");
+        if (args[1] === "res" || args[1] === "resource") {
+          await generateResource();
+        } else if (args[1] === "s" || args[1] === "service") {
+          await generateService();
+        } else if (args[1] === "au" || args[1] === "auth") {
+          await generateAuth();
+        } else {
+          throw new Error("Usage: gcg g [res|resource|s|service|au|auth]");
+        }
+        break;
+
+      case "rm":
+        if (!args[1]) throw new Error("Usage: gcg rm res");
+        if (args[1] === "res" || args[1] === "resource") {
+          const moduleName = await listModules();
+          if (moduleName) {
+            const rmNames = utils.processName(moduleName);
+            await require(scripts.removeModule)(
+              rmNames.lower,
+              rmNames.pascal,
+              rmNames.camel,
+              rmNames.snake,
+            );
+          }
+        } else {
+          throw new Error("Usage: gcg rm res");
+        }
+        break;
+
+      case "list":
+      case "ls":
+        const selected = await listModules();
+        if (selected) {
+          console.log(`${COLORS.GREEN}Selected resource: ${selected}`);
+        }
+        break;
+
+      case "new":
+      case "n":
+        if (args[1]) throw new Error("'new' takes no arguments");
+        await setupProject();
+        break;
+
+      case "add":
+        if (!args[1]) throw new Error("Usage: gcg add [au|auth]");
+        if (args[1] === "au" || args[1] === "auth") {
+          await addAuthToResource();
+        } else {
+          throw new Error("Usage: gcg add [au|auth]");
+        }
+        break;
+
+      default:
+        throw new Error(`Unknown command: ${args[0]}`);
+    }
+  } catch (error) {
+    console.error(`${COLORS.RED}❌ Error: ${error.message}${COLORS.NC}`);
+    console.log(`${COLORS.CYAN}Use --help for command info${COLORS.NC}`);
+    process.exit(1);
+  }
+}
+
+// Run with error handling
+if (require.main === module) {
+  commandLineMode().catch((error) => {
+    console.error(`${COLORS.RED}❌ Fatal error:${COLORS.NC} ${error.message}`);
+    process.stdout.write("\x1B[?25h");
+    process.exit(1);
+  });
+}

package/src/lib/constants/index.js

@@ -0,0 +1,24 @@
+const path = require("path");
+
+const COLORS = {
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  RED: "\x1b[31m",
+  CYAN: "\x1b[36m",
+  MAGENTA: "\x1b[35m",
+  NC: "\x1b[0m",
+};
+
+const CONFIG = {
+  MODULE_NAME: "",
+  MODULE_NAME_PASCAL: "",
+  MODULE_NAME_CAMEL: "",
+  MODULE_NAME_SNAKE: "",
+  ROOT_DIR: "",
+  GO_MODULE: "",
+};
+
+module.exports = {
+  COLORS,
+  CONFIG,
+};

package/src/lib/shares/createDir.js

@@ -0,0 +1,22 @@
+const fs = require("fs").promises;
+
+const COLORS = {
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  RED: "\x1b[31m",
+  NC: "\x1b[0m",
+};
+
+async function createDir(dirPath) {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+    console.log(`${COLORS.GREEN}✔ Created directory ${dirPath}${COLORS.NC}`);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      console.error(`${COLORS.RED}❌ Failed to create directory ${dirPath}: ${error.message}${COLORS.NC}`);
+      throw error;
+    }
+  }
+}
+
+module.exports = createDir;

package/src/lib/shares/createFile.js

@@ -0,0 +1,23 @@
+const fs = require("fs").promises;
+const path = require("path");
+
+const COLORS = {
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  RED: "\x1b[31m",
+  NC: "\x1b[0m",
+};
+
+async function createFile(filePath, content) {
+  try {
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(filePath, content, "utf8");
+    console.log(`${COLORS.GREEN}✔ Created ${filePath}${COLORS.NC}`);
+  } catch (error) {
+    console.error(`${COLORS.RED}❌ Failed to create ${filePath}: ${error.message}${COLORS.NC}`);
+    throw error;
+  }
+}
+
+module.exports = createFile;

package/src/lib/utils/add-auth-to-resource.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+
+const fs = require("fs").promises;
+const path = require("path");
+const { COLORS } = require("../constants/index");
+
+/**
+ * AddAuthToResource - Adds JWT authentication guard to an existing Gin controller
+ */
+class AddAuthToResource {
+  constructor(moduleNameLower, moduleNamePascal, moduleNameCamel) {
+    this.moduleNameLower = moduleNameLower;
+    this.moduleNamePascal = moduleNamePascal;
+    this.moduleNameCamel = moduleNameCamel;
+
+    this.srcDir = "src";
+    this.infrastructureDir = path.join(this.srcDir, "infrastructure");
+
+    // Get go module name from go.mod
+    this.goModule = this.getGoModuleName();
+  }
+
+  getGoModuleName() {
+    try {
+      const goModPath = path.join(process.cwd(), "go.mod");
+      const content = require("fs").readFileSync(goModPath, "utf8");
+      const match = content.match(/module\s+(.+)/);
+      return match ? match[1].trim() : "github.com/example/project";
+    } catch {
+      return "github.com/example/project";
+    }
+  }
+
+  async execute() {
+    try {
+      console.log(
+        `${COLORS.YELLOW}Adding authentication to ${this.moduleNamePascal} resource...${COLORS.NC}`,
+      );
+
+      // Check if auth module exists
+      const authDir = path.join(this.infrastructureDir, "common", "auth");
+      try {
+        await fs.access(authDir);
+      } catch {
+        console.log(
+          `${COLORS.RED}❌ Authentication module not found. Run 'gcg g au' first.${COLORS.NC}`,
+        );
+        return;
+      }
+
+      await this.updateController();
+      await this.updateRouter();
+
+      console.log(
+        `${COLORS.GREEN}✔ Authentication added to ${this.moduleNamePascal} resource!${COLORS.NC}`,
+      );
+      this.printSummary();
+    } catch (error) {
+      console.error(`${COLORS.RED}Error:${COLORS.NC} ${error.message}`);
+      throw error;
+    }
+  }
+
+  async updateController() {
+    const controllerPath = path.join(
+      this.infrastructureDir,
+      "controllers",
+      this.moduleNameLower,
+      `${this.moduleNameLower}.controller.go`,
+    );
+
+    try {
+      let content = await fs.readFile(controllerPath, "utf8");
+
+      // Check if already has auth middleware import
+      if (
+        content.includes("middleware.GetAuthUser") ||
+        content.includes("middleware.AuthMiddleware")
+      ) {
+        console.log(
+          `${COLORS.YELLOW}⚠ ${this.moduleNamePascal} controller already has authentication${COLORS.NC}`,
+        );
+        return;
+      }
+
+      // Add middleware import if not present
+      if (
+        !content.includes(
+          `"${this.goModule}/src/infrastructure/common/middleware"`,
+        )
+      ) {
+        content = content.replace(
+          /import \(\n/,
+          `import (\n\t"${this.goModule}/src/infrastructure/common/middleware"\n`,
+        );
+      }
+
+      // Add helper methods for auth
+      const authHelperFunc = `
+// getAuthUser retrieves the authenticated user from Gin context
+func (c *Controller) getAuthUser(ctx *gin.Context) (*models.AuthUser, bool) {
+	return middleware.GetAuthUser(ctx)
+}
+`;
+
+      // Add before the Converters section or at the end of the file
+      if (
+        content.includes(
+          "// ============================================================================\n// Converters",
+        )
+      ) {
+        content = content.replace(
+          "// ============================================================================\n// Converters",
+          authHelperFunc +
+            "\n// ============================================================================\n// Converters",
+        );
+      }
+
+      await fs.writeFile(controllerPath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${controllerPath}${COLORS.NC}`);
+    } catch (error) {
+      console.error(
+        `${COLORS.YELLOW}⚠ Could not update controller: ${error.message}${COLORS.NC}`,
+      );
+    }
+  }
+
+  async updateRouter() {
+    const routerPath = path.join(
+      this.infrastructureDir,
+      "controllers",
+      "router.go",
+    );
+
+    try {
+      let content = await fs.readFile(routerPath, "utf8");
+
+      // Check if auth middleware import exists
+      if (
+        !content.includes(
+          `"${this.goModule}/src/infrastructure/common/middleware"`,
+        )
+      ) {
+        content = content.replace(
+          /import \(\n/,
+          `import (\n\t"${this.goModule}/src/infrastructure/common/middleware"\n`,
+        );
+      }
+
+      // Check if auth import exists
+      if (
+        !content.includes(`"${this.goModule}/src/infrastructure/common/auth"`)
+      ) {
+        content = content.replace(
+          /import \(\n/,
+          `import (\n\t"${this.goModule}/src/infrastructure/common/auth"\n`,
+        );
+      }
+
+      // Check if this module's routes already use auth middleware
+      const authMiddlewarePattern = new RegExp(
+        `${this.moduleNameLower}s?\\.Use\\(middleware\\.AuthMiddleware`,
+        "m",
+      );
+
+      if (authMiddlewarePattern.test(content)) {
+        console.log(
+          `${COLORS.YELLOW}⚠ Router already has auth middleware for ${this.moduleNamePascal}${COLORS.NC}`,
+        );
+        return;
+      }
+
+      // Find the module's route group and add auth middleware
+      // Pattern: moduleName := v1.Group("/moduleNames")
+      const groupPattern = new RegExp(
+        `(${this.moduleNameLower}s?\\s*:=\\s*v1\\.Group\\(["\']\/${this.moduleNameLower}s?["\']\\))`,
+        "m",
+      );
+
+      const match = content.match(groupPattern);
+      if (match) {
+        // Add auth middleware after the group declaration
+        const authMiddleware = `$1\n\t${this.moduleNameLower}s.Use(middleware.AuthMiddleware(auth.NewJWTService()))`;
+        content = content.replace(groupPattern, authMiddleware);
+
+        await fs.writeFile(routerPath, content, "utf8");
+        console.log(
+          `${COLORS.GREEN}✔ Updated ${routerPath} with auth middleware${COLORS.NC}`,
+        );
+      } else {
+        console.log(
+          `${COLORS.YELLOW}⚠ Could not find ${this.moduleNameLower} route group in router.go. Please add auth middleware manually.${COLORS.NC}`,
+        );
+      }
+    } catch (error) {
+      console.error(
+        `${COLORS.YELLOW}⚠ Could not update router: ${error.message}${COLORS.NC}`,
+      );
+    }
+  }
+
+  printSummary() {
+    console.log(`
+${COLORS.CYAN}╔════════════════════════════════════════════════════════════╗
+║              Authentication Added to Resource                ║
+╠════════════════════════════════════════════════════════════╣
+║  📁 Updated:                                                 ║
+║     • infrastructure/controllers/${this.moduleNameLower}/${this.moduleNameLower}.controller.go
+║     • infrastructure/controllers/router.go                   ║
+║                                                              ║
+║  🔧 New helper methods available:                            ║
+║     • c.getAuthUser(ctx) - Get authenticated user            ║
+║                                                              ║
+║  📝 Usage in your controller methods:                        ║
+║     user, ok := c.getAuthUser(ctx)                           ║
+║     if !ok { response.Error(ctx, 401, "Unauthorized") }      ║
+║     // Use user.ID, user.Email, user.Role                    ║
+║                                                              ║
+║  🔒 Auth middleware automatically added to ${this.moduleNameLower} routes    ║
+╚════════════════════════════════════════════════════════════╝${COLORS.NC}
+`);
+  }
+}
+
+module.exports = AddAuthToResource;