A powerful CLI tool that generates modern Go backend projects with Gin, GORM, JWT authentication, and enterprise-grade project structure.

• 🎯 Interactive CLI with beautiful terminal UI (using Bubble Tea)
• 🏗️ Modern Tech Stack: Gin web framework, GORM ORM, JWT auth
• 🗃️ Multiple Databases: PostgreSQL, MySQL, SQLite, MongoDB support
• 🔐 Authentication: JWT-based auth with bcrypt password hashing
• 📁 Enterprise Structure: Clean architecture with services, handlers, middleware
• 🐳 Docker Support: Dockerfile and docker-compose.yml generation
• 🧪 Testing: Unit test templates included
• 🔧 Auto-Migration: Database tables created automatically
• 🌍 Environment Config: .env file support with godotenv

• Go 1.21+ installed on your system
• Git (optional, for cloning)
• Database (PostgreSQL/MySQL/SQLite/MongoDB) - optional, projects can run without DB

# Clone the repository
git clone <repository-url>
cd go-backend-generator

# Install dependencies
go mod tidy

# Build the generator
go build -o go-backend-gen main.go

# Run the interactive generator
./go-backend-gen

# Or run directly with Go
go run main.go

# Add to system path
sudo cp go-backend-gen /usr/local/bin/

# Run
go-backend-gen

The generator will ask you:

1. Project Name: my-awesome-api
2. Go Module Name: github.com/username/my-awesome-api
3. Database Choice: PostgreSQL, MySQL, SQLite, MongoDB, or None
4. Features:
   • ✅ Authentication (JWT-based)
   • ✅ Docker Support
   • ✅ REST API (User CRUD)
   • ✅ Unit Tests

my-awesome-api/
├── cmd/server/main.go              # Application entry point
├── internal/
│   ├── api/
│   │   ├── handlers/               # HTTP handlers (Gin)
│   │   │   ├── health.go          # Health check endpoint
│   │   │   └── user.go            # User CRUD endpoints
│   │   ├── middleware/            # Auth middleware
│   │   └── routes/                # Route setup
│   ├── auth/                      # Authentication service
│   ├── config/                    # Configuration management
│   ├── database/                  # GORM database connection
│   ├── models/                    # Data models with GORM tags
│   ├── services/                  # Business logic layer
│   └── utils/                     # Utility functions
├── migrations/                    # Database migrations
├── .env                          # Environment variables
├── .env.example                  # Example environment file
├── Dockerfile                    # Docker configuration
├── docker-compose.yml            # Docker Compose setup
├── go.mod                        # Go dependencies
└── README.md                     # Project documentation

cd my-awesome-api

# Install dependencies
go mod tidy

# Set up environment (optional)
cp .env.example .env
# Edit .env with your database credentials

# Run the server
go run main.go

The generated project includes these endpoints:

# Health check
curl http://localhost:8080/health

# Register a new user
curl -X POST http://localhost:8080/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{
    "email": "john@example.com",
    "username": "johndoe",
    "password": "secretpassword",
    "first_name": "John",
    "last_name": "Doe"
  }'

# Login
curl -X POST http://localhost:8080/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "john@example.com",
    "password": "secretpassword"
  }'

# Get users (requires authentication)
curl -X GET http://localhost:8080/api/v1/users \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

If you enabled Docker support, you can run the generated project with:

# Build and run with Docker Compose
docker-compose up --build

# Or build manually
docker build -t my-awesome-api .
docker run -p 8080:8080 my-awesome-api

createdb my-awesome-api
export DATABASE_URL="postgres://localhost/my-awesome-api?sslmode=disable"

mysql -u root -p -e "CREATE DATABASE my_awesome_api;"
export DATABASE_URL="root:password@tcp(localhost:3306)/my_awesome_api"

# No setup needed - file will be created automatically
export DATABASE_URL="my-awesome-api.db"

Run tests in the generated project:

cd my-awesome-api
go test ./...

To modify the generator itself:

1. Edit Templates: Update templates in main.go
2. Add Features: Modify the ProjectConfig struct and generation logic
3. Test Changes: Run go run main.go to test your changes

The generated projects follow these patterns:

• Handlers: HTTP request/response logic in internal/api/handlers/
• Services: Business logic in internal/services/
• Models: Data structures in internal/models/
• Database: GORM setup in internal/database/
• Config: Environment configuration in internal/config/

• ✅ Password Hashing: bcrypt with salt
• ✅ JWT Authentication: Secure token-based auth
• ✅ Input Validation: Struct validation tags
• ✅ Database Security: GORM prevents SQL injection
• ✅ CORS Ready: Easy to add CORS middleware

• github.com/charmbracelet/bubbletea - Terminal UI
• github.com/charmbracelet/lipgloss - Terminal styling

• github.com/gin-gonic/gin - Web framework
• gorm.io/gorm - ORM
• github.com/golang-jwt/jwt/v5 - JWT authentication
• golang.org/x/crypto - Password hashing
• github.com/joho/godotenv - Environment variables
• github.com/google/uuid - UUID generation

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

This project is licensed under the MIT License - see the LICENSE file for details.

• Gin Web Framework - Fast HTTP web framework
• GORM - Fantastic ORM library
• Bubble Tea - Beautiful terminal UIs

Happy Coding! 🎉

Generate modern Go backends in seconds!