go-gin-cli 1.0.0

package/src/lib/utils/create-service.js

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+
+const fs = require("fs").promises;
+const path = require("path");
+const prompts = require("prompts");
+const createDir = require("../shares/createDir");
+const createFile = require("../shares/createFile");
+const { COLORS } = require("../constants/index");
+
+/**
+ * ServiceGenerator - Adds custom services to existing resources
+ * Following Clean Architecture pattern with action folders
+ * 
+ * Creates:
+ * src/infrastructure/repositories/{module}/{serviceName}/
+ *   ├── action.go
+ *   └── validation.go
+ */
+class ServiceGenerator {
+  constructor() {
+    this.moduleName = "";
+    this.serviceName = "";
+    this.serviceNamePascal = "";
+    this.serviceNameCamel = "";
+    this.goModule = "";
+    
+    // Paths matching Clean Architecture structure
+    this.srcDir = "src";
+    this.domainDir = path.join(this.srcDir, "domain");
+    this.infrastructureDir = path.join(this.srcDir, "infrastructure");
+    this.usecasesDir = path.join(this.srcDir, "usecases");
+  }
+
+  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";
+    }
+  }
+
+  getRepositoryFolders() {
+    try {
+      const repoPath = path.join(this.infrastructureDir, "repositories");
+      
+      if (!require("fs").existsSync(repoPath)) {
+        return [];
+      }
+
+      return require("fs").readdirSync(repoPath, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+        .filter(folder => folder !== "base");
+    } catch (error) {
+      console.error(`${COLORS.RED}❌ Error listing modules: ${error.message}${COLORS.NC}`);
+      return [];
+    }
+  }
+
+  validateServiceName(name) {
+    const isValid = /^[a-zA-Z][a-zA-Z0-9]*$/.test(name);
+    if (!isValid) {
+      console.error(`${COLORS.RED}Service name must start with a letter and contain only letters and numbers${COLORS.NC}`);
+    }
+    return isValid;
+  }
+
+  toPascalCase(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  toCamelCase(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+  }
+
+  async buildParams() {
+    // Check if we're in the right directory
+    if (!require("fs").existsSync(path.join(this.infrastructureDir, "repositories"))) {
+      throw new Error("This command must be run from within a Go Clean Architecture project root directory.");
+    }
+
+    const modules = this.getRepositoryFolders();
+    
+    if (modules.length === 0) {
+      throw new Error(
+        "No modules found. Please create a resource first using: gcg g res <resource-name>",
+      );
+    }
+
+    const { selectedModule } = await prompts({
+      type: "select",
+      name: "selectedModule",
+      message: "Select a module for the service:",
+      choices: modules.map(module => ({
+        title: module,
+        value: module
+      })),
+      initial: 0,
+      onState: (state) => {
+        if (state.aborted) {
+          console.log(`${COLORS.CYAN}Service generation cancelled${COLORS.NC}`);
+          process.exit(0);
+        }
+      }
+    });
+
+    if (!selectedModule) {
+      throw new Error("Module selection is required");
+    }
+
+    const { serviceName } = await prompts({
+      type: "text",
+      name: "serviceName",
+      message: "Enter service name (e.g., getByEmail, activate):",
+      validate: this.validateServiceName.bind(this),
+      hint: "Use camelCase format",
+      onState: (state) => {
+        if (state.aborted) {
+          console.log(`${COLORS.CYAN}Service generation cancelled${COLORS.NC}`);
+          process.exit(0);
+        }
+      }
+    });
+
+    if (!serviceName) {
+      throw new Error("Service name is required");
+    }
+
+    this.moduleName = selectedModule;
+    this.serviceName = serviceName;
+    this.serviceNamePascal = this.toPascalCase(serviceName);
+    this.serviceNameCamel = this.toCamelCase(serviceName);
+    this.goModule = this.getGoModuleName();
+    
+    // Get module pascal case
+    this.moduleNamePascal = selectedModule
+      .split("-")
+      .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+      .join("");
+    this.moduleNameCamel = selectedModule
+      .split("-")
+      .map((part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1))
+      .join("");
+  }
+
+  async execute() {
+    try {
+      console.log(`${COLORS.CYAN}🚀 Starting service generation...${COLORS.NC}`);
+      
+      await this.buildParams();
+
+      console.log(`
+${COLORS.MAGENTA}📋 Service Details:${COLORS.NC}
+   ${COLORS.YELLOW}Module:${COLORS.NC} ${this.moduleName}
+   ${COLORS.YELLOW}Service:${COLORS.NC} ${this.serviceName}
+`);
+
+      // Create service action folder
+      await this.createServiceFolder();
+      
+      // Update files
+      await this.updateRepositoryInterface();
+      await this.updateMainRepository();
+      await this.updateUsecase();
+      await this.updateController();
+      await this.updateRouter();
+
+      console.log(`${COLORS.GREEN}🎉 Service generation completed successfully!${COLORS.NC}`);
+      this.printSummary();
+    } catch (error) {
+      console.error(`${COLORS.RED}❌ Service generation failed: ${error.message}${COLORS.NC}`);
+      throw error;
+    }
+  }
+
+  async createServiceFolder() {
+    const serviceDir = path.join(
+      this.infrastructureDir, 
+      "repositories", 
+      this.moduleName, 
+      `${this.serviceNameCamel}${this.moduleNamePascal}`
+    );
+    
+    await createDir(serviceDir);
+
+    // Create action.go
+    await createFile(
+      path.join(serviceDir, "action.go"),
+      this.getServiceActionContent()
+    );
+
+    // Create validation.go
+    await createFile(
+      path.join(serviceDir, "validation.go"),
+      this.getServiceValidationContent()
+    );
+  }
+
+  getServiceActionContent() {
+    return `package ${this.serviceNameCamel}${this.moduleNamePascal}
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/infrastructure/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// Action performs the ${this.serviceNameCamel} operation
+func Action(ctx context.Context, db *gorm.DB, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error) {
+	var entity entities.${this.moduleNamePascal}
+	err := db.WithContext(ctx).Where("id = ? AND is_active = ?", id, true).First(&entity).Error
+	if err != nil {
+		return nil, err
+	}
+	return entity.ToModel(), nil
+}
+`;
+  }
+
+  getServiceValidationContent() {
+    return `package ${this.serviceNameCamel}${this.moduleNamePascal}
+
+import (
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+// Validate validates the ${this.serviceNameCamel} request
+func Validate(id uuid.UUID) error {
+	if id == uuid.Nil {
+		return errors.New("id is required")
+	}
+	return nil
+}
+`;
+  }
+
+  async updateRepositoryInterface() {
+    const filePath = path.join(this.domainDir, "repositories", `${this.moduleName}.go`);
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+      
+      // Check if method already exists
+      if (content.includes(`${this.serviceNamePascal}(`)) {
+        console.log(`${COLORS.YELLOW}⚠ Repository interface already contains ${this.serviceNamePascal}${COLORS.NC}`);
+        return;
+      }
+
+      // Add new method to interface
+      const methodSignature = `\t${this.serviceNamePascal}(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error)`;
+      
+      // Find the interface closing brace and add method before it
+      const interfaceMatch = content.match(/(type\s+\w+Repository\s+interface\s*\{[\s\S]*?)(^\})/m);
+      if (interfaceMatch) {
+        const newContent = content.replace(
+          interfaceMatch[0],
+          `${interfaceMatch[1]}${methodSignature}\n}`
+        );
+        await fs.writeFile(filePath, newContent, "utf8");
+        console.log(`${COLORS.GREEN}✔ Updated ${filePath}${COLORS.NC}`);
+      }
+    } catch (error) {
+      console.error(`${COLORS.RED}❌ Failed to update repository interface: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  async updateMainRepository() {
+    const filePath = path.join(this.infrastructureDir, "repositories", this.moduleName, `${this.moduleName}.repository.go`);
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+      
+      // Check if method already exists
+      if (content.includes(`func (r *Repository) ${this.serviceNamePascal}`)) {
+        console.log(`${COLORS.YELLOW}⚠ Repository already contains ${this.serviceNamePascal}${COLORS.NC}`);
+        return;
+      }
+
+      // Add import for the new service package
+      const importLine = `\t"${this.goModule}/src/infrastructure/repositories/${this.moduleName}/${this.serviceNameCamel}${this.moduleNamePascal}"`;
+      content = content.replace(
+        /import \(([\s\S]*?)\)/,
+        (match, imports) => `import (${imports}${importLine}\n)`
+      );
+
+      // Add new method implementation
+      const methodImpl = `
+func (r *Repository) ${this.serviceNamePascal}(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error) {
+	if err := ${this.serviceNameCamel}${this.moduleNamePascal}.Validate(id); err != nil {
+		return nil, err
+	}
+	return ${this.serviceNameCamel}${this.moduleNamePascal}.Action(ctx, r.db, id)
+}
+`;
+      
+      content += methodImpl;
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${filePath}${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.RED}❌ Failed to update main repository: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  async updateUsecase() {
+    const filePath = path.join(this.usecasesDir, this.moduleName, `${this.moduleName}.usecase.go`);
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+      
+      // Check if method already exists
+      if (content.includes(`func (u *Usecase) ${this.serviceNamePascal}`)) {
+        console.log(`${COLORS.YELLOW}⚠ Usecase already contains ${this.serviceNamePascal}${COLORS.NC}`);
+        return;
+      }
+
+      // Add new method implementation
+      const methodImpl = `
+// ${this.serviceNamePascal} performs ${this.serviceNameCamel} operation
+func (u *Usecase) ${this.serviceNamePascal}(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error) {
+	model, err := u.repo.${this.serviceNamePascal}(ctx, id)
+	if err != nil {
+		u.logger.Error("${this.moduleNamePascal}Usecase", "Failed to ${this.serviceNameCamel}", err)
+		return nil, err
+	}
+	return model, nil
+}
+`;
+      
+      content += methodImpl;
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${filePath}${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.RED}❌ Failed to update usecase: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  async updateController() {
+    const filePath = path.join(this.infrastructureDir, "controllers", this.moduleName, `${this.moduleName}.controller.go`);
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+      
+      // Check if method already exists
+      if (content.includes(`func (c *Controller) ${this.serviceNamePascal}`)) {
+        console.log(`${COLORS.YELLOW}⚠ Controller already contains ${this.serviceNamePascal}${COLORS.NC}`);
+        return;
+      }
+
+      // Add new controller method
+      const controllerMethod = `
+// ${this.serviceNamePascal} performs ${this.serviceNameCamel} operation
+// @Summary ${this.serviceNamePascal} for ${this.moduleNamePascal}
+// @Tags ${this.moduleNamePascal}
+// @Produce json
+// @Param id path string true "${this.moduleNamePascal} ID"
+// @Success 200 {object} response.Response{data=dtos.${this.moduleNamePascal}Response}
+// @Failure 400 {object} response.Response
+// @Failure 404 {object} response.Response
+// @Router /api/v1/${this.moduleName}s/{id}/${this.serviceNameCamel} [get]
+func (c *Controller) ${this.serviceNamePascal}(ctx *gin.Context) {
+	id, err := uuid.Parse(ctx.Param("id"))
+	if err != nil {
+		response.Error(ctx, http.StatusBadRequest, "Invalid ID format")
+		return
+	}
+
+	model, err := c.usecase.${this.serviceNamePascal}(ctx.Request.Context(), id)
+	if err != nil {
+		if appErr, ok := utils.IsAppError(err); ok {
+			response.Error(ctx, appErr.Code, appErr.Message)
+			return
+		}
+		response.Error(ctx, http.StatusNotFound, "${this.moduleNamePascal} not found")
+		return
+	}
+
+	response.Success(ctx, http.StatusOK, modelToResponse(model))
+}
+`;
+      
+      content += controllerMethod;
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${filePath}${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.RED}❌ Failed to 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 route already exists
+      const routePattern = `${this.moduleName}s/{id}/${this.serviceNameCamel}`;
+      if (content.includes(routePattern)) {
+        console.log(`${COLORS.YELLOW}⚠ Router already contains route for ${this.serviceNamePascal}${COLORS.NC}`);
+        return;
+      }
+
+      // Find the module's route group and add the new route
+      // Look for pattern like: moduleName := v1.Group("/moduleNames")
+      const groupPattern = new RegExp(
+        `(${this.moduleName}s?\\s*:=\\s*v1\\.Group\\(["\']\/${this.moduleName}s?["\']\\)[\\s\\S]*?\\{[\\s\\S]*?)(\\})`,
+        'm'
+      );
+      
+      const match = content.match(groupPattern);
+      if (match) {
+        const newRoute = `\t\t${this.moduleName}s.GET("/:id/${this.serviceNameCamel}", ${this.moduleName}Ctrl.${this.serviceNamePascal})\n\t`;
+        content = content.replace(
+          groupPattern,
+          `$1${newRoute}$2`
+        );
+        await fs.writeFile(routerPath, content, "utf8");
+        console.log(`${COLORS.GREEN}✔ Updated ${routerPath}${COLORS.NC}`);
+      } else {
+        console.log(`${COLORS.YELLOW}⚠ Could not find ${this.moduleName} route group in router.go. Please add route manually.${COLORS.NC}`);
+      }
+    } catch (error) {
+      console.error(`${COLORS.YELLOW}⚠ Could not update router: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  printSummary() {
+    console.log(`
+${COLORS.CYAN}📁 Created files:${COLORS.NC}
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/repositories/${this.moduleName}/${this.serviceNameCamel}${this.moduleNamePascal}/
+      ├── action.go
+      └── validation.go
+
+${COLORS.CYAN}📝 Updated files:${COLORS.NC}
+  ${COLORS.GREEN}✓${COLORS.NC} src/domain/repositories/${this.moduleName}.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/repositories/${this.moduleName}/${this.moduleName}.repository.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/usecases/${this.moduleName}/${this.moduleName}.usecase.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/controllers/${this.moduleName}/${this.moduleName}.controller.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/controllers/router.go
+
+${COLORS.YELLOW}⚠ Don't forget to:${COLORS.NC}
+  1. Customize the service logic in action.go as needed
+  2. Run ${COLORS.CYAN}go mod tidy${COLORS.NC} if you added new dependencies
+`);
+  }
+}
+
+module.exports = ServiceGenerator;

package/src/lib/utils/display.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+const packageJson = require("../../../package.json");
+
+const COLORS = {
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  CYAN: "\x1b[36m",
+  NC: "\x1b[0m",
+};
+
+function displayVersion() {
+  console.log(`${COLORS.CYAN}╔══════════════════════════════════════════╗${COLORS.NC}`);
+  console.log(`   ${COLORS.GREEN}Go Clean Architecture CLI${COLORS.NC}`);
+  console.log(`   ${COLORS.YELLOW}Version: ${packageJson.version}${COLORS.NC}`);
+  console.log(`${COLORS.CYAN}╚══════════════════════════════════════════╝${COLORS.NC}`);
+}
+
+module.exports = { displayVersion };

package/src/lib/utils/help.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+// Colors for output
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[36m";
+const BLUE = "\x1b[34m";
+const MAGENTA = "\x1b[35m";
+const NC = "\x1b[0m";
+
+// Header
+console.log(`${CYAN}╔══════════════════════════════════════════╗${NC}`);
+console.log(`   ${BLUE}✨ ${GREEN}Go Clean Architecture CLI ${BLUE}✨${NC}   `);
+console.log(`${CYAN}╚══════════════════════════════════════════╝${NC}`);
+console.log("");
+console.log(
+  `${YELLOW}📚 This CLI follows Clean Architecture principles${NC}`
+);
+console.log(`${YELLOW}   and helps scaffold your Go/Gin-Gonic application${NC}`);
+console.log("");
+
+// Commands section
+console.log(`${MAGENTA}🌈 Available Commands:${NC}`);
+console.log("");
+
+console.log(`${BLUE}⚙️ Create New Project:${NC}`);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg n${NC}        - Initialize project structure`,
+);
+console.log(`   ${GREEN}➜${NC} ${CYAN}gcg new${NC}      `);
+console.log("");
+
+console.log(`${GREEN}🛠  Create Resources:${NC}`);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg g res${NC}        - Generate a new resource`,
+);
+console.log(`   ${GREEN}➜${NC} ${CYAN}gcg g resource${NC}`);
+console.log("");
+
+console.log(`${BLUE}⚡ Create Services:${NC}`);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg g s${NC}          - Generate a new service`,
+);
+console.log(`   ${GREEN}➜${NC} ${CYAN}gcg g service${NC}`);
+console.log("");
+
+console.log(`${MAGENTA}🔐 Create Authentication:${NC}`);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg g au${NC}         - Generate JWT & Passport auth`,
+);
+console.log(`   ${GREEN}➜${NC} ${CYAN}gcg g auth${NC}`);
+console.log("");
+
+console.log(`${YELLOW}🔒 Add Auth to Resource:${NC}`);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg add au${NC}       - Add auth guard to a resource`,
+);
+console.log(`   ${GREEN}➜${NC} ${CYAN}gcg add auth${NC}`);
+console.log("");
+
+console.log(`${RED}🗑  Remove Resources:${NC}`);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg rm res${NC}        - Remove an existing resource`,
+);
+console.log(`   ${GREEN}➜${NC} ${CYAN}gcg rm resource${NC}`);
+console.log("");
+
+console.log(`${YELLOW}ℹ️  Other Commands:${NC}`);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg --help${NC}        - Show help message`,
+);
+console.log(
+  `   ${GREEN}➜${NC} ${CYAN}gcg --version${NC}     - Display version`,
+);
+console.log("");
+
+// Tech Stack
+console.log(`${MAGENTA}🔧 Tech Stack:${NC}`);
+console.log(`   ${GREEN}➜${NC} Framework: ${CYAN}Gin-Gonic${NC}`);
+console.log(`   ${GREEN}➜${NC} ORM: ${CYAN}GORM${NC}`);
+console.log(`   ${GREEN}➜${NC} Database: ${CYAN}PostgreSQL${NC}`);
+console.log(`   ${GREEN}➜${NC} API: ${CYAN}RESTful${NC}`);
+console.log(`   ${GREEN}➜${NC} Logging: ${CYAN}Zap${NC}`);
+console.log(`   ${GREEN}➜${NC} Config: ${CYAN}Viper${NC}`);
+console.log("");
+
+// Footer
+console.log(`${CYAN}╔══════════════════════════════════════════╗${NC}`);
+console.log(
+  `${BLUE}🔹 ${GREEN}Happy Coding with Clean Architecture! ${BLUE} 🔹${NC}`
+);
+console.log(`${CYAN}╚══════════════════════════════════════════╝${NC}`);