@dewtech/dare-cli 3.0.0 → 3.1.0

package/templates/stacks/go-gin/.env.example

@@ -0,0 +1,24 @@
+# Application
+APP_PORT=8000
+LOG_LEVEL=info
+
+# Database
+DATABASE_URL=postgres://user:pass@localhost:5432/myapi?sslmode=disable
+
+# JWT auth
+JWT_SECRET=replace-me-in-prod
+JWT_EXP_HOURS=1
+
+# Password hashing
+BCRYPT_COST=12
+
+# Rate limit (token bucket per IP)
+RATE_LIMIT_PER_SEC=10
+RATE_LIMIT_BURST=20
+
+# CORS — comma-separated origins
+CORS_ORIGINS=http://localhost:3000
+
+# LLM
+LLM_PROVIDER=dummy
+# OPENAI_API_KEY=

package/templates/stacks/go-gin/.github/workflows/dare-ci.yml

@@ -0,0 +1,42 @@
+name: DARE CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  audit:
+    name: govulncheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - run: go install golang.org/x/vuln/cmd/govulncheck@latest
+      - run: govulncheck ./...
+
+  lint:
+    name: golangci-lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - uses: golangci/golangci-lint-action@v6
+        with:
+          version: v1.61
+
+  test:
+    name: go test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - run: go mod download
+      - run: go test ./...

package/templates/stacks/go-gin/README.md.tpl

@@ -0,0 +1,38 @@
+# {{projectName}}
+
+DARE-shaped Go API on Gin. Layered Design (Handler → Service → Repository → Model).
+
+## Setup
+
+```bash
+cp .env.example .env
+docker compose up -d postgres
+go mod tidy
+go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest
+go install github.com/swaggo/swag/cmd/swag@latest
+sqlc generate
+swag init -g cmd/server/main.go -o docs
+go run ./cmd/server
+```
+
+## Endpoints
+
+- `POST /auth/login` — exchange email/password for JWT
+- `GET /auth/me` — current user (Bearer JWT)
+- `GET /users` — list users (paginated)
+- `POST /users` — create user (admin only)
+- `GET /ws` — WebSocket echo
+- `GET /openapi.json` — OpenAPI surface
+- `GET /swagger/index.html` — Swagger UI (after `swag init`)
+
+## Commands
+
+- `go run ./cmd/server` — dev server (port 8000)
+- `go test ./...` — tests
+- `golangci-lint run` — lint
+- `govulncheck ./...` — vuln scan
+- `sqlc generate` — regenerate type-safe DB code
+
+## DARE Method
+
+See `.dare/skills.yml` for installed skills, `llms.txt` for agent context.

package/templates/stacks/go-gin/cmd/server/main.go.tpl

@@ -0,0 +1,78 @@
+// {{projectName}} — Gin API entrypoint.
+//
+// @title           {{projectName}}
+// @version         0.1.0
+// @description     DARE-shaped Gin API.
+// @BasePath        /
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/gin-gonic/gin"
+	"github.com/joho/godotenv"
+
+	"{{moduleName}}/internal/config"
+	"{{moduleName}}/internal/db"
+	"{{moduleName}}/internal/handler"
+	"{{moduleName}}/internal/middleware"
+	"{{moduleName}}/internal/repository"
+	"{{moduleName}}/internal/service"
+)
+
+func main() {
+	_ = godotenv.Load()
+
+	cfg, err := config.FromEnv()
+	if err != nil {
+		log.Fatalf("config: %v", err)
+	}
+
+	pool, err := db.Connect(context.Background(), cfg.DatabaseURL)
+	if err != nil {
+		log.Fatalf("db: %v", err)
+	}
+	defer pool.Close()
+
+	repo := repository.NewUsersRepository(pool)
+	svcAuth := service.NewAuthService(repo, cfg)
+	svcUsers := service.NewUsersService(repo, cfg)
+
+	r := gin.New()
+	r.Use(gin.Recovery())
+	r.Use(middleware.RateLimit(cfg.RateLimitPerSec, cfg.RateLimitBurst))
+	r.Use(middleware.CORS(cfg.CORSOrigins))
+
+	r.GET("/healthz", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"status": "ok"}) })
+	r.GET("/openapi.json", func(c *gin.Context) {
+		b, _ := os.ReadFile("openapi.json")
+		var v any
+		_ = json.Unmarshal(b, &v)
+		c.JSON(http.StatusOK, v)
+	})
+
+	auth := handler.NewAuthHandler(svcAuth, svcUsers, cfg)
+	r.POST("/auth/login", auth.Login)
+
+	protected := r.Group("/", middleware.JWT(cfg))
+	{
+		protected.GET("/auth/me", auth.Me)
+		users := handler.NewUsersHandler(svcUsers)
+		protected.GET("/users", users.List)
+		protected.POST("/users", users.Create)
+	}
+
+	ws := handler.NewWSHandler()
+	r.GET("/ws", ws.Handle)
+
+	addr := fmt.Sprintf(":%d", cfg.AppPort)
+	log.Printf("listening on %s", addr)
+	if err := r.Run(addr); err != nil {
+		log.Fatal(err)
+	}
+}

package/templates/stacks/go-gin/db/migrations/0001_create_users.down.sql

@@ -0,0 +1,2 @@
+DROP INDEX IF EXISTS ix_users_email;
+DROP TABLE IF EXISTS users;

package/templates/stacks/go-gin/db/migrations/0001_create_users.up.sql

@@ -0,0 +1,12 @@
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TABLE IF NOT EXISTS users (
+    id          UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    email       VARCHAR(254) NOT NULL UNIQUE,
+    password    VARCHAR(255) NOT NULL,
+    role        VARCHAR(16) NOT NULL DEFAULT 'USER',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS ix_users_email ON users (email);

package/templates/stacks/go-gin/db/queries/users.sql

@@ -0,0 +1,23 @@
+-- name: FindUserByEmail :one
+SELECT id, email, password, role, created_at, updated_at
+FROM users
+WHERE email = $1;
+
+-- name: GetUserByID :one
+SELECT id, email, password, role, created_at, updated_at
+FROM users
+WHERE id = $1;
+
+-- name: ListUsers :many
+SELECT id, email, password, role, created_at, updated_at
+FROM users
+ORDER BY created_at DESC
+LIMIT $1 OFFSET $2;
+
+-- name: CountUsers :one
+SELECT COUNT(*) FROM users;
+
+-- name: CreateUser :one
+INSERT INTO users (id, email, password, role)
+VALUES ($1, $2, $3, $4)
+RETURNING id, email, password, role, created_at, updated_at;

package/templates/stacks/go-gin/gitignore

@@ -0,0 +1,7 @@
+/bin/
+/vendor/
+.env
+.env.local
+*.log
+.DS_Store
+docs/

package/templates/stacks/go-gin/go.mod.tpl

@@ -0,0 +1,17 @@
+module {{moduleName}}
+
+go 1.22
+
+require (
+	github.com/caarlos0/env/v11 v11.2.2
+	github.com/gin-gonic/gin v1.10.0
+	github.com/go-playground/validator/v10 v10.22.0
+	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
+	github.com/jackc/pgx/v5 v5.7.1
+	github.com/joho/godotenv v1.5.1
+	github.com/stretchr/testify v1.9.0
+	golang.org/x/crypto v0.28.0
+	golang.org/x/time v0.7.0
+)

package/templates/stacks/go-gin/internal/config/config.go

@@ -0,0 +1,41 @@
+// Package config — runtime configuration from environment via caarlos0/env.
+package config
+
+import (
+	"strings"
+
+	"github.com/caarlos0/env/v11"
+)
+
+type Config struct {
+	AppPort          int      `env:"APP_PORT" envDefault:"8000"`
+	DatabaseURL      string   `env:"DATABASE_URL,required"`
+	JWTSecret        string   `env:"JWT_SECRET" envDefault:"replace-me-in-prod"`
+	JWTExpHours      int      `env:"JWT_EXP_HOURS" envDefault:"1"`
+	BcryptCost       int      `env:"BCRYPT_COST" envDefault:"12"`
+	RateLimitPerSec  int      `env:"RATE_LIMIT_PER_SEC" envDefault:"10"`
+	RateLimitBurst   int      `env:"RATE_LIMIT_BURST" envDefault:"20"`
+	CORSOriginsRaw   string   `env:"CORS_ORIGINS" envDefault:"http://localhost:3000"`
+	LLMProvider      string   `env:"LLM_PROVIDER" envDefault:"dummy"`
+	CORSOrigins      []string `env:"-"`
+}
+
+func FromEnv() (*Config, error) {
+	cfg := &Config{}
+	if err := env.Parse(cfg); err != nil {
+		return nil, err
+	}
+	cfg.CORSOrigins = splitAndTrim(cfg.CORSOriginsRaw)
+	return cfg, nil
+}
+
+func splitAndTrim(s string) []string {
+	parts := strings.Split(s, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if t := strings.TrimSpace(p); t != "" {
+			out = append(out, t)
+		}
+	}
+	return out
+}

package/templates/stacks/go-gin/internal/db/postgres.go.tpl

@@ -0,0 +1,25 @@
+// Package db — pgx connection pool.
+package db
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Connect returns a pgx pool. Caller closes via pool.Close().
+func Connect(ctx context.Context, url string) (*pgxpool.Pool, error) {
+	cfg, err := pgxpool.ParseConfig(url)
+	if err != nil {
+		return nil, err
+	}
+	pool, err := pgxpool.NewWithConfig(ctx, cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return nil, err
+	}
+	return pool, nil
+}

package/templates/stacks/go-gin/internal/handler/auth_handler.go.tpl

@@ -0,0 +1,72 @@
+// Package handler — HTTP layer (Gin handlers).
+package handler
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"{{moduleName}}/internal/config"
+	"{{moduleName}}/internal/service"
+)
+
+type AuthHandler struct {
+	auth  *service.AuthService
+	users *service.UsersService
+	cfg   *config.Config
+}
+
+func NewAuthHandler(a *service.AuthService, u *service.UsersService, cfg *config.Config) *AuthHandler {
+	return &AuthHandler{auth: a, users: u, cfg: cfg}
+}
+
+type loginBody struct {
+	Email    string `json:"email" binding:"required,email"`
+	Password string `json:"password" binding:"required,min=8"`
+}
+
+// Login godoc
+// @Summary Exchange email+password for JWT
+// @Accept  json
+// @Produce json
+// @Param   body body loginBody true "credentials"
+// @Success 200 {object} map[string]any
+// @Failure 401 {object} map[string]string
+// @Router  /auth/login [post]
+func (h *AuthHandler) Login(c *gin.Context) {
+	var body loginBody
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	token, expiresIn, err := h.auth.Login(c.Request.Context(), body.Email, body.Password)
+	if errors.Is(err, service.ErrInvalidCredentials) {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid credentials"})
+		return
+	}
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{
+		"accessToken": token,
+		"tokenType":   "Bearer",
+		"expiresIn":   expiresIn,
+	})
+}
+
+// Me godoc
+// @Summary Current user info
+// @Security BearerAuth
+// @Produce json
+// @Success 200 {object} map[string]any
+// @Router  /auth/me [get]
+func (h *AuthHandler) Me(c *gin.Context) {
+	claims, ok := c.Get("claims")
+	if !ok {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
+		return
+	}
+	c.JSON(http.StatusOK, claims)
+}

package/templates/stacks/go-gin/internal/handler/users_handler.go.tpl

@@ -0,0 +1,72 @@
+package handler
+
+import (
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+
+	"{{moduleName}}/internal/service"
+)
+
+type UsersHandler struct {
+	svc *service.UsersService
+}
+
+func NewUsersHandler(s *service.UsersService) *UsersHandler {
+	return &UsersHandler{svc: s}
+}
+
+func (h *UsersHandler) List(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	limit, _ := strconv.Atoi(c.DefaultQuery("limit", "20"))
+	if page < 1 {
+		page = 1
+	}
+	if limit < 1 || limit > 100 {
+		limit = 20
+	}
+	items, total, err := h.svc.Page(c.Request.Context(), page, limit)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"items": items, "total": total, "page": page})
+}
+
+type createUserBody struct {
+	Email    string  `json:"email" binding:"required,email"`
+	Password string  `json:"password" binding:"required,min=8"`
+	Role     *string `json:"role" binding:"omitempty,oneof=USER ADMIN"`
+}
+
+func (h *UsersHandler) Create(c *gin.Context) {
+	claimsAny, _ := c.Get("claims")
+	claims, _ := claimsAny.(map[string]any)
+	if role, _ := claims["role"].(string); role != "ADMIN" {
+		c.JSON(http.StatusForbidden, gin.H{"error": "admin role required"})
+		return
+	}
+
+	var body createUserBody
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	role := "USER"
+	if body.Role != nil {
+		role = *body.Role
+	}
+
+	user, err := h.svc.Create(c.Request.Context(), body.Email, body.Password, role)
+	if errors.Is(err, service.ErrEmailExists) {
+		c.JSON(http.StatusConflict, gin.H{"error": "email already in use"})
+		return
+	}
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal"})
+		return
+	}
+	c.JSON(http.StatusCreated, user)
+}

package/templates/stacks/go-gin/internal/handler/ws_handler.go

@@ -0,0 +1,37 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+)
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+	CheckOrigin:     func(_ *http.Request) bool { return true },
+}
+
+type WSHandler struct{}
+
+func NewWSHandler() *WSHandler { return &WSHandler{} }
+
+func (h *WSHandler) Handle(c *gin.Context) {
+	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	defer conn.Close()
+
+	for {
+		mt, msg, err := conn.ReadMessage()
+		if err != nil {
+			return
+		}
+		if err := conn.WriteMessage(mt, msg); err != nil {
+			return
+		}
+	}
+}

package/templates/stacks/go-gin/internal/llm/dummy.go

@@ -0,0 +1,14 @@
+package llm
+
+import "context"
+
+type DummyProvider struct{}
+
+func NewDummyProvider() *DummyProvider { return &DummyProvider{} }
+
+func (d *DummyProvider) Complete(_ context.Context, prompt string, maxTokens int) (string, error) {
+	if maxTokens > 0 && len(prompt) > maxTokens {
+		return "[dummy] " + prompt[:maxTokens], nil
+	}
+	return "[dummy] " + prompt, nil
+}

package/templates/stacks/go-gin/internal/llm/provider.go

@@ -0,0 +1,8 @@
+// Package llm — LLM provider abstraction.
+package llm
+
+import "context"
+
+type Provider interface {
+	Complete(ctx context.Context, prompt string, maxTokens int) (string, error)
+}

package/templates/stacks/go-gin/internal/middleware/jwt.go.tpl

@@ -0,0 +1,58 @@
+// Package middleware — Gin middlewares (JWT, rate limit, CORS).
+package middleware
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+
+	"{{moduleName}}/internal/config"
+)
+
+func JWT(cfg *config.Config) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		raw := c.GetHeader("Authorization")
+		token := strings.TrimPrefix(raw, "Bearer ")
+		if token == raw {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "missing bearer"})
+			return
+		}
+		parsed, err := jwt.Parse(token, func(t *jwt.Token) (any, error) {
+			if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+				return nil, jwt.ErrSignatureInvalid
+			}
+			return []byte(cfg.JWTSecret), nil
+		})
+		if err != nil || !parsed.Valid {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid token"})
+			return
+		}
+		claims, _ := parsed.Claims.(jwt.MapClaims)
+		c.Set("claims", map[string]any(claims))
+		c.Next()
+	}
+}
+
+// CORS — comma-separated whitelist of origins from env.
+func CORS(allow []string) gin.HandlerFunc {
+	set := make(map[string]bool, len(allow))
+	for _, o := range allow {
+		set[o] = true
+	}
+	return func(c *gin.Context) {
+		origin := c.Request.Header.Get("Origin")
+		if origin != "" && set[origin] {
+			c.Header("Access-Control-Allow-Origin", origin)
+			c.Header("Vary", "Origin")
+			c.Header("Access-Control-Allow-Headers", "Authorization, Content-Type")
+			c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		}
+		if c.Request.Method == http.MethodOptions {
+			c.AbortWithStatus(http.StatusNoContent)
+			return
+		}
+		c.Next()
+	}
+}

package/templates/stacks/go-gin/internal/middleware/rate_limit.go

@@ -0,0 +1,55 @@
+package middleware
+
+import (
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"golang.org/x/time/rate"
+)
+
+// RateLimit returns a token-bucket-per-IP middleware. Idle IP entries are
+// pruned every 5 minutes to keep memory bounded.
+func RateLimit(perSec, burst int) gin.HandlerFunc {
+	type bucket struct {
+		limiter *rate.Limiter
+		seen    time.Time
+	}
+	var (
+		mu      sync.Mutex
+		buckets = make(map[string]*bucket)
+	)
+
+	go func() {
+		t := time.NewTicker(5 * time.Minute)
+		defer t.Stop()
+		for now := range t.C {
+			mu.Lock()
+			for ip, b := range buckets {
+				if now.Sub(b.seen) > 10*time.Minute {
+					delete(buckets, ip)
+				}
+			}
+			mu.Unlock()
+		}
+	}()
+
+	return func(c *gin.Context) {
+		ip := c.ClientIP()
+		mu.Lock()
+		b, ok := buckets[ip]
+		if !ok {
+			b = &bucket{limiter: rate.NewLimiter(rate.Limit(perSec), burst)}
+			buckets[ip] = b
+		}
+		b.seen = time.Now()
+		mu.Unlock()
+
+		if !b.limiter.Allow() {
+			c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{"error": "rate limit exceeded"})
+			return
+		}
+		c.Next()
+	}
+}

package/templates/stacks/go-gin/internal/model/user.go

@@ -0,0 +1,17 @@
+// Package model — domain entities.
+package model
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type User struct {
+	ID        uuid.UUID `json:"id"`
+	Email     string    `json:"email"`
+	Password  string    `json:"-"`
+	Role      string    `json:"role"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+}