go-gin-cli 1.0.0

package/src/lib/utils/setup.js

@@ -0,0 +1,1626 @@
+#!/usr/bin/env node
+
+const fs = require("fs").promises;
+const path = require("path");
+const createFile = require("../shares/createFile");
+const createDir = require("../shares/createDir");
+const { COLORS } = require("../constants/index");
+
+/**
+ * ProjectSetup - Generates Go Clean Architecture project structure with Gin-Gonic
+ * Matching NestJS Clean Architecture pattern:
+ * 
+ * project/
+ * ├── src/
+ * │   ├── domain/
+ * │   │   ├── dtos/
+ * │   │   ├── logger/
+ * │   │   ├── repositories/
+ * │   │   └── models/
+ * │   ├── infrastructure/
+ * │   │   ├── common/
+ * │   │   ├── config/
+ * │   │   ├── controllers/
+ * │   │   ├── entities/
+ * │   │   ├── logger/
+ * │   │   ├── repositories/
+ * │   │   └── usecases-proxy/
+ * │   ├── usecases/
+ * │   ├── shared/utils/
+ * │   └── main.go
+ * ├── .env
+ * ├── go.mod
+ * ├── Makefile
+ * └── Dockerfile
+ */
+class ProjectSetup {
+  constructor(projectName, moduleName) {
+    this.projectName = projectName;
+    this.moduleName = moduleName;
+    this.rootDir = projectName;
+    this.srcDir = path.join(projectName, "src");
+    this.domainDir = path.join(this.srcDir, "domain");
+    this.infrastructureDir = path.join(this.srcDir, "infrastructure");
+  }
+
+  async execute() {
+    try {
+      console.log(
+        `${COLORS.YELLOW}Starting Go Gin-Gonic project setup...${COLORS.NC}`,
+      );
+
+      await createDir(this.rootDir);
+      await createDir(this.srcDir);
+
+      await this.setupDirectories();
+      await this.setupDomain();
+      await this.setupInfrastructure();
+      await this.setupUsecases();
+      await this.setupShared();
+      await this.setupMain();
+      await this.setupGoMod();
+      await this.setupEnvFiles();
+      await this.setupMakefile();
+      await this.setupDockerfile();
+
+      console.log(
+        `${COLORS.GREEN}Project setup completed successfully!${COLORS.NC}`,
+      );
+    } catch (error) {
+      console.error(
+        `${COLORS.RED}Error during setup:${COLORS.NC} ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async setupDirectories() {
+    // Domain directories (matching NestJS structure)
+    const domainDirs = ["dtos", "logger", "repositories", "models"];
+
+    // Infrastructure directories (matching NestJS structure)
+    const infrastructureDirs = [
+      "common/middleware",
+      "common/response",
+      "config/environment",
+      "config/database",
+      "controllers",
+      "entities",
+      "logger",
+      "repositories",
+      "usecases-proxy",
+    ];
+
+    // Other directories
+    const otherDirs = ["usecases", "shared/utils"];
+
+    // Create domain directories
+    for (const dir of domainDirs) {
+      await createDir(path.join(this.domainDir, dir));
+    }
+
+    // Create infrastructure directories
+    for (const dir of infrastructureDirs) {
+      await createDir(path.join(this.infrastructureDir, dir));
+    }
+
+    // Create other directories
+    for (const dir of otherDirs) {
+      await createDir(path.join(this.srcDir, dir));
+    }
+  }
+
+  async setupDomain() {
+    // Logger interface
+    await createFile(
+      path.join(this.domainDir, "logger/logger.go"),
+      this.getLoggerInterfaceContent(),
+    );
+
+    // Base model
+    await createFile(
+      path.join(this.domainDir, "models/base.go"),
+      this.getBaseModelContent(),
+    );
+
+    // Query model
+    await createFile(
+      path.join(this.domainDir, "models/query.go"),
+      this.getQueryModelContent(),
+    );
+
+    // Base repository interface
+    await createFile(
+      path.join(this.domainDir, "repositories/base.go"),
+      this.getBaseRepositoryInterfaceContent(),
+    );
+  }
+
+  async setupInfrastructure() {
+    // Common - Middleware
+    await createFile(
+      path.join(this.infrastructureDir, "common/middleware/logger.go"),
+      this.getLoggerMiddlewareContent(),
+    );
+
+    await createFile(
+      path.join(this.infrastructureDir, "common/middleware/recovery.go"),
+      this.getRecoveryMiddlewareContent(),
+    );
+
+    await createFile(
+      path.join(this.infrastructureDir, "common/middleware/cors.go"),
+      this.getCorsMiddlewareContent(),
+    );
+
+    // Common - Response
+    await createFile(
+      path.join(this.infrastructureDir, "common/response/response.go"),
+      this.getResponseContent(),
+    );
+
+    // Config - Environment
+    await createFile(
+      path.join(this.infrastructureDir, "config/environment/config.go"),
+      this.getEnvironmentConfigContent(),
+    );
+
+    // Config - Database
+    await createFile(
+      path.join(this.infrastructureDir, "config/database/postgres.go"),
+      this.getDatabaseConfigContent(),
+    );
+
+    // Logger service
+    await createFile(
+      path.join(this.infrastructureDir, "logger/logger.go"),
+      this.getLoggerServiceContent(),
+    );
+
+    // Repositories module
+    await createFile(
+      path.join(this.infrastructureDir, "repositories/repositories.go"),
+      this.getRepositoriesModuleContent(),
+    );
+
+    // Usecases proxy
+    await createFile(
+      path.join(this.infrastructureDir, "usecases-proxy/usecases_proxy.go"),
+      this.getUsecasesProxyContent(),
+    );
+
+    // Router
+    await createFile(
+      path.join(this.infrastructureDir, "controllers/router.go"),
+      this.getRouterContent(),
+    );
+  }
+
+  async setupUsecases() {
+    await createFile(
+      path.join(this.srcDir, "usecases/base.go"),
+      this.getBaseUsecaseContent(),
+    );
+  }
+
+  async setupShared() {
+    await createFile(
+      path.join(this.srcDir, "shared/utils/query.go"),
+      this.getQueryUtilContent(),
+    );
+
+    await createFile(
+      path.join(this.srcDir, "shared/utils/validator.go"),
+      this.getValidatorUtilContent(),
+    );
+  }
+
+  async setupMain() {
+    await createFile(path.join(this.srcDir, "main.go"), this.getMainContent());
+
+    await createFile(
+      path.join(this.srcDir, "app.go"),
+      this.getAppModuleContent(),
+    );
+  }
+
+  async setupGoMod() {
+    await createFile(path.join(this.rootDir, "go.mod"), this.getGoModContent());
+  }
+
+  async setupEnvFiles() {
+    await createFile(path.join(this.rootDir, ".env"), this.getEnvContent());
+
+    await createFile(
+      path.join(this.rootDir, ".env.example"),
+      this.getEnvContent(),
+    );
+
+    await createFile(
+      path.join(this.rootDir, ".gitignore"),
+      this.getGitignoreContent(),
+    );
+  }
+
+  async setupMakefile() {
+    await createFile(
+      path.join(this.rootDir, "Makefile"),
+      this.getMakefileContent(),
+    );
+
+    // Air config for hot reload
+    await createFile(
+      path.join(this.rootDir, ".air.toml"),
+      this.getAirConfigContent(),
+    );
+  }
+
+  async setupDockerfile() {
+    await createFile(
+      path.join(this.rootDir, "Dockerfile"),
+      this.getDockerfileContent(),
+    );
+
+    await createFile(
+      path.join(this.rootDir, "docker-compose.yml"),
+      this.getDockerComposeContent(),
+    );
+  }
+
+  // ============================================
+  // Content Generators - Domain
+  // ============================================
+
+  getLoggerInterfaceContent() {
+    return `package logger
+
+// Logger defines the application logger interface
+type Logger interface {
+	Debug(context string, message string)
+	Info(context string, message string)
+	Warn(context string, message string)
+	Error(context string, message string, err error)
+	Fatal(context string, message string, err error)
+}
+`;
+  }
+
+  getBaseModelContent() {
+    return `package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// BaseModel contains common fields for all models
+type BaseModel struct {
+	ID        uuid.UUID  \`json:"id"\`
+	CreatedAt time.Time  \`json:"created_at"\`
+	UpdatedAt time.Time  \`json:"updated_at"\`
+	DeletedAt *time.Time \`json:"deleted_at,omitempty"\`
+	IsActive  bool       \`json:"is_active"\`
+}
+
+// NewBaseModel creates a new base model with default values
+func NewBaseModel() BaseModel {
+	return BaseModel{
+		ID:        uuid.New(),
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+		IsActive:  true,
+	}
+}
+`;
+  }
+
+  getQueryModelContent() {
+    return `package models
+
+// QueryParams represents common query parameters
+type QueryParams struct {
+	DateFilter *DateFilter \`json:"date_filter,omitempty"\`
+	Search     *Search     \`json:"search,omitempty"\`
+	Sort       int         \`json:"sort,omitempty"\`
+	Paginate   *Paginate   \`json:"paginate,omitempty"\`
+	Condition  []Condition \`json:"condition,omitempty"\`
+	InNumber   []InNumber  \`json:"in_number,omitempty"\`
+	InString   []InString  \`json:"in_string,omitempty"\`
+	Joins      []string    \`json:"joins,omitempty"\`
+	Select     []string    \`json:"select,omitempty"\`
+}
+
+// DateFilter represents date range filter
+type DateFilter struct {
+	StartDate string \`json:"start_date"\`
+	EndDate   string \`json:"end_date"\`
+}
+
+// Search represents search parameters
+type Search struct {
+	SearchField []string \`json:"search_field"\`
+	Q           string   \`json:"q"\`
+}
+
+// Paginate represents pagination parameters
+type Paginate struct {
+	Limit int \`json:"limit"\`
+	Page  int \`json:"page"\`
+}
+
+// Condition represents a single condition
+type Condition struct {
+	Field string \`json:"field"\`
+	Value string \`json:"value"\`
+}
+
+// InNumber represents IN clause for numbers
+type InNumber struct {
+	Field string \`json:"field"\`
+	Value []int  \`json:"value"\`
+}
+
+// InString represents IN clause for strings
+type InString struct {
+	Field string   \`json:"field"\`
+	Value []string \`json:"value"\`
+}
+
+// GetOffset calculates offset for pagination
+func (p *Paginate) GetOffset() int {
+	if p == nil || p.Page < 1 {
+		return 0
+	}
+	return (p.Page - 1) * p.GetLimit()
+}
+
+// GetLimit returns limit with default value
+func (p *Paginate) GetLimit() int {
+	if p == nil || p.Limit < 1 {
+		return 10
+	}
+	if p.Limit > 100 {
+		return 100
+	}
+	return p.Limit
+}
+`;
+  }
+
+  getBaseRepositoryInterfaceContent() {
+    return `package repositories
+
+import (
+	"context"
+
+	"${this.moduleName}/src/domain/models"
+	"github.com/google/uuid"
+)
+
+// BaseRepository defines common repository operations
+type BaseRepository[T any] interface {
+	Create(ctx context.Context, entity *T) error
+	Update(ctx context.Context, entity *T) error
+	Delete(ctx context.Context, id uuid.UUID) error
+	FindByID(ctx context.Context, id uuid.UUID) (*T, error)
+	FindAll(ctx context.Context, params *models.QueryParams) ([]T, int64, error)
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Infrastructure
+  // ============================================
+
+  getLoggerMiddlewareContent() {
+    return `package middleware
+
+import (
+	"time"
+
+	"${this.moduleName}/src/domain/logger"
+
+	"github.com/gin-gonic/gin"
+)
+
+// LoggerMiddleware logs HTTP requests
+func LoggerMiddleware(log logger.Logger) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		path := c.Request.URL.Path
+		raw := c.Request.URL.RawQuery
+
+		c.Next()
+
+		latency := time.Since(start)
+		statusCode := c.Writer.Status()
+		clientIP := c.ClientIP()
+		method := c.Request.Method
+
+		if raw != "" {
+			path = path + "?" + raw
+		}
+
+		log.Info("HTTP Request",
+			"method="+method+
+				" path="+path+
+				" status="+string(rune(statusCode))+
+				" latency="+latency.String()+
+				" ip="+clientIP,
+		)
+	}
+}
+`;
+  }
+
+  getRecoveryMiddlewareContent() {
+    return `package middleware
+
+import (
+	"net/http"
+	"runtime/debug"
+
+	"${this.moduleName}/src/domain/logger"
+	"${this.moduleName}/src/infrastructure/common/response"
+
+	"github.com/gin-gonic/gin"
+)
+
+// RecoveryMiddleware recovers from panics and returns 500 error
+func RecoveryMiddleware(log logger.Logger) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		defer func() {
+			if r := recover(); r != nil {
+				log.Error("Panic recovered", "error", nil)
+				log.Error("Stack trace", string(debug.Stack()), nil)
+				response.Error(c, http.StatusInternalServerError, "Internal server error")
+				c.Abort()
+			}
+		}()
+		c.Next()
+	}
+}
+`;
+  }
+
+  getCorsMiddlewareContent() {
+    return `package middleware
+
+import (
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+)
+
+// CorsMiddleware returns CORS middleware configuration
+func CorsMiddleware() gin.HandlerFunc {
+	return cors.New(cors.Config{
+		AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
+		AllowHeaders:     []string{"Origin", "Content-Type", "Accept", "Authorization"},
+		ExposeHeaders:    []string{"Content-Length"},
+		AllowCredentials: true,
+	})
+}
+`;
+  }
+
+  getResponseContent() {
+    return `package response
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+// Response represents a standard API response
+type Response struct {
+	Success bool        \`json:"success"\`
+	Message string      \`json:"message,omitempty"\`
+	Data    interface{} \`json:"data,omitempty"\`
+	Meta    *Meta       \`json:"meta,omitempty"\`
+}
+
+// Meta represents pagination metadata
+type Meta struct {
+	Page      int   \`json:"page"\`
+	PageSize  int   \`json:"page_size"\`
+	Total     int64 \`json:"total"\`
+	TotalPage int   \`json:"total_page"\`
+}
+
+// Success sends a success response
+func Success(c *gin.Context, statusCode int, data interface{}) {
+	c.JSON(statusCode, Response{
+		Success: true,
+		Data:    data,
+	})
+}
+
+// SuccessWithMeta sends a success response with pagination meta
+func SuccessWithMeta(c *gin.Context, statusCode int, data interface{}, meta *Meta) {
+	c.JSON(statusCode, Response{
+		Success: true,
+		Data:    data,
+		Meta:    meta,
+	})
+}
+
+// SuccessWithMessage sends a success response with message
+func SuccessWithMessage(c *gin.Context, statusCode int, message string) {
+	c.JSON(statusCode, Response{
+		Success: true,
+		Message: message,
+	})
+}
+
+// Error sends an error response
+func Error(c *gin.Context, statusCode int, message string) {
+	c.JSON(statusCode, Response{
+		Success: false,
+		Message: message,
+	})
+}
+
+// ValidationError sends a validation error response
+func ValidationError(c *gin.Context, errors interface{}) {
+	c.JSON(400, Response{
+		Success: false,
+		Message: "Validation failed",
+		Data:    errors,
+	})
+}
+`;
+  }
+
+  getEnvironmentConfigContent() {
+    return `package environment
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+
+	"github.com/joho/godotenv"
+)
+
+// Config holds all configuration
+type Config struct {
+	App      AppConfig
+	Server   ServerConfig
+	Database DatabaseConfig
+}
+
+// AppConfig holds application configuration
+type AppConfig struct {
+	Name        string
+	Environment string
+	Debug       bool
+}
+
+// ServerConfig holds server configuration
+type ServerConfig struct {
+	Host string
+	Port int
+}
+
+// DatabaseConfig holds database configuration
+type DatabaseConfig struct {
+	Host     string
+	Port     int
+	User     string
+	Password string
+	DBName   string
+	SSLMode  string
+	TimeZone string
+}
+
+// Load loads configuration from environment
+func Load() (*Config, error) {
+	env := os.Getenv("APP_ENV")
+	if env == "" {
+		env = "development"
+	}
+
+	envFile := ".env"
+	if env != "production" {
+		envFile = fmt.Sprintf(".env.%s", env)
+		if _, err := os.Stat(envFile); os.IsNotExist(err) {
+			envFile = ".env"
+		}
+	}
+
+	if err := godotenv.Load(envFile); err != nil {
+		if env != "production" {
+			return nil, fmt.Errorf("error loading %s file: %w", envFile, err)
+		}
+	}
+
+	port, _ := strconv.Atoi(getEnv("SERVER_PORT", "8080"))
+	dbPort, _ := strconv.Atoi(getEnv("DB_PORT", "5432"))
+	debug, _ := strconv.ParseBool(getEnv("APP_DEBUG", "false"))
+
+	return &Config{
+		App: AppConfig{
+			Name:        getEnv("APP_NAME", "${this.projectName}"),
+			Environment: env,
+			Debug:       debug,
+		},
+		Server: ServerConfig{
+			Host: getEnv("SERVER_HOST", "0.0.0.0"),
+			Port: port,
+		},
+		Database: DatabaseConfig{
+			Host:     getEnv("DB_HOST", "localhost"),
+			Port:     dbPort,
+			User:     getEnv("DB_USER", "postgres"),
+			Password: getEnv("DB_PASSWORD", ""),
+			DBName:   getEnv("DB_NAME", "${this.projectName.replace(/-/g, "_")}"),
+			SSLMode:  getEnv("DB_SSL_MODE", "disable"),
+			TimeZone: getEnv("DB_TIMEZONE", "UTC"),
+		},
+	}, nil
+}
+
+func getEnv(key, defaultValue string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return defaultValue
+}
+`;
+  }
+
+  getDatabaseConfigContent() {
+    return `package database
+
+import (
+	"fmt"
+	"time"
+
+	"${this.moduleName}/src/infrastructure/config/environment"
+
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+// NewPostgresConnection creates a new PostgreSQL connection
+func NewPostgresConnection(cfg environment.DatabaseConfig) (*gorm.DB, error) {
+	dsn := fmt.Sprintf(
+		"host=%s port=%d user=%s password=%s dbname=%s sslmode=%s TimeZone=%s",
+		cfg.Host,
+		cfg.Port,
+		cfg.User,
+		cfg.Password,
+		cfg.DBName,
+		cfg.SSLMode,
+		cfg.TimeZone,
+	)
+
+	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Info),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to database: %w", err)
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get database instance: %w", err)
+	}
+
+	// Connection pool settings
+	sqlDB.SetMaxIdleConns(10)
+	sqlDB.SetMaxOpenConns(100)
+	sqlDB.SetConnMaxLifetime(time.Hour)
+
+	return db, nil
+}
+
+// AutoMigrate runs auto migration for given models
+func AutoMigrate(db *gorm.DB, models ...interface{}) error {
+	return db.AutoMigrate(models...)
+}
+`;
+  }
+
+  getLoggerServiceContent() {
+    return `package logger
+
+import (
+	"os"
+
+	domainLogger "${this.moduleName}/src/domain/logger"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// ZapLogger implements domain logger interface
+type ZapLogger struct {
+	*zap.SugaredLogger
+}
+
+// NewLogger creates a new logger instance
+func NewLogger(env string) *ZapLogger {
+	var config zap.Config
+
+	if env == "production" {
+		config = zap.NewProductionConfig()
+		config.EncoderConfig.TimeKey = "timestamp"
+		config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+	} else {
+		config = zap.NewDevelopmentConfig()
+		config.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
+	}
+
+	config.OutputPaths = []string{"stdout"}
+	config.ErrorOutputPaths = []string{"stderr"}
+
+	logger, err := config.Build()
+	if err != nil {
+		panic(err)
+	}
+
+	return &ZapLogger{logger.Sugar()}
+}
+
+// Ensure ZapLogger implements Logger interface
+var _ domainLogger.Logger = (*ZapLogger)(nil)
+
+func (l *ZapLogger) Debug(context string, message string) {
+	l.SugaredLogger.Debugw(message, "context", context)
+}
+
+func (l *ZapLogger) Info(context string, message string) {
+	l.SugaredLogger.Infow(message, "context", context)
+}
+
+func (l *ZapLogger) Warn(context string, message string) {
+	l.SugaredLogger.Warnw(message, "context", context)
+}
+
+func (l *ZapLogger) Error(context string, message string, err error) {
+	l.SugaredLogger.Errorw(message, "context", context, "error", err)
+}
+
+func (l *ZapLogger) Fatal(context string, message string, err error) {
+	l.SugaredLogger.Fatalw(message, "context", context, "error", err)
+	os.Exit(1)
+}
+
+func (l *ZapLogger) Sync() {
+	_ = l.SugaredLogger.Sync()
+}
+`;
+  }
+
+  getRepositoriesModuleContent() {
+    return `package repositories
+
+import (
+	"gorm.io/gorm"
+)
+
+// RepositoriesModule holds all repositories
+type RepositoriesModule struct {
+	db *gorm.DB
+	// Add your repositories here
+}
+
+// NewRepositoriesModule creates a new repositories module
+func NewRepositoriesModule(db *gorm.DB) *RepositoriesModule {
+	return &RepositoriesModule{
+		db: db,
+		// Initialize your repositories here
+	}
+}
+`;
+  }
+
+  getUsecasesProxyContent() {
+    return `package usecasesproxy
+
+import (
+	"${this.moduleName}/src/domain/logger"
+	"${this.moduleName}/src/infrastructure/repositories"
+)
+
+// UsecasesProxy holds all usecases
+type UsecasesProxy struct {
+	Logger       logger.Logger
+	Repositories *repositories.RepositoriesModule
+	// Add your usecases here
+	// UserUsecase *usecases.UserUsecase
+}
+
+// NewUsecasesProxy creates a new usecases proxy
+func NewUsecasesProxy(logger logger.Logger, repos *repositories.RepositoriesModule) *UsecasesProxy {
+	return &UsecasesProxy{
+		Logger:       logger,
+		Repositories: repos,
+		// Initialize your usecases here
+		// UserUsecase: usecases.NewUserUsecase(repos.UserRepository, logger),
+	}
+}
+`;
+  }
+
+  getRouterContent() {
+    return `package controllers
+
+import (
+	"${this.moduleName}/src/domain/logger"
+	"${this.moduleName}/src/infrastructure/common/middleware"
+	usecasesproxy "${this.moduleName}/src/infrastructure/usecases-proxy"
+
+	"github.com/gin-gonic/gin"
+)
+
+// Router holds the gin engine and dependencies
+type Router struct {
+	engine        *gin.Engine
+	logger        logger.Logger
+	usecasesProxy *usecasesproxy.UsecasesProxy
+}
+
+// NewRouter creates a new router instance
+func NewRouter(logger logger.Logger, usecasesProxy *usecasesproxy.UsecasesProxy, debug bool) *Router {
+	if !debug {
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	engine := gin.New()
+
+	// Apply global middleware
+	engine.Use(middleware.CorsMiddleware())
+	engine.Use(middleware.RecoveryMiddleware(logger))
+	engine.Use(middleware.LoggerMiddleware(logger))
+
+	return &Router{
+		engine:        engine,
+		logger:        logger,
+		usecasesProxy: usecasesProxy,
+	}
+}
+
+// SetupRoutes configures all routes
+func (r *Router) SetupRoutes() {
+	// Health check
+	r.engine.GET("/health", func(c *gin.Context) {
+		c.JSON(200, gin.H{"status": "ok"})
+	})
+
+	// API v1 group
+	v1 := r.engine.Group("/api/v1")
+	{
+		// Register your routes here
+		_ = v1 // Remove this line when adding routes
+	}
+}
+
+// GetEngine returns the gin engine
+func (r *Router) GetEngine() *gin.Engine {
+	return r.engine
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Usecases
+  // ============================================
+
+  getBaseUsecaseContent() {
+    return `package usecases
+
+import (
+	"context"
+
+	"${this.moduleName}/src/domain/models"
+	"github.com/google/uuid"
+)
+
+// BaseUsecase defines common usecase operations
+type BaseUsecase[T any, CreateReq any, UpdateReq any] interface {
+	Create(ctx context.Context, req *CreateReq) (*T, error)
+	Update(ctx context.Context, id uuid.UUID, req *UpdateReq) (*T, error)
+	Delete(ctx context.Context, id uuid.UUID) error
+	GetByID(ctx context.Context, id uuid.UUID) (*T, error)
+	GetAll(ctx context.Context, params *models.QueryParams) ([]T, int64, error)
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Shared Utils
+  // ============================================
+
+  getQueryUtilContent() {
+    return `package utils
+
+import (
+	"fmt"
+	"time"
+
+	"${this.moduleName}/src/domain/models"
+
+	"gorm.io/gorm"
+)
+
+// QueryResult represents query result with pagination
+type QueryResult[T any] struct {
+	Data  []T
+	Total int64
+}
+
+// BuildQuery builds a GORM query based on provided parameters
+func BuildQuery[T any](db *gorm.DB, params *models.QueryParams) *gorm.DB {
+	query := db.Model(new(T)).Where("is_active = ?", true)
+
+	if params == nil {
+		return query.Order("created_at DESC")
+	}
+
+	// Handle date filtering
+	if params.DateFilter != nil && params.DateFilter.StartDate != "" && params.DateFilter.EndDate != "" {
+		startDate, err1 := time.Parse("2006-01-02", params.DateFilter.StartDate)
+		endDate, err2 := time.Parse("2006-01-02", params.DateFilter.EndDate)
+		if err1 == nil && err2 == nil {
+			startDate = time.Date(startDate.Year(), startDate.Month(), startDate.Day(), 0, 0, 0, 0, time.UTC)
+			endDate = time.Date(endDate.Year(), endDate.Month(), endDate.Day(), 23, 59, 59, 999999999, time.UTC)
+			query = query.Where("created_at BETWEEN ? AND ?", startDate, endDate)
+		}
+	}
+
+	// Handle search
+	if params.Search != nil && len(params.Search.SearchField) > 0 && params.Search.Q != "" {
+		var conditions []string
+		for _, field := range params.Search.SearchField {
+			conditions = append(conditions, fmt.Sprintf("%s ILIKE ?", field))
+		}
+		searchTerm := "%" + params.Search.Q + "%"
+		args := make([]interface{}, len(conditions))
+		for i := range args {
+			args[i] = searchTerm
+		}
+		query = query.Where("("+joinOr(conditions)+")", args...)
+	}
+
+	// Handle conditions
+	if len(params.Condition) > 0 {
+		for _, cond := range params.Condition {
+			query = query.Where(fmt.Sprintf("%s = ?", cond.Field), cond.Value)
+		}
+	}
+
+	// Handle IN clauses for numbers
+	if len(params.InNumber) > 0 {
+		for _, in := range params.InNumber {
+			query = query.Where(fmt.Sprintf("%s IN ?", in.Field), in.Value)
+		}
+	}
+
+	// Handle IN clauses for strings
+	if len(params.InString) > 0 {
+		for _, in := range params.InString {
+			query = query.Where(fmt.Sprintf("%s IN ?", in.Field), in.Value)
+		}
+	}
+
+	// Handle sorting
+	if params.Sort != 0 {
+		if params.Sort == 1 {
+			query = query.Order("created_at ASC")
+		} else {
+			query = query.Order("created_at DESC")
+		}
+	} else {
+		query = query.Order("created_at DESC")
+	}
+
+	return query
+}
+
+// ExecuteQuery executes query with pagination
+func ExecuteQuery[T any](db *gorm.DB, params *models.QueryParams) (*QueryResult[T], error) {
+	var entities []T
+	var total int64
+
+	query := BuildQuery[T](db, params)
+
+	// Count total
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// Apply pagination
+	if params != nil && params.Paginate != nil {
+		offset := params.Paginate.GetOffset()
+		limit := params.Paginate.GetLimit()
+		query = query.Offset(offset).Limit(limit)
+	}
+
+	if err := query.Find(&entities).Error; err != nil {
+		return nil, err
+	}
+
+	return &QueryResult[T]{
+		Data:  entities,
+		Total: total,
+	}, nil
+}
+
+func joinOr(conditions []string) string {
+	result := ""
+	for i, cond := range conditions {
+		if i > 0 {
+			result += " OR "
+		}
+		result += cond
+	}
+	return result
+}
+`;
+  }
+
+  getValidatorUtilContent() {
+    return `package utils
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/go-playground/validator/v10"
+)
+
+var validate *validator.Validate
+
+func init() {
+	validate = validator.New()
+}
+
+// ValidationError represents a validation error
+type ValidationError struct {
+	Field   string \`json:"field"\`
+	Message string \`json:"message"\`
+}
+
+// ValidateStruct validates a struct using go-playground/validator
+func ValidateStruct(s interface{}) []ValidationError {
+	var validationErrors []ValidationError
+
+	err := validate.Struct(s)
+	if err != nil {
+		for _, err := range err.(validator.ValidationErrors) {
+			validationErrors = append(validationErrors, ValidationError{
+				Field:   err.Field(),
+				Message: getErrorMessage(err),
+			})
+		}
+	}
+
+	return validationErrors
+}
+
+func getErrorMessage(err validator.FieldError) string {
+	switch err.Tag() {
+	case "required":
+		return fmt.Sprintf("%s is required", err.Field())
+	case "email":
+		return fmt.Sprintf("%s must be a valid email", err.Field())
+	case "min":
+		return fmt.Sprintf("%s must be at least %s characters", err.Field(), err.Param())
+	case "max":
+		return fmt.Sprintf("%s must be at most %s characters", err.Field(), err.Param())
+	case "uuid":
+		return fmt.Sprintf("%s must be a valid UUID", err.Field())
+	default:
+		return fmt.Sprintf("%s is invalid", err.Field())
+	}
+}
+
+// AppError represents an application error
+type AppError struct {
+	Code    int
+	Message string
+}
+
+func (e *AppError) Error() string {
+	return e.Message
+}
+
+// NewAppError creates a new application error
+func NewAppError(code int, message string) *AppError {
+	return &AppError{Code: code, Message: message}
+}
+
+// NotFoundError returns a not found error
+func NotFoundError(message string) error {
+	return NewAppError(404, message)
+}
+
+// BadRequestError returns a bad request error
+func BadRequestError(message string) error {
+	return NewAppError(400, message)
+}
+
+// InternalError returns an internal server error
+func InternalError(message string) error {
+	return NewAppError(500, message)
+}
+
+// ConflictError returns a conflict error
+func ConflictError(message string) error {
+	return NewAppError(409, message)
+}
+
+// IsAppError checks if error is an AppError and returns it
+func IsAppError(err error) (*AppError, bool) {
+	var appErr *AppError
+	if errors.As(err, &appErr) {
+		return appErr, true
+	}
+	return nil, false
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Main & App
+  // ============================================
+
+  getMainContent() {
+    return `package main
+
+import (
+	"log"
+
+	"${this.moduleName}/src/infrastructure/config/database"
+	"${this.moduleName}/src/infrastructure/config/environment"
+	infraLogger "${this.moduleName}/src/infrastructure/logger"
+)
+
+func main() {
+	// Load configuration
+	cfg, err := environment.Load()
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Initialize logger
+	logger := infraLogger.NewLogger(cfg.App.Environment)
+	defer logger.Sync()
+
+	// Initialize database
+	db, err := database.NewPostgresConnection(cfg.Database)
+	if err != nil {
+		logger.Fatal("main", "Failed to connect to database", err)
+	}
+
+	// Initialize and run application
+	app := NewApp(cfg, db, logger)
+	
+	if err := app.Run(); err != nil {
+		logger.Fatal("main", "Failed to start server", err)
+	}
+}
+`;
+  }
+
+  getAppModuleContent() {
+    return `package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"${this.moduleName}/src/infrastructure/config/environment"
+	"${this.moduleName}/src/infrastructure/controllers"
+	infraLogger "${this.moduleName}/src/infrastructure/logger"
+	"${this.moduleName}/src/infrastructure/repositories"
+	usecasesproxy "${this.moduleName}/src/infrastructure/usecases-proxy"
+
+	"gorm.io/gorm"
+)
+
+// App represents the application
+type App struct {
+	cfg    *environment.Config
+	db     *gorm.DB
+	logger *infraLogger.ZapLogger
+	router *controllers.Router
+	server *http.Server
+}
+
+// NewApp creates a new application instance
+func NewApp(cfg *environment.Config, db *gorm.DB, logger *infraLogger.ZapLogger) *App {
+	// Initialize modules
+	reposModule := repositories.NewRepositoriesModule(db)
+	usecasesProxy := usecasesproxy.NewUsecasesProxy(logger, reposModule)
+
+	// Create router
+	router := controllers.NewRouter(logger, usecasesProxy, cfg.App.Debug)
+	router.SetupRoutes()
+
+	// Create HTTP server
+	server := &http.Server{
+		Addr:         fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port),
+		Handler:      router.GetEngine(),
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+
+	return &App{
+		cfg:    cfg,
+		db:     db,
+		logger: logger,
+		router: router,
+		server: server,
+	}
+}
+
+// Run starts the application
+func (a *App) Run() error {
+	// Start HTTP server in goroutine
+	errChan := make(chan error, 1)
+	go func() {
+		a.logger.Info("HTTP Server", fmt.Sprintf("Starting server on %s", a.server.Addr))
+		if err := a.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			errChan <- err
+		}
+	}()
+
+	// Wait for interrupt signal
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	select {
+	case err := <-errChan:
+		return err
+	case <-quit:
+		a.logger.Info("app", "Shutting down server...")
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if err := a.server.Shutdown(ctx); err != nil {
+			a.logger.Error("app", "Server forced to shutdown", err)
+			return err
+		}
+		a.logger.Info("app", "Server exited properly")
+	}
+
+	return nil
+}
+`;
+  }
+
+  // ============================================
+  // Content Generators - Config Files
+  // ============================================
+
+  getGoModContent() {
+    return `module ${this.moduleName}
+
+go 1.21
+
+require (
+	github.com/gin-contrib/cors v1.5.0
+	github.com/gin-gonic/gin v1.9.1
+	github.com/go-playground/validator/v10 v10.16.0
+	github.com/google/uuid v1.5.0
+	github.com/joho/godotenv v1.5.1
+	go.uber.org/zap v1.26.0
+	gorm.io/driver/postgres v1.5.4
+	gorm.io/gorm v1.25.5
+)
+`;
+  }
+
+  getEnvContent() {
+    return `# Application
+APP_NAME=${this.projectName}
+APP_ENV=development
+APP_DEBUG=true
+
+# Server
+SERVER_HOST=0.0.0.0
+SERVER_PORT=8080
+
+# Database
+DB_HOST=localhost
+DB_PORT=5432
+DB_USER=postgres
+DB_PASSWORD=postgres
+DB_NAME=${this.projectName.replace(/-/g, "_")}
+DB_SSL_MODE=disable
+DB_TIMEZONE=UTC
+`;
+  }
+
+  getGitignoreContent() {
+    return `# Binaries
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+bin/
+build/
+
+# Test binary
+*.test
+
+# Output of the go coverage tool
+*.out
+coverage.html
+
+# Dependency directories
+vendor/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/
+
+# Generated proto files
+*.pb.go
+`;
+  }
+
+  getMakefileContent() {
+    return `# Variables
+APP_NAME := ${this.projectName}
+BUILD_DIR := build
+MAIN_PATH := src/main.go src/app.go
+
+# Go commands
+GOCMD := go
+GOBUILD := $(GOCMD) build
+GORUN := $(GOCMD) run
+GOTEST := $(GOCMD) test
+GOMOD := $(GOCMD) mod
+GOFMT := gofmt
+
+.PHONY: all build run test clean fmt lint tidy help
+
+all: build
+
+## build: Build the application
+build:
+	@echo "Building..."
+	@mkdir -p $(BUILD_DIR)
+	$(GOBUILD) -o $(BUILD_DIR)/$(APP_NAME) $(MAIN_PATH)
+
+## run: Run the application
+run:
+	@echo "Running..."
+	$(GORUN) $(MAIN_PATH)
+
+## dev: Run with hot reload (requires air: go install github.com/air-verse/air@latest)
+dev:
+	@echo "Starting development server with hot reload..."
+	@if command -v air > /dev/null 2>&1; then \
+		air; \
+	elif [ -f "$$(go env GOPATH)/bin/air" ]; then \
+		$$(go env GOPATH)/bin/air; \
+	else \
+		echo "Air not found. Installing..."; \
+		go install github.com/air-verse/air@latest; \
+		$$(go env GOPATH)/bin/air; \
+	fi
+
+## test: Run tests
+test:
+	@echo "Testing..."
+	$(GOTEST) -v ./...
+
+## test-coverage: Run tests with coverage
+test-coverage:
+	@echo "Testing with coverage..."
+	$(GOTEST) -coverprofile=coverage.out ./...
+	$(GOCMD) tool cover -html=coverage.out -o coverage.html
+
+## clean: Clean build files
+clean:
+	@echo "Cleaning..."
+	@rm -rf $(BUILD_DIR)
+	@rm -f coverage.out coverage.html
+
+## fmt: Format code
+fmt:
+	@echo "Formatting..."
+	$(GOFMT) -s -w .
+
+## lint: Run linter
+lint:
+	@echo "Linting..."
+	golangci-lint run
+
+## tidy: Tidy dependencies
+tidy:
+	@echo "Tidying dependencies..."
+	$(GOMOD) tidy
+
+## docker-build: Build Docker image
+docker-build:
+	@echo "Building Docker image..."
+	docker build -t $(APP_NAME):latest .
+
+## docker-run: Run Docker container
+docker-run:
+	@echo "Running Docker container..."
+	docker-compose up -d
+
+## docker-stop: Stop Docker container
+docker-stop:
+	@echo "Stopping Docker container..."
+	docker-compose down
+
+## help: Show this help
+help:
+	@echo "Usage: make [target]"
+	@echo ""
+	@echo "Targets:"
+	@sed -n 's/^##//p' \${MAKEFILE_LIST} | column -t -s ':' | sed -e 's/^/ /'
+`;
+  }
+
+  getAirConfigContent() {
+    return `# Air configuration for hot reload
+# Documentation: https://github.com/air-verse/air
+
+root = "."
+testdata_dir = "testdata"
+tmp_dir = "tmp"
+
+[build]
+  args_bin = []
+  bin = "./tmp/main"
+  cmd = "go build -o ./tmp/main ./src/main.go ./src/app.go"
+  delay = 1000
+  exclude_dir = ["assets", "tmp", "vendor", "testdata", "node_modules"]
+  exclude_file = []
+  exclude_regex = ["_test.go", ".*_templ.go"]
+  exclude_unchanged = false
+  follow_symlink = false
+  full_bin = ""
+  include_dir = []
+  include_ext = ["go", "tpl", "tmpl", "html"]
+  include_file = []
+  kill_delay = "2s"
+  log = "build-errors.log"
+  poll = false
+  poll_interval = 0
+  post_cmd = []
+  pre_cmd = []
+  rerun = false
+  rerun_delay = 500
+  send_interrupt = false
+  stop_on_error = false
+
+[color]
+  app = ""
+  build = "yellow"
+  main = "magenta"
+  runner = "green"
+  watcher = "cyan"
+
+[log]
+  main_only = false
+  time = false
+
+[misc]
+  clean_on_exit = false
+
+[screen]
+  clear_on_rebuild = false
+  keep_scroll = true
+`;
+  }
+
+  getDockerfileContent() {
+    return `# Build stage
+FROM golang:1.21-alpine AS builder
+
+WORKDIR /app
+
+# Install dependencies
+RUN apk add --no-cache git
+
+# Copy go mod files
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Copy source code
+COPY . .
+
+# Build the application
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main src/main.go src/app.go
+
+# Final stage
+FROM alpine:latest
+
+WORKDIR /app
+
+# Install ca-certificates for HTTPS
+RUN apk --no-cache add ca-certificates tzdata
+
+# Copy binary from builder
+COPY --from=builder /app/main .
+COPY --from=builder /app/.env.example .env
+
+# Expose HTTP port
+EXPOSE 8080
+
+# Run the application
+CMD ["./main"]
+`;
+  }
+
+  getDockerComposeContent() {
+    return `version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "8080:8080"
+    environment:
+      - APP_ENV=production
+      - SERVER_PORT=8080
+      - DB_HOST=postgres
+      - DB_PORT=5432
+      - DB_USER=postgres
+      - DB_PASSWORD=postgres
+      - DB_NAME=${this.projectName.replace(/-/g, "_")}
+    depends_on:
+      - postgres
+    networks:
+      - app-network
+
+  postgres:
+    image: postgres:15-alpine
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=${this.projectName.replace(/-/g, "_")}
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    networks:
+      - app-network
+
+volumes:
+  postgres-data:
+
+networks:
+  app-network:
+    driver: bridge
+`;
+  }
+}
+
+module.exports = ProjectSetup;