A sophisticated and professional Todo REST API built with Go, featuring clean architecture, comprehensive documentation, and production-ready features.

• ✅ Clean Architecture - Layered architecture with clear separation of concerns
• ✅ RESTful API - Standard HTTP methods and status codes
• ✅ Database Support - SQLite (development) and PostgreSQL (production)
• ✅ GORM ORM - Type-safe database operations with auto-migration
• ✅ UUID Primary Keys - Secure and globally unique identifiers
• ✅ Input Validation - Comprehensive request validation
• ✅ Structured Logging - JSON-formatted logs with zerolog
• ✅ CORS Support - Cross-origin resource sharing configuration
• ✅ Request ID Tracking - Request tracing and debugging
• ✅ Health Checks - Application health monitoring
• ✅ Prometheus Metrics - Performance and business metrics
• ✅ Swagger Documentation - Auto-generated API documentation
• ✅ Graceful Shutdown - Proper server termination
• ✅ Environment Configuration - Flexible configuration management
• ✅ Pagination - Efficient data retrieval with metadata
• ✅ Soft Deletes - Data preservation with logical deletion

• Framework: Gin - High-performance HTTP web framework
• ORM: GORM - Object-relational mapping library
• Logging: Zerolog - Structured JSON logging
• Validation: Validator - Request validation
• Documentation: Swagger - API documentation
• Database: SQLite (dev) / PostgreSQL (prod)
• Monitoring: Prometheus metrics

• Go 1.21 or higher
• Git
• SQLite (for development)
• PostgreSQL (for production, optional)

git clone https://github.com/1cbyc/go-todo-api.git
cd go-todo-api

go mod tidy

Create a .env file in the root directory:

# Server Configuration
PORT=8080
GIN_MODE=debug
LOG_LEVEL=info
# Database Configuration
DB_DRIVER=sqlite
DB_NAME=todo_api
# For PostgreSQL (production)
# DB_DRIVER=postgres
# DB_HOST=localhost
# DB_PORT=5432
# DB_USER=postgres
# DB_PASSWORD=password
# DB_NAME=todo_api
# DB_SSLMODE=disable

go run cmd/api/main.go

The API will be available at https://localhost:8080

Once the server is running, visit:

• Swagger UI: https://localhost:8080/swagger/index.html
• Health Check: https://localhost:8080/health
• Metrics: https://localhost:8080/api/v1/metrics

curl -X POST https://localhost:8080/api/v1/todos \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Learn Go",
    "description": "Study Go programming language",
    "priority": "high",
    "due_date": "2024-12-31T23:59:59Z"
  }'

curl -X GET "https://localhost:8080/api/v1/todos?page=1&per_page=10"

curl -X PUT https://localhost:8080/api/v1/todos/{id} \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Learn Go Programming",
    "completed": true
  }'

curl -X PATCH https://localhost:8080/api/v1/todos/{id}/toggle

The application uses SQLite by default for development. The database file will be created automatically as todo_api.db.

To use PostgreSQL in production:

1. Install PostgreSQL
2. Create a database
3. Update environment variables:

DB_DRIVER=postgres
DB_HOST=localhost
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=your_password
DB_NAME=todo_api
DB_SSLMODE=disable

# Run all tests
go test ./...
# Run tests with coverage
go test -cover ./...
# Run tests with verbose output
go test -v ./...

# Run only unit tests
go test ./internal/services/...
# Run only integration tests
go test ./internal/repository/...
# Run benchmarks
go test -bench=. ./...

docker build -t todo-api .

docker run -p 8080:8080 todo-api

Create a docker-compose.yml file:

version: '3.8'
services:
  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_DRIVER=sqlite
      - DB_NAME=todo_api
    volumes:
      - ./data:/app/data
  # For PostgreSQL
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: todo_api
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

Run with:

docker-compose up -d

curl https://localhost:8080/health

Response:

{
  "status": "ok",
  "message": "Todo API is running",
  "version": "1.0.0",
  "timestamp": "2024-01-01T00:00:00Z",
  "uptime": "1h2m3s",
  "memory": {
    "alloc": 1234567,
    "total_alloc": 2345678,
    "sys": 3456789,
    "num_gc": 5
  },
  "goroutines": 10
}

curl https://localhost:8080/api/v1/metrics

# Build for production
go build -o bin/api cmd/api/main.go
# Run production binary
./bin/api

For production, set:

GIN_MODE=release
LOG_LEVEL=info
DB_DRIVER=postgres
# ... other production settings

1. Fork the repository
2. Create a 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

• Follow Go coding standards and conventions
• Write comprehensive tests for new features
• Update documentation for API changes
• Use conventional commit messages
• Ensure all tests pass before submitting PRs

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

• Technical Explanation - Detailed architecture and design decisions
• What's Next - Development roadmap and future features
• API Documentation - Interactive API docs

If you encounter any issues or have questions:

1. Check the documentation
2. Search existing issues
3. Create a new issue with detailed information

• Gin - Web framework
• GORM - ORM library
• Zerolog - Logging library
• Swagger - API documentation

Happy coding! 🎉