go-gin-cli 1.0.0

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

@@ -0,0 +1,1426 @@
+#!/usr/bin/env node
+
+const fs = require("fs").promises;
+const path = require("path");
+const createDir = require("../shares/createDir");
+const createFile = require("../shares/createFile");
+const { COLORS } = require("../constants/index");
+
+/**
+ * ModuleGenerator - Generates Gin HTTP resource files following Clean Architecture pattern
+ * 
+ * Structure:
+ * src/
+ * ├── domain/
+ * │   ├── dtos/{module}.go
+ * │   ├── models/{module}.go
+ * │   └── repositories/{module}.go
+ * ├── infrastructure/
+ * │   ├── controllers/{module}/
+ * │   │   └── {module}.controller.go
+ * │   ├── entities/{module}.go
+ * │   ├── repositories/{module}/
+ * │   │   ├── create{Module}/
+ * │   │   │   ├── action.go
+ * │   │   │   └── validation.go
+ * │   │   ├── delete{Module}/
+ * │   │   ├── getAll{Module}/
+ * │   │   ├── load{Module}ById/
+ * │   │   ├── loadAll{Module}/
+ * │   │   ├── update{Module}/
+ * │   │   └── {module}.repository.go
+ * └── usecases/{module}/
+ */
+class ModuleGenerator {
+  constructor(moduleNameLower, moduleNamePascal, moduleNameCamel, moduleNameSnake) {
+    // For Go packages, use camelCase (no hyphens allowed)
+    // e.g., "user-role" -> "userRole" for package name
+    this.moduleNameLower = moduleNameCamel.charAt(0).toLowerCase() + moduleNameCamel.slice(1); // userRole
+    this.moduleNamePascal = moduleNamePascal; // UserRole
+    this.moduleNameCamel = moduleNameCamel; // userRole
+    this.moduleNameSnake = moduleNameSnake; // user_role
+    this.moduleNameKebab = moduleNameLower; // user-role (original input, for display only)
+    
+    // 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");
+    
+    // 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}Starting Gin HTTP resource generation...${COLORS.NC}`);
+      
+      await this.setupDirectories();
+      await this.generateDomainFiles();
+      await this.generateInfrastructureFiles();
+      await this.generateUsecaseFiles();
+      await this.updateModules();
+      await this.runPostGeneration();
+      
+      console.log(`${COLORS.GREEN}Resource generation completed successfully!${COLORS.NC}`);
+      this.printSummary();
+    } catch (error) {
+      console.error(`${COLORS.RED}Error during generation:${COLORS.NC} ${error.message}`);
+      throw error;
+    }
+  }
+
+  async setupDirectories() {
+    // Repository action directories
+    const repoActions = [
+      `create${this.moduleNamePascal}`,
+      `delete${this.moduleNamePascal}`,
+      `getAll${this.moduleNamePascal}`,
+      `load${this.moduleNamePascal}ById`,
+      `loadAll${this.moduleNamePascal}`,
+      `update${this.moduleNamePascal}`,
+    ];
+
+    const dirs = [
+      // Repository directories with action folders
+      ...repoActions.map(action => 
+        path.join(this.infrastructureDir, "repositories", this.moduleNameLower, action)
+      ),
+      // Controller directory
+      path.join(this.infrastructureDir, "controllers", this.moduleNameLower),
+      // Usecase directory
+      path.join(this.usecasesDir, this.moduleNameLower),
+    ];
+
+    for (const dir of dirs) {
+      await createDir(dir);
+    }
+  }
+
+  async generateDomainFiles() {
+    // DTOs
+    await createFile(
+      path.join(this.domainDir, "dtos", `${this.moduleNameLower}.go`),
+      this.getDtoContent()
+    );
+    // Model
+    await createFile(
+      path.join(this.domainDir, "models", `${this.moduleNameLower}.go`),
+      this.getModelContent()
+    );
+
+    // Repository Interface
+    await createFile(
+      path.join(this.domainDir, "repositories", `${this.moduleNameLower}.go`),
+      this.getRepositoryInterfaceContent()
+    );
+  }
+
+  async generateInfrastructureFiles() {
+    // Entity
+    await createFile(
+      path.join(this.infrastructureDir, "entities", `${this.moduleNameLower}.go`),
+      this.getEntityContent()
+    );
+
+    // Repository action files
+    await this.generateRepositoryActions();
+
+    // Main repository file
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `${this.moduleNameLower}.repository.go`),
+      this.getMainRepositoryContent()
+    );
+
+    // Gin Controller
+    await createFile(
+      path.join(this.infrastructureDir, "controllers", this.moduleNameLower, `${this.moduleNameLower}.controller.go`),
+      this.getControllerContent()
+    );
+  }
+
+  async generateRepositoryActions() {
+    // Create action
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `create${this.moduleNamePascal}`, "action.go"),
+      this.getCreateActionContent()
+    );
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `create${this.moduleNamePascal}`, "validation.go"),
+      this.getCreateValidationContent()
+    );
+
+    // Delete action
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `delete${this.moduleNamePascal}`, "action.go"),
+      this.getDeleteActionContent()
+    );
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `delete${this.moduleNamePascal}`, "validation.go"),
+      this.getDeleteValidationContent()
+    );
+
+    // GetAll action
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `getAll${this.moduleNamePascal}`, "action.go"),
+      this.getGetAllActionContent()
+    );
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `getAll${this.moduleNamePascal}`, "validation.go"),
+      this.getGetAllValidationContent()
+    );
+
+    // LoadById action
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `load${this.moduleNamePascal}ById`, "action.go"),
+      this.getLoadByIdActionContent()
+    );
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `load${this.moduleNamePascal}ById`, "validation.go"),
+      this.getLoadByIdValidationContent()
+    );
+
+    // LoadAll action
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `loadAll${this.moduleNamePascal}`, "action.go"),
+      this.getLoadAllActionContent()
+    );
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `loadAll${this.moduleNamePascal}`, "validation.go"),
+      this.getLoadAllValidationContent()
+    );
+
+    // Update action
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `update${this.moduleNamePascal}`, "action.go"),
+      this.getUpdateActionContent()
+    );
+    await createFile(
+      path.join(this.infrastructureDir, "repositories", this.moduleNameLower, `update${this.moduleNamePascal}`, "validation.go"),
+      this.getUpdateValidationContent()
+    );
+  }
+
+  async generateUsecaseFiles() {
+    // Main usecase file
+    await createFile(
+      path.join(this.usecasesDir, this.moduleNameLower, `${this.moduleNameLower}.usecase.go`),
+      this.getUsecaseContent()
+    );
+  }
+
+  async updateModules() {
+    // Update repositories module
+    await this.updateRepositoriesModule();
+    // Update usecases proxy
+    await this.updateUsecasesProxy();
+    // Update router with new routes
+    await this.updateRouter();
+    // Update main.go with auto-migration
+    await this.updateMainMigration();
+  }
+
+  async updateRepositoriesModule() {
+    const filePath = path.join(this.infrastructureDir, "repositories", "repositories.go");
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+
+      if (content.includes(`${this.moduleNamePascal}Repository`)) {
+        console.log(
+          `${COLORS.YELLOW}⚠ Repositories module already contains ${this.moduleNamePascal}${COLORS.NC}`,
+        );
+        return;
+      }
+
+      // Add import before gorm.io/gorm (alphabetical order)
+      const importLine = `\t"${this.goModule}/src/infrastructure/repositories/${this.moduleNameLower}"`;
+      content = content.replace(/import \(\n/, `import (\n${importLine}\n`);
+
+      // Add repository field to struct after "Add your repositories here" comment
+      const structFieldLine = `\t${this.moduleNamePascal}Repository *${this.moduleNameLower}.Repository`;
+      content = content.replace(
+        /\/\/ Add your repositories here\n/,
+        `// Add your repositories here\n${structFieldLine}\n`,
+      );
+
+      // Add initialization after "Initialize your repositories here" comment
+      const initLine = `\t\t${this.moduleNamePascal}Repository: ${this.moduleNameLower}.NewRepository(db),`;
+      content = content.replace(
+        /\/\/ Initialize your repositories here\n/,
+        `// Initialize your repositories here\n${initLine}\n`,
+      );
+
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${filePath}${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.YELLOW}⚠ Could not update repositories module: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  async updateUsecasesProxy() {
+    const filePath = path.join(this.infrastructureDir, "usecases-proxy", "usecases_proxy.go");
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+      
+      if (content.includes(`${this.moduleNamePascal}Usecase *${this.moduleNameCamel}Usecase.Usecase`)) {
+        console.log(`${COLORS.YELLOW}⚠ Usecases proxy already contains ${this.moduleNamePascal}${COLORS.NC}`);
+        return;
+      }
+
+      // Add import
+      const importLine = `\t${this.moduleNameCamel}Usecase "${this.goModule}/src/usecases/${this.moduleNameLower}"`;
+      content = content.replace(
+        /import \(([\s\S]*?)\)/,
+        (match, imports) => `import (${imports}${importLine}\n)`
+      );
+
+      // Remove placeholder comments if present
+      content = content.replace(/\t\/\/ Add your usecases here\n\t\/\/ UserUsecase \*usecases\.UserUsecase\n/g, '');
+      content = content.replace(/\t\t\/\/ Initialize your usecases here\n\t\t\/\/ UserUsecase: usecases\.NewUserUsecase\(repos\.UserRepository, logger\),\n/g, '');
+
+      // Add usecase field to struct - find the struct and add before closing brace
+      content = content.replace(
+        /(type UsecasesProxy struct \{[\s\S]*?)(})/,
+        (match, structContent, closeBrace) => {
+          if (structContent.includes(`${this.moduleNamePascal}Usecase`)) {
+            return match;
+          }
+          return `${structContent}\t${this.moduleNamePascal}Usecase *${this.moduleNameCamel}Usecase.Usecase\n${closeBrace}`;
+        }
+      );
+
+      // Add initialization - find NewUsecasesProxy return and add before closing brace
+      content = content.replace(
+        /(return &UsecasesProxy\{[\s\S]*?)([\t ]*\})/,
+        (match, initContent, closeBrace) => {
+          if (initContent.includes(`${this.moduleNamePascal}Usecase:`)) {
+            return match;
+          }
+          return `${initContent}\t\t${this.moduleNamePascal}Usecase: ${this.moduleNameCamel}Usecase.NewUsecase(repos.${this.moduleNamePascal}Repository, logger),\n${closeBrace}`;
+        }
+      );
+
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${filePath}${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.YELLOW}⚠ Could not update usecases proxy: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  async updateRouter() {
+    const filePath = path.join(this.infrastructureDir, "controllers", "router.go");
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+      
+      if (content.includes(`${this.moduleNameCamel}Controller`)) {
+        console.log(`${COLORS.YELLOW}⚠ Router already contains ${this.moduleNamePascal}${COLORS.NC}`);
+        return;
+      }
+
+      // Add import
+      const importLine = `\t${this.moduleNameCamel}Controller "${this.goModule}/src/infrastructure/controllers/${this.moduleNameLower}"`;
+      content = content.replace(
+        /import \(([\s\S]*?)\)/,
+        (match, imports) => `import (${imports}${importLine}\n)`
+      );
+
+      // Remove placeholder line if present
+      content = content.replace(/\t\t_ = v1 \/\/ Remove this line when adding routes\n/, '');
+
+      // Add route registration
+      const routeRegistration = `\n\t\t// ${this.moduleNamePascal} routes\n\t\t${this.moduleNameCamel}Ctrl := ${this.moduleNameCamel}Controller.NewController(r.usecasesProxy.${this.moduleNamePascal}Usecase, r.logger)\n\t\t${this.moduleNameLower}s := v1.Group("/${this.moduleNameSnake}s")\n\t\t{\n\t\t\t${this.moduleNameLower}s.GET("", ${this.moduleNameCamel}Ctrl.GetAll)\n\t\t\t${this.moduleNameLower}s.GET("/:id", ${this.moduleNameCamel}Ctrl.GetByID)\n\t\t\t${this.moduleNameLower}s.POST("", ${this.moduleNameCamel}Ctrl.Create)\n\t\t\t${this.moduleNameLower}s.PUT("/:id", ${this.moduleNameCamel}Ctrl.Update)\n\t\t\t${this.moduleNameLower}s.DELETE("/:id", ${this.moduleNameCamel}Ctrl.Delete)\n\t\t}`;
+
+      content = content.replace(
+        /(v1 := r\.engine\.Group\("\/api\/v1"\)\n\t\{)/,
+        `$1${routeRegistration}`
+      );
+
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${filePath}${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.YELLOW}⚠ Could not update router: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  async updateMainMigration() {
+    const filePath = path.join(this.srcDir, "main.go");
+    
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+      
+      // Check if entity is already in migration
+      if (content.includes(`&entities.${this.moduleNamePascal}{}`)) {
+        console.log(`${COLORS.YELLOW}⚠ main.go already contains ${this.moduleNamePascal} migration${COLORS.NC}`);
+        return;
+      }
+
+      // Add entities import if not present
+      if (!content.includes(`"${this.goModule}/src/infrastructure/entities"`)) {
+        content = content.replace(
+          /import \(([\s\S]*?)\)/,
+          (match, imports) => `import (${imports}\t"${this.goModule}/src/infrastructure/entities"\n)`
+        );
+      }
+
+      // Find AutoMigrate call and add the new entity
+      if (content.includes("database.AutoMigrate(db,")) {
+        // Add to existing AutoMigrate call - find the closing parenthesis
+        content = content.replace(
+          /(database\.AutoMigrate\(db,)([\s\S]*?)(\n\t\))/,
+          `$1$2\n\t\t&entities.${this.moduleNamePascal}{},$3`
+        );
+      } else if (content.includes("db.AutoMigrate(")) {
+        // Alternative: db.AutoMigrate pattern
+        content = content.replace(
+          /(db\.AutoMigrate\()([\s\S]*?)(\))/,
+          `$1$2, &entities.${this.moduleNamePascal}{}$3`
+        );
+      } else {
+        // Add AutoMigrate before "// Initialize and run application" or before NewApp
+        if (content.includes("// Initialize and run application")) {
+          content = content.replace(
+            /(\/\/ Initialize and run application)/,
+            `// Auto-migrate entities\n\tdatabase.AutoMigrate(db,\n\t\t&entities.${this.moduleNamePascal}{},\n\t)\n\n\t$1`
+          );
+        } else {
+          // Add before NewApp call
+          content = content.replace(
+            /(\n\t)(app := NewApp)/,
+            `$1// Auto-migrate entities\n\tdatabase.AutoMigrate(db,\n\t\t&entities.${this.moduleNamePascal}{},\n\t)\n\n\t$2`
+          );
+        }
+      }
+
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`${COLORS.GREEN}✔ Updated ${filePath} with auto-migration${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.YELLOW}⚠ Could not update main.go migration: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  async runPostGeneration() {
+    const { execSync } = require("child_process");
+    
+    console.log(`\n${COLORS.CYAN}🔄 Running post-generation tasks...${COLORS.NC}`);
+    
+    try {
+      // Run go mod tidy
+      console.log(`${COLORS.YELLOW}Running go mod tidy...${COLORS.NC}`);
+      execSync("go mod tidy", { stdio: "inherit" });
+      console.log(`${COLORS.GREEN}✔ go mod tidy completed${COLORS.NC}`);
+    } catch (error) {
+      console.error(`${COLORS.YELLOW}⚠ go mod tidy failed: ${error.message}${COLORS.NC}`);
+    }
+  }
+
+  printSummary() {
+    console.log(`
+${COLORS.CYAN}📁 Generated files:${COLORS.NC}
+  ${COLORS.GREEN}✓${COLORS.NC} src/domain/dtos/${this.moduleNameLower}.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/domain/models/${this.moduleNameLower}.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/domain/repositories/${this.moduleNameLower}.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/entities/${this.moduleNameLower}.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/controllers/${this.moduleNameLower}/${this.moduleNameLower}.controller.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/repositories/${this.moduleNameLower}/
+      ├── create${this.moduleNamePascal}/ (action.go, validation.go)
+      ├── delete${this.moduleNamePascal}/ (action.go, validation.go)
+      ├── getAll${this.moduleNamePascal}/ (action.go, validation.go)
+      ├── load${this.moduleNamePascal}ById/ (action.go, validation.go)
+      ├── loadAll${this.moduleNamePascal}/ (action.go, validation.go)
+      ├── update${this.moduleNamePascal}/ (action.go, validation.go)
+      └── ${this.moduleNameLower}.repository.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/usecases/${this.moduleNameLower}/${this.moduleNameLower}.usecase.go
+
+${COLORS.CYAN}📝 Updated files:${COLORS.NC}
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/repositories/repositories.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/usecases-proxy/usecases_proxy.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/infrastructure/controllers/router.go
+  ${COLORS.GREEN}✓${COLORS.NC} src/main.go (auto-migration added)
+
+${COLORS.CYAN}🔄 Auto-completed:${COLORS.NC}
+  ${COLORS.GREEN}✓${COLORS.NC} go mod tidy
+
+${COLORS.YELLOW}⚠ Don't forget to:${COLORS.NC}
+  1. Customize the entity fields in ${COLORS.CYAN}src/infrastructure/entities/${this.moduleNameLower}.go${COLORS.NC}
+  2. Update DTOs in ${COLORS.CYAN}src/domain/dtos/${this.moduleNameLower}.go${COLORS.NC}
+  3. Run ${COLORS.CYAN}make run${COLORS.NC} or ${COLORS.CYAN}make dev${COLORS.NC} to start the server
+`);
+  }
+
+  // ============================================
+  // Content Generators - DTOs
+  // ============================================
+
+  getDtoContent() {
+    return `package dtos
+
+// Create${this.moduleNamePascal}Request represents the create request
+type Create${this.moduleNamePascal}Request struct {
+	Name        string \`json:"name" binding:"required\"\`
+	Description string \`json:"description"\`
+}
+
+// Update${this.moduleNamePascal}Request represents the update request
+type Update${this.moduleNamePascal}Request struct {
+	Name        string \`json:"name" binding:"required"\`
+	Description string \`json:"description"\`
+}
+
+// ${this.moduleNamePascal}Response represents the response
+type ${this.moduleNamePascal}Response struct {
+	ID          string  \`json:"id"\`
+	Name        string  \`json:"name"\`
+	Description string  \`json:"description"\`
+	IsActive    bool    \`json:"is_active"\`
+	CreatedAt   string  \`json:"created_at"\`
+	UpdatedAt   string  \`json:"updated_at"\`
+}
+
+// ${this.moduleNamePascal}QueryParams represents query parameters for listing
+type ${this.moduleNamePascal}QueryParams struct {
+	Page     int    \`form:"page" binding:"omitempty,min=1"\`
+	PageSize int    \`form:"page_size" binding:"omitempty,min=1,max=100"\`
+	Search   string \`form:"search"\`
+	SortBy   string \`form:"sort_by"\`
+	SortOrder string \`form:"sort_order" binding:"omitempty,oneof=asc desc"\`
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Domain
+  // ============================================
+
+  getModelContent() {
+    return `package models
+
+import (
+	"github.com/google/uuid"
+)
+
+// ${this.moduleNamePascal}Model represents the ${this.moduleNameLower} domain model
+type ${this.moduleNamePascal}Model struct {
+	BaseModel
+	Name        string \`json:"name"\`
+	Description string \`json:"description"\`
+}
+
+// New${this.moduleNamePascal}Model creates a new ${this.moduleNamePascal} model
+func New${this.moduleNamePascal}Model(name, description string) *${this.moduleNamePascal}Model {
+	return &${this.moduleNamePascal}Model{
+		BaseModel:   NewBaseModel(),
+		Name:        name,
+		Description: description,
+	}
+}
+
+// ${this.moduleNamePascal}Filter represents filter options for ${this.moduleNameLower}
+type ${this.moduleNamePascal}Filter struct {
+	QueryParams
+	Name string \`json:"name" form:"name"\`
+}
+
+// ToMap converts model to map
+func (m *${this.moduleNamePascal}Model) ToMap() map[string]interface{} {
+	return map[string]interface{}{
+		"id":          m.ID,
+		"name":        m.Name,
+		"description": m.Description,
+		"is_active":   m.IsActive,
+		"created_at":  m.CreatedAt,
+		"updated_at":  m.UpdatedAt,
+	}
+}
+
+// ${this.moduleNamePascal}FromID creates a model reference by ID
+func ${this.moduleNamePascal}FromID(id uuid.UUID) *${this.moduleNamePascal}Model {
+	return &${this.moduleNamePascal}Model{
+		BaseModel: BaseModel{ID: id},
+	}
+}
+`;
+  }
+
+  getRepositoryInterfaceContent() {
+    return `package repositories
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	"github.com/google/uuid"
+)
+
+// ${this.moduleNamePascal}Repository defines the ${this.moduleNameLower} repository interface
+type ${this.moduleNamePascal}Repository interface {
+	Create(ctx context.Context, ${this.moduleNameCamel} *models.${this.moduleNamePascal}Model) error
+	Update(ctx context.Context, ${this.moduleNameCamel} *models.${this.moduleNamePascal}Model) error
+	Delete(ctx context.Context, id uuid.UUID) error
+	GetById(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error)
+	GetAll(ctx context.Context, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error)
+	LoadById(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error)
+	LoadAll(ctx context.Context, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error)
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Entity
+  // ============================================
+
+  getEntityContent() {
+    return `package entities
+
+import (
+	"time"
+
+	"${this.goModule}/src/domain/models"
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// ${this.moduleNamePascal} represents the ${this.moduleNameLower} entity
+type ${this.moduleNamePascal} struct {
+	ID          uuid.UUID      \`gorm:"type:uuid;primary_key" json:"id"\`
+	Name        string         \`gorm:"type:varchar(255);not null" json:"name"\`
+	Description string         \`gorm:"type:text" json:"description"\`
+	IsActive    bool           \`gorm:"default:true" json:"is_active"\`
+	CreatedAt   time.Time      \`gorm:"autoCreateTime" json:"created_at"\`
+	UpdatedAt   time.Time      \`gorm:"autoUpdateTime" json:"updated_at"\`
+	DeletedAt   gorm.DeletedAt \`gorm:"index" json:"deleted_at,omitempty"\`
+}
+
+// TableName returns the table name for ${this.moduleNamePascal}
+func (${this.moduleNamePascal}) TableName() string {
+	return "${this.moduleNameSnake}s"
+}
+
+// BeforeCreate will set a UUID rather than numeric ID
+func (e *${this.moduleNamePascal}) BeforeCreate(tx *gorm.DB) error {
+	if e.ID == uuid.Nil {
+		e.ID = uuid.New()
+	}
+	return nil
+}
+
+// ToModel converts entity to domain model
+func (e *${this.moduleNamePascal}) ToModel() *models.${this.moduleNamePascal}Model {
+	var deletedAt *time.Time
+	if e.DeletedAt.Valid {
+		deletedAt = &e.DeletedAt.Time
+	}
+	return &models.${this.moduleNamePascal}Model{
+		BaseModel: models.BaseModel{
+			ID:        e.ID,
+			CreatedAt: e.CreatedAt,
+			UpdatedAt: e.UpdatedAt,
+			DeletedAt: deletedAt,
+			IsActive:  e.IsActive,
+		},
+		Name:        e.Name,
+		Description: e.Description,
+	}
+}
+
+// FromModel creates entity from domain model
+func ${this.moduleNamePascal}FromModel(m *models.${this.moduleNamePascal}Model) *${this.moduleNamePascal} {
+	return &${this.moduleNamePascal}{
+		ID:          m.ID,
+		Name:        m.Name,
+		Description: m.Description,
+		IsActive:    m.IsActive,
+		CreatedAt:   m.CreatedAt,
+		UpdatedAt:   m.UpdatedAt,
+	}
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Repository Actions
+  // ============================================
+
+  getCreateActionContent() {
+    return `package create${this.moduleNamePascal}
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/infrastructure/entities"
+
+	"gorm.io/gorm"
+)
+
+// Action performs the create operation
+func Action(ctx context.Context, db *gorm.DB, model *models.${this.moduleNamePascal}Model) error {
+	entity := entities.${this.moduleNamePascal}FromModel(model)
+	if err := db.WithContext(ctx).Create(entity).Error; err != nil {
+		return err
+	}
+	// Update model with generated values
+	*model = *entity.ToModel()
+	return nil
+}
+`;
+  }
+
+  getCreateValidationContent() {
+    return `package create${this.moduleNamePascal}
+
+import (
+	"errors"
+
+	"${this.goModule}/src/domain/models"
+)
+
+// Validate validates the create request
+func Validate(model *models.${this.moduleNamePascal}Model) error {
+	if model.Name == "" {
+		return errors.New("name is required")
+	}
+	return nil
+}
+`;
+  }
+
+  getDeleteActionContent() {
+    return `package delete${this.moduleNamePascal}
+
+import (
+	"context"
+
+	"${this.goModule}/src/infrastructure/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// Action performs the delete operation (soft delete)
+func Action(ctx context.Context, db *gorm.DB, id uuid.UUID) error {
+	return db.WithContext(ctx).
+		Model(&entities.${this.moduleNamePascal}{}).
+		Where("id = ?", id).
+		Update("is_active", false).Error
+}
+`;
+  }
+
+  getDeleteValidationContent() {
+    return `package delete${this.moduleNamePascal}
+
+import (
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+// Validate validates the delete request
+func Validate(id uuid.UUID) error {
+	if id == uuid.Nil {
+		return errors.New("id is required")
+	}
+	return nil
+}
+`;
+  }
+
+  getGetAllActionContent() {
+    return `package getAll${this.moduleNamePascal}
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/infrastructure/entities"
+
+	"gorm.io/gorm"
+)
+
+// Action performs the getAll operation with filtering
+func Action(ctx context.Context, db *gorm.DB, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error) {
+	var entityList []entities.${this.moduleNamePascal}
+	var total int64
+
+	query := db.WithContext(ctx).Model(&entities.${this.moduleNamePascal}{}).Where("is_active = ?", true)
+
+	// Apply filters
+	if filter != nil {
+		if filter.Name != "" {
+			query = query.Where("name ILIKE ?", "%"+filter.Name+"%")
+		}
+
+		if filter.Search != nil && filter.Search.Q != "" {
+			query = query.Where("name ILIKE ? OR description ILIKE ?", "%"+filter.Search.Q+"%", "%"+filter.Search.Q+"%")
+		}
+	}
+
+	// Count total
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Apply sorting
+	if filter != nil && filter.Sort != 0 {
+		if filter.Sort == 1 {
+			query = query.Order("created_at ASC")
+		} else {
+			query = query.Order("created_at DESC")
+		}
+	} else {
+		query = query.Order("created_at DESC")
+	}
+
+	// Apply pagination
+	if filter != nil && filter.Paginate != nil {
+		offset := filter.Paginate.GetOffset()
+		limit := filter.Paginate.GetLimit()
+		query = query.Offset(offset).Limit(limit)
+	}
+
+	if err := query.Find(&entityList).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Convert to models
+	result := make([]models.${this.moduleNamePascal}Model, len(entityList))
+	for i, entity := range entityList {
+		result[i] = *entity.ToModel()
+	}
+
+	return result, total, nil
+}
+`;
+  }
+
+  getGetAllValidationContent() {
+    return `package getAll${this.moduleNamePascal}
+
+import (
+	"${this.goModule}/src/domain/models"
+)
+
+// Validate validates the getAll request
+func Validate(filter *models.${this.moduleNamePascal}Filter) error {
+	// Add validation logic if needed
+	return nil
+}
+`;
+  }
+
+  getLoadByIdActionContent() {
+    return `package load${this.moduleNamePascal}ById
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/infrastructure/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// Action performs the loadById 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
+}
+`;
+  }
+
+  getLoadByIdValidationContent() {
+    return `package load${this.moduleNamePascal}ById
+
+import (
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+// Validate validates the loadById request
+func Validate(id uuid.UUID) error {
+	if id == uuid.Nil {
+		return errors.New("id is required")
+	}
+	return nil
+}
+`;
+  }
+
+  getLoadAllActionContent() {
+    return `package loadAll${this.moduleNamePascal}
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/infrastructure/entities"
+
+	"gorm.io/gorm"
+)
+
+// Action performs the loadAll operation (without pagination)
+func Action(ctx context.Context, db *gorm.DB, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error) {
+	var entityList []entities.${this.moduleNamePascal}
+	var total int64
+
+	query := db.WithContext(ctx).Model(&entities.${this.moduleNamePascal}{}).Where("is_active = ?", true)
+
+	// Apply filters
+	if filter != nil {
+		if filter.Name != "" {
+			query = query.Where("name ILIKE ?", "%"+filter.Name+"%")
+		}
+	}
+
+	// Count total
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Order by created_at DESC
+	query = query.Order("created_at DESC")
+
+	if err := query.Find(&entityList).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Convert to models
+	result := make([]models.${this.moduleNamePascal}Model, len(entityList))
+	for i, entity := range entityList {
+		result[i] = *entity.ToModel()
+	}
+
+	return result, total, nil
+}
+`;
+  }
+
+  getLoadAllValidationContent() {
+    return `package loadAll${this.moduleNamePascal}
+
+import (
+	"${this.goModule}/src/domain/models"
+)
+
+// Validate validates the loadAll request
+func Validate(filter *models.${this.moduleNamePascal}Filter) error {
+	// Add validation logic if needed
+	return nil
+}
+`;
+  }
+
+  getUpdateActionContent() {
+    return `package update${this.moduleNamePascal}
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/infrastructure/entities"
+
+	"gorm.io/gorm"
+)
+
+// Action performs the update operation
+func Action(ctx context.Context, db *gorm.DB, model *models.${this.moduleNamePascal}Model) error {
+	entity := entities.${this.moduleNamePascal}FromModel(model)
+	if err := db.WithContext(ctx).Save(entity).Error; err != nil {
+		return err
+	}
+	*model = *entity.ToModel()
+	return nil
+}
+`;
+  }
+
+  getUpdateValidationContent() {
+    return `package update${this.moduleNamePascal}
+
+import (
+	"errors"
+
+	"${this.goModule}/src/domain/models"
+	"github.com/google/uuid"
+)
+
+// Validate validates the update request
+func Validate(model *models.${this.moduleNamePascal}Model) error {
+	if model.ID == uuid.Nil {
+		return errors.New("id is required")
+	}
+	if model.Name == "" {
+		return errors.New("name is required")
+	}
+	return nil
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Main Repository
+  // ============================================
+
+  getMainRepositoryContent() {
+    return `package ${this.moduleNameLower}
+
+import (
+	"context"
+
+	"${this.goModule}/src/domain/models"
+	domainRepo "${this.goModule}/src/domain/repositories"
+	"${this.goModule}/src/infrastructure/repositories/${this.moduleNameLower}/create${this.moduleNamePascal}"
+	"${this.goModule}/src/infrastructure/repositories/${this.moduleNameLower}/delete${this.moduleNamePascal}"
+	"${this.goModule}/src/infrastructure/repositories/${this.moduleNameLower}/getAll${this.moduleNamePascal}"
+	"${this.goModule}/src/infrastructure/repositories/${this.moduleNameLower}/load${this.moduleNamePascal}ById"
+	"${this.goModule}/src/infrastructure/repositories/${this.moduleNameLower}/loadAll${this.moduleNamePascal}"
+	"${this.goModule}/src/infrastructure/repositories/${this.moduleNameLower}/update${this.moduleNamePascal}"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// Repository implements ${this.moduleNamePascal}Repository interface
+type Repository struct {
+	db *gorm.DB
+}
+
+// NewRepository creates a new ${this.moduleNameLower} repository
+func NewRepository(db *gorm.DB) *Repository {
+	return &Repository{db: db}
+}
+
+// Ensure Repository implements interface
+var _ domainRepo.${this.moduleNamePascal}Repository = (*Repository)(nil)
+
+func (r *Repository) Create(ctx context.Context, model *models.${this.moduleNamePascal}Model) error {
+	if err := create${this.moduleNamePascal}.Validate(model); err != nil {
+		return err
+	}
+	return create${this.moduleNamePascal}.Action(ctx, r.db, model)
+}
+
+func (r *Repository) Update(ctx context.Context, model *models.${this.moduleNamePascal}Model) error {
+	if err := update${this.moduleNamePascal}.Validate(model); err != nil {
+		return err
+	}
+	return update${this.moduleNamePascal}.Action(ctx, r.db, model)
+}
+
+func (r *Repository) Delete(ctx context.Context, id uuid.UUID) error {
+	if err := delete${this.moduleNamePascal}.Validate(id); err != nil {
+		return err
+	}
+	return delete${this.moduleNamePascal}.Action(ctx, r.db, id)
+}
+
+func (r *Repository) GetById(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error) {
+	if err := load${this.moduleNamePascal}ById.Validate(id); err != nil {
+		return nil, err
+	}
+	return load${this.moduleNamePascal}ById.Action(ctx, r.db, id)
+}
+
+func (r *Repository) GetAll(ctx context.Context, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error) {
+	if err := getAll${this.moduleNamePascal}.Validate(filter); err != nil {
+		return nil, 0, err
+	}
+	return getAll${this.moduleNamePascal}.Action(ctx, r.db, filter)
+}
+
+func (r *Repository) LoadById(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error) {
+	if err := load${this.moduleNamePascal}ById.Validate(id); err != nil {
+		return nil, err
+	}
+	return load${this.moduleNamePascal}ById.Action(ctx, r.db, id)
+}
+
+func (r *Repository) LoadAll(ctx context.Context, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error) {
+	if err := loadAll${this.moduleNamePascal}.Validate(filter); err != nil {
+		return nil, 0, err
+	}
+	return loadAll${this.moduleNamePascal}.Action(ctx, r.db, filter)
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Usecase
+  // ============================================
+
+  getUsecaseContent() {
+    return `package ${this.moduleNameLower}
+
+import (
+	"context"
+	"errors"
+
+	"${this.goModule}/src/domain/logger"
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/domain/repositories"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// Usecase handles ${this.moduleNameLower} business logic
+type Usecase struct {
+	repo   repositories.${this.moduleNamePascal}Repository
+	logger logger.Logger
+}
+
+// NewUsecase creates a new ${this.moduleNameLower} usecase
+func NewUsecase(repo repositories.${this.moduleNamePascal}Repository, logger logger.Logger) *Usecase {
+	return &Usecase{
+		repo:   repo,
+		logger: logger,
+	}
+}
+
+// Create creates a new ${this.moduleNameLower}
+func (u *Usecase) Create(ctx context.Context, name, description string) (*models.${this.moduleNamePascal}Model, error) {
+	model := models.New${this.moduleNamePascal}Model(name, description)
+	
+	if err := u.repo.Create(ctx, model); err != nil {
+		u.logger.Error("${this.moduleNamePascal}Usecase", "Failed to create ${this.moduleNameLower}", err)
+		return nil, err
+	}
+
+	u.logger.Info("${this.moduleNamePascal}Usecase", "${this.moduleNamePascal} created: "+model.ID.String())
+	return model, nil
+}
+
+// Update updates an existing ${this.moduleNameLower}
+func (u *Usecase) Update(ctx context.Context, id uuid.UUID, name, description string) (*models.${this.moduleNamePascal}Model, error) {
+	model, err := u.repo.LoadById(ctx, id)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.New("${this.moduleNameLower} not found")
+		}
+		u.logger.Error("${this.moduleNamePascal}Usecase", "Failed to find ${this.moduleNameLower}", err)
+		return nil, err
+	}
+
+	model.Name = name
+	model.Description = description
+
+	if err := u.repo.Update(ctx, model); err != nil {
+		u.logger.Error("${this.moduleNamePascal}Usecase", "Failed to update ${this.moduleNameLower}", err)
+		return nil, err
+	}
+
+	u.logger.Info("${this.moduleNamePascal}Usecase", "${this.moduleNamePascal} updated: "+id.String())
+	return model, nil
+}
+
+// Delete soft deletes a ${this.moduleNameLower}
+func (u *Usecase) Delete(ctx context.Context, id uuid.UUID) error {
+	if err := u.repo.Delete(ctx, id); err != nil {
+		u.logger.Error("${this.moduleNamePascal}Usecase", "Failed to delete ${this.moduleNameLower}", err)
+		return err
+	}
+
+	u.logger.Info("${this.moduleNamePascal}Usecase", "${this.moduleNamePascal} deleted: "+id.String())
+	return nil
+}
+
+// GetById gets a ${this.moduleNameLower} by ID
+func (u *Usecase) GetById(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error) {
+	model, err := u.repo.GetById(ctx, id)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.New("${this.moduleNameLower} not found")
+		}
+		u.logger.Error("${this.moduleNamePascal}Usecase", "Failed to find ${this.moduleNameLower}", err)
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetAll gets all ${this.moduleNameLower}s with filtering and pagination
+func (u *Usecase) GetAll(ctx context.Context, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error) {
+	items, total, err := u.repo.GetAll(ctx, filter)
+	if err != nil {
+		u.logger.Error("${this.moduleNamePascal}Usecase", "Failed to get ${this.moduleNameLower}s", err)
+		return nil, 0, err
+	}
+	return items, total, nil
+}
+
+// LoadById loads a ${this.moduleNameLower} by ID
+func (u *Usecase) LoadById(ctx context.Context, id uuid.UUID) (*models.${this.moduleNamePascal}Model, error) {
+	return u.repo.LoadById(ctx, id)
+}
+
+// LoadAll loads all ${this.moduleNameLower}s without pagination
+func (u *Usecase) LoadAll(ctx context.Context, filter *models.${this.moduleNamePascal}Filter) ([]models.${this.moduleNamePascal}Model, int64, error) {
+	return u.repo.LoadAll(ctx, filter)
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Gin Controller
+  // ============================================
+
+  getControllerContent() {
+    return `package ${this.moduleNameLower}
+
+import (
+	"net/http"
+	"strconv"
+
+	"${this.goModule}/src/domain/dtos"
+	"${this.goModule}/src/domain/logger"
+	"${this.goModule}/src/domain/models"
+	"${this.goModule}/src/infrastructure/common/response"
+	"${this.goModule}/src/shared/utils"
+	${this.moduleNameCamel}Usecase "${this.goModule}/src/usecases/${this.moduleNameLower}"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+const controllerName = "${this.moduleNamePascal}Controller"
+
+// Controller handles ${this.moduleNameLower} HTTP requests
+type Controller struct {
+	usecase *${this.moduleNameCamel}Usecase.Usecase
+	logger  logger.Logger
+}
+
+// NewController creates a new ${this.moduleNameLower} controller
+func NewController(usecase *${this.moduleNameCamel}Usecase.Usecase, logger logger.Logger) *Controller {
+	return &Controller{
+		usecase: usecase,
+		logger:  logger,
+	}
+}
+
+// Create creates a new ${this.moduleNameLower}
+// @Summary Create a new ${this.moduleNameLower}
+// @Tags ${this.moduleNamePascal}
+// @Accept json
+// @Produce json
+// @Param request body dtos.Create${this.moduleNamePascal}Request true "Create ${this.moduleNamePascal} Request"
+// @Success 201 {object} response.Response{data=dtos.${this.moduleNamePascal}Response}
+// @Failure 400 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /api/v1/${this.moduleNameSnake}s [post]
+func (c *Controller) Create(ctx *gin.Context) {
+	var req dtos.Create${this.moduleNamePascal}Request
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.ValidationError(ctx, err.Error())
+		return
+	}
+
+	model, err := c.usecase.Create(ctx.Request.Context(), req.Name, req.Description)
+	if err != nil {
+		c.logger.Error(controllerName, "Failed to create ${this.moduleNameLower}", err)
+		response.Error(ctx, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	response.Success(ctx, http.StatusCreated, modelToResponse(model))
+}
+
+// GetByID gets a ${this.moduleNameLower} by ID
+// @Summary Get a ${this.moduleNameLower} by ID
+// @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.moduleNameSnake}s/{id} [get]
+func (c *Controller) GetByID(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.GetById(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))
+}
+
+// GetAll gets all ${this.moduleNameLower}s with pagination
+// @Summary Get all ${this.moduleNameLower}s
+// @Tags ${this.moduleNamePascal}
+// @Produce json
+// @Param page query int false "Page number" default(1)
+// @Param page_size query int false "Page size" default(10)
+// @Param search query string false "Search term"
+// @Success 200 {object} response.Response{data=[]dtos.${this.moduleNamePascal}Response}
+// @Failure 500 {object} response.Response
+// @Router /api/v1/${this.moduleNameSnake}s [get]
+func (c *Controller) GetAll(ctx *gin.Context) {
+	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
+	pageSize, _ := strconv.Atoi(ctx.DefaultQuery("page_size", "10"))
+	search := ctx.Query("search")
+
+	filter := &models.${this.moduleNamePascal}Filter{
+		QueryParams: models.QueryParams{
+			Paginate: &models.Paginate{
+				Page:  page,
+				Limit: pageSize,
+			},
+		},
+	}
+
+	if search != "" {
+		filter.Search = &models.Search{
+			SearchField: []string{"name", "description"},
+			Q:           search,
+		}
+	}
+
+	items, total, err := c.usecase.GetAll(ctx.Request.Context(), filter)
+	if err != nil {
+		c.logger.Error(controllerName, "Failed to get ${this.moduleNameLower}s", err)
+		response.Error(ctx, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	totalPage := int(total) / pageSize
+	if int(total)%pageSize > 0 {
+		totalPage++
+	}
+
+	response.SuccessWithMeta(ctx, http.StatusOK, modelsToResponse(items), &response.Meta{
+		Page:      page,
+		PageSize:  pageSize,
+		Total:     total,
+		TotalPage: totalPage,
+	})
+}
+
+// Update updates an existing ${this.moduleNameLower}
+// @Summary Update a ${this.moduleNameLower}
+// @Tags ${this.moduleNamePascal}
+// @Accept json
+// @Produce json
+// @Param id path string true "${this.moduleNamePascal} ID"
+// @Param request body dtos.Update${this.moduleNamePascal}Request true "Update ${this.moduleNamePascal} Request"
+// @Success 200 {object} response.Response{data=dtos.${this.moduleNamePascal}Response}
+// @Failure 400 {object} response.Response
+// @Failure 404 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /api/v1/${this.moduleNameSnake}s/{id} [put]
+func (c *Controller) Update(ctx *gin.Context) {
+	id, err := uuid.Parse(ctx.Param("id"))
+	if err != nil {
+		response.Error(ctx, http.StatusBadRequest, "Invalid ID format")
+		return
+	}
+
+	var req dtos.Update${this.moduleNamePascal}Request
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.ValidationError(ctx, err.Error())
+		return
+	}
+
+	model, err := c.usecase.Update(ctx.Request.Context(), id, req.Name, req.Description)
+	if err != nil {
+		if appErr, ok := utils.IsAppError(err); ok {
+			response.Error(ctx, appErr.Code, appErr.Message)
+			return
+		}
+		c.logger.Error(controllerName, "Failed to update ${this.moduleNameLower}", err)
+		response.Error(ctx, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	response.Success(ctx, http.StatusOK, modelToResponse(model))
+}
+
+// Delete deletes a ${this.moduleNameLower}
+// @Summary Delete a ${this.moduleNameLower}
+// @Tags ${this.moduleNamePascal}
+// @Produce json
+// @Param id path string true "${this.moduleNamePascal} ID"
+// @Success 200 {object} response.Response
+// @Failure 400 {object} response.Response
+// @Failure 500 {object} response.Response
+// @Router /api/v1/${this.moduleNameSnake}s/{id} [delete]
+func (c *Controller) Delete(ctx *gin.Context) {
+	id, err := uuid.Parse(ctx.Param("id"))
+	if err != nil {
+		response.Error(ctx, http.StatusBadRequest, "Invalid ID format")
+		return
+	}
+
+	if err := c.usecase.Delete(ctx.Request.Context(), id); err != nil {
+		if appErr, ok := utils.IsAppError(err); ok {
+			response.Error(ctx, appErr.Code, appErr.Message)
+			return
+		}
+		c.logger.Error(controllerName, "Failed to delete ${this.moduleNameLower}", err)
+		response.Error(ctx, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	response.SuccessWithMessage(ctx, http.StatusOK, "${this.moduleNamePascal} deleted successfully")
+}
+
+// ============================================================================
+// Converters
+// ============================================================================
+
+const timeFormat = "2006-01-02T15:04:05Z07:00"
+
+func modelToResponse(m *models.${this.moduleNamePascal}Model) *dtos.${this.moduleNamePascal}Response {
+	if m == nil {
+		return nil
+	}
+	return &dtos.${this.moduleNamePascal}Response{
+		ID:          m.ID.String(),
+		Name:        m.Name,
+		Description: m.Description,
+		IsActive:    m.IsActive,
+		CreatedAt:   m.CreatedAt.Format(timeFormat),
+		UpdatedAt:   m.UpdatedAt.Format(timeFormat),
+	}
+}
+
+func modelsToResponse(items []models.${this.moduleNamePascal}Model) []*dtos.${this.moduleNamePascal}Response {
+	result := make([]*dtos.${this.moduleNamePascal}Response, len(items))
+	for i := range items {
+		result[i] = modelToResponse(&items[i])
+	}
+	return result
+}
+`;
+  }
+}
+
+module.exports = ModuleGenerator;