Go (Gin)

# Create a new Go service
apso init my-api --template go
 
# Navigate to project
cd my-api
 
# Download dependencies
go mod download
 
# Start development server
go run main.go
 
# Or with hot reload
air

my-api/
├── cmd/
│   └── server/
│       └── main.go         # Entry point
├── internal/
│   ├── entities/           # GORM models
│   │   ├── project.go
│   │   └── task.go
│   ├── handlers/           # HTTP handlers
│   │   ├── projects.go
│   │   └── tasks.go
│   ├── services/           # Business logic
│   ├── repository/         # Database layer
│   ├── middleware/         # HTTP middleware
│   └── extensions/         # Your custom code
├── pkg/                    # Shared packages
│   ├── config/
│   └── database/
├── migrations/             # Database migrations
├── .apsorc                 # APSO schema
└── go.mod

package entities
 
import (
    "time"
    "github.com/google/uuid"
    "gorm.io/gorm"
)
 
type Project struct {
    ID             uuid.UUID  `gorm:"type:uuid;primaryKey"`
    Name           string     `gorm:"not null"`
    Description    *string
    OrganizationID uuid.UUID  `gorm:"not null;index"`
    Tasks          []Task     `gorm:"foreignKey:ProjectID"`
    CreatedAt      time.Time
    UpdatedAt      time.Time
    DeletedAt      gorm.DeletedAt `gorm:"index"`
}
 
func (p *Project) BeforeCreate(tx *gorm.DB) error {
    p.ID = uuid.New()
    return nil
}

type CreateProjectRequest struct {
    Name        string  `json:"name" binding:"required,max=200"`
    Description *string `json:"description"`
}

// internal/handlers/projects.go
package handlers
 
import (
    "net/http"
    "github.com/gin-gonic/gin"
    "myapi/internal/services"
)
 
type ProjectHandler struct {
    service *services.ProjectService
}
 
func NewProjectHandler(service *services.ProjectService) *ProjectHandler {
    return &ProjectHandler{service: service}
}
 
func (h *ProjectHandler) List(c *gin.Context) {
    user := c.MustGet("user").(*entities.User)
 
    projects, err := h.service.GetAll(c, user.OrganizationID)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
 
    c.JSON(http.StatusOK, gin.H{"data": projects})
}
 
func (h *ProjectHandler) Create(c *gin.Context) {
    var req CreateProjectRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
 
    user := c.MustGet("user").(*entities.User)
    project, err := h.service.Create(c, req, user.OrganizationID)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
 
    c.JSON(http.StatusCreated, project)
}

// cmd/server/main.go
func setupRoutes(r *gin.Engine) {
    api := r.Group("/api/v1")
    api.Use(middleware.Auth())
 
    projects := api.Group("/projects")
    {
        projects.GET("/", projectHandler.List)
        projects.POST("/", projectHandler.Create)
        projects.GET("/:id", projectHandler.Get)
        projects.PATCH("/:id", projectHandler.Update)
        projects.DELETE("/:id", projectHandler.Delete)
    }
}

# .env
DATABASE_URL=postgres://user:pass@localhost:5432/db
JWT_SECRET=your-secret-key
PORT=3001
GIN_MODE=debug

// pkg/config/config.go
package config
 
import "os"
 
type Config struct {
    DatabaseURL string
    JWTSecret   string
    Port        string
    GinMode     string
}
 
func Load() *Config {
    return &Config{
        DatabaseURL: os.Getenv("DATABASE_URL"),
        JWTSecret:   os.Getenv("JWT_SECRET"),
        Port:        getEnvOrDefault("PORT", "3001"),
        GinMode:     getEnvOrDefault("GIN_MODE", "debug"),
    }
}