@dewtech/dare-cli 3.3.0 → 3.5.0

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

@@ -1,51 +1,51 @@
-package middleware
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"strings"
-
-	"github.com/golang-jwt/jwt/v5"
-
-	"{{moduleName}}/internal/config"
-)
-
-// JWT returns a middleware that validates a Bearer token and stashes the
-// claims as a map[string]any in request context under ClaimsContextKey.
-func JWT(cfg *config.Config) Middleware {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			raw := r.Header.Get("Authorization")
-			token := strings.TrimPrefix(raw, "Bearer ")
-			if token == raw || token == "" {
-				writeAuthError(w, http.StatusUnauthorized, "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 {
-				writeAuthError(w, http.StatusUnauthorized, "invalid token")
-				return
-			}
-			claims, _ := parsed.Claims.(jwt.MapClaims)
-			ctx := context.WithValue(r.Context(), ClaimsContextKey, map[string]any(claims))
-			next.ServeHTTP(w, r.WithContext(ctx))
-		})
-	}
-}
-
-func writeAuthError(w http.ResponseWriter, status int, detail string) {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	w.WriteHeader(status)
-	_ = json.NewEncoder(w).Encode(map[string]any{
-		"type":   "urn:problem:Unauthorized",
-		"title":  http.StatusText(status),
-		"status": status,
-		"detail": detail,
-	})
-}
+package middleware
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/golang-jwt/jwt/v5"
+
+	"{{moduleName}}/internal/config"
+)
+
+// JWT returns a middleware that validates a Bearer token and stashes the
+// claims as a map[string]any in request context under ClaimsContextKey.
+func JWT(cfg *config.Config) Middleware {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			raw := r.Header.Get("Authorization")
+			token := strings.TrimPrefix(raw, "Bearer ")
+			if token == raw || token == "" {
+				writeAuthError(w, http.StatusUnauthorized, "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 {
+				writeAuthError(w, http.StatusUnauthorized, "invalid token")
+				return
+			}
+			claims, _ := parsed.Claims.(jwt.MapClaims)
+			ctx := context.WithValue(r.Context(), ClaimsContextKey, map[string]any(claims))
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
+
+func writeAuthError(w http.ResponseWriter, status int, detail string) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(map[string]any{
+		"type":   "urn:problem:Unauthorized",
+		"title":  http.StatusText(status),
+		"status": status,
+		"detail": detail,
+	})
+}

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

@@ -1,81 +1,81 @@
-package middleware
-
-import (
-	"encoding/json"
-	"net"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"golang.org/x/time/rate"
-)
-
-// RateLimit is a token-bucket-per-IP middleware. Idle entries are pruned
-// every 5 minutes to keep memory bounded.
-func RateLimit(perSec, burst int) Middleware {
-	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(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			ip := clientIP(r)
-			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() {
-				w.Header().Set("Content-Type", "application/json; charset=utf-8")
-				w.WriteHeader(http.StatusTooManyRequests)
-				_ = json.NewEncoder(w).Encode(map[string]any{
-					"type":   "urn:problem:TooManyRequests",
-					"title":  http.StatusText(http.StatusTooManyRequests),
-					"status": http.StatusTooManyRequests,
-					"detail": "rate limit exceeded",
-				})
-				return
-			}
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
-func clientIP(r *http.Request) string {
-	if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
-		// First IP in chain.
-		if i := strings.Index(xff, ","); i >= 0 {
-			return strings.TrimSpace(xff[:i])
-		}
-		return strings.TrimSpace(xff)
-	}
-	host, _, err := net.SplitHostPort(r.RemoteAddr)
-	if err != nil {
-		return r.RemoteAddr
-	}
-	return host
-}
+package middleware
+
+import (
+	"encoding/json"
+	"net"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/time/rate"
+)
+
+// RateLimit is a token-bucket-per-IP middleware. Idle entries are pruned
+// every 5 minutes to keep memory bounded.
+func RateLimit(perSec, burst int) Middleware {
+	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(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ip := clientIP(r)
+			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() {
+				w.Header().Set("Content-Type", "application/json; charset=utf-8")
+				w.WriteHeader(http.StatusTooManyRequests)
+				_ = json.NewEncoder(w).Encode(map[string]any{
+					"type":   "urn:problem:TooManyRequests",
+					"title":  http.StatusText(http.StatusTooManyRequests),
+					"status": http.StatusTooManyRequests,
+					"detail": "rate limit exceeded",
+				})
+				return
+			}
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+func clientIP(r *http.Request) string {
+	if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
+		// First IP in chain.
+		if i := strings.Index(xff, ","); i >= 0 {
+			return strings.TrimSpace(xff[:i])
+		}
+		return strings.TrimSpace(xff)
+	}
+	host, _, err := net.SplitHostPort(r.RemoteAddr)
+	if err != nil {
+		return r.RemoteAddr
+	}
+	return host
+}

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

@@ -1,17 +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"`
-}
+// 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"`
+}

package/templates/stacks/go-stdlib/internal/repository/users_repository.go.tpl

@@ -1,75 +1,75 @@
-// Package repository — the only layer with SQL strings. Production setups can
-// swap in sqlc-generated code from db/queries/users.sql.
-package repository
-
-import (
-	"context"
-	"errors"
-
-	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"{{moduleName}}/internal/model"
-)
-
-type UsersRepository struct {
-	pool *pgxpool.Pool
-}
-
-func NewUsersRepository(pool *pgxpool.Pool) *UsersRepository {
-	return &UsersRepository{pool: pool}
-}
-
-func (r *UsersRepository) FindByEmail(ctx context.Context, email string) (*model.User, error) {
-	row := r.pool.QueryRow(ctx,
-		`SELECT id, email, password, role, created_at, updated_at FROM users WHERE email = $1`, email)
-	u := &model.User{}
-	if err := row.Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return u, nil
-}
-
-func (r *UsersRepository) Page(ctx context.Context, offset, limit int64) ([]*model.User, error) {
-	rows, err := r.pool.Query(ctx,
-		`SELECT id, email, password, role, created_at, updated_at
-		 FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2`, limit, offset)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var out []*model.User
-	for rows.Next() {
-		u := &model.User{}
-		if err := rows.Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt); err != nil {
-			return nil, err
-		}
-		out = append(out, u)
-	}
-	return out, rows.Err()
-}
-
-func (r *UsersRepository) Count(ctx context.Context) (int64, error) {
-	var total int64
-	err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM users`).Scan(&total)
-	return total, err
-}
-
-func (r *UsersRepository) Create(ctx context.Context, email, passwordHash, role string) (*model.User, error) {
-	u := &model.User{}
-	err := r.pool.QueryRow(ctx,
-		`INSERT INTO users (id, email, password, role)
-		 VALUES ($1, $2, $3, $4)
-		 RETURNING id, email, password, role, created_at, updated_at`,
-		uuid.New(), email, passwordHash, role,
-	).Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt)
-	if err != nil {
-		return nil, err
-	}
-	return u, nil
-}
+// Package repository — the only layer with SQL strings. Production setups can
+// swap in sqlc-generated code from db/queries/users.sql.
+package repository
+
+import (
+	"context"
+	"errors"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"{{moduleName}}/internal/model"
+)
+
+type UsersRepository struct {
+	pool *pgxpool.Pool
+}
+
+func NewUsersRepository(pool *pgxpool.Pool) *UsersRepository {
+	return &UsersRepository{pool: pool}
+}
+
+func (r *UsersRepository) FindByEmail(ctx context.Context, email string) (*model.User, error) {
+	row := r.pool.QueryRow(ctx,
+		`SELECT id, email, password, role, created_at, updated_at FROM users WHERE email = $1`, email)
+	u := &model.User{}
+	if err := row.Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return u, nil
+}
+
+func (r *UsersRepository) Page(ctx context.Context, offset, limit int64) ([]*model.User, error) {
+	rows, err := r.pool.Query(ctx,
+		`SELECT id, email, password, role, created_at, updated_at
+		 FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2`, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []*model.User
+	for rows.Next() {
+		u := &model.User{}
+		if err := rows.Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, err
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+func (r *UsersRepository) Count(ctx context.Context) (int64, error) {
+	var total int64
+	err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM users`).Scan(&total)
+	return total, err
+}
+
+func (r *UsersRepository) Create(ctx context.Context, email, passwordHash, role string) (*model.User, error) {
+	u := &model.User{}
+	err := r.pool.QueryRow(ctx,
+		`INSERT INTO users (id, email, password, role)
+		 VALUES ($1, $2, $3, $4)
+		 RETURNING id, email, password, role, created_at, updated_at`,
+		uuid.New(), email, passwordHash, role,
+	).Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return u, nil
+}

package/templates/stacks/go-stdlib/internal/service/auth_service.go.tpl

@@ -1,55 +1,55 @@
-// Package service — business logic.
-package service
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"time"
-
-	"github.com/golang-jwt/jwt/v5"
-	"golang.org/x/crypto/bcrypt"
-
-	"{{moduleName}}/internal/config"
-	"{{moduleName}}/internal/repository"
-)
-
-var ErrInvalidCredentials = errors.New("invalid credentials")
-
-type AuthService struct {
-	repo *repository.UsersRepository
-	cfg  *config.Config
-}
-
-func NewAuthService(r *repository.UsersRepository, cfg *config.Config) *AuthService {
-	return &AuthService{repo: r, cfg: cfg}
-}
-
-func (s *AuthService) Login(ctx context.Context, email, password string) (string, int64, error) {
-	email = strings.TrimSpace(strings.ToLower(email))
-	user, err := s.repo.FindByEmail(ctx, email)
-	if err != nil {
-		return "", 0, err
-	}
-	if user == nil {
-		return "", 0, ErrInvalidCredentials
-	}
-	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
-		return "", 0, ErrInvalidCredentials
-	}
-
-	expHours := s.cfg.JWTExpHours
-	expiresAt := time.Now().Add(time.Duration(expHours) * time.Hour)
-	claims := jwt.MapClaims{
-		"sub":   user.ID.String(),
-		"email": user.Email,
-		"role":  user.Role,
-		"exp":   expiresAt.Unix(),
-	}
-	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	signed, err := token.SignedString([]byte(s.cfg.JWTSecret))
-	if err != nil {
-		return "", 0, err
-	}
-	return signed, int64(expHours) * 3600, nil
-}
+// Package service — business logic.
+package service
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"golang.org/x/crypto/bcrypt"
+
+	"{{moduleName}}/internal/config"
+	"{{moduleName}}/internal/repository"
+)
+
+var ErrInvalidCredentials = errors.New("invalid credentials")
+
+type AuthService struct {
+	repo *repository.UsersRepository
+	cfg  *config.Config
+}
+
+func NewAuthService(r *repository.UsersRepository, cfg *config.Config) *AuthService {
+	return &AuthService{repo: r, cfg: cfg}
+}
+
+func (s *AuthService) Login(ctx context.Context, email, password string) (string, int64, error) {
+	email = strings.TrimSpace(strings.ToLower(email))
+	user, err := s.repo.FindByEmail(ctx, email)
+	if err != nil {
+		return "", 0, err
+	}
+	if user == nil {
+		return "", 0, ErrInvalidCredentials
+	}
+	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
+		return "", 0, ErrInvalidCredentials
+	}
+
+	expHours := s.cfg.JWTExpHours
+	expiresAt := time.Now().Add(time.Duration(expHours) * time.Hour)
+	claims := jwt.MapClaims{
+		"sub":   user.ID.String(),
+		"email": user.Email,
+		"role":  user.Role,
+		"exp":   expiresAt.Unix(),
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	signed, err := token.SignedString([]byte(s.cfg.JWTSecret))
+	if err != nil {
+		return "", 0, err
+	}
+	return signed, int64(expHours) * 3600, nil
+}

package/templates/stacks/go-stdlib/internal/service/users_service.go.tpl

@@ -1,53 +1,53 @@
-package service
-
-import (
-	"context"
-	"errors"
-	"strings"
-
-	"golang.org/x/crypto/bcrypt"
-
-	"{{moduleName}}/internal/config"
-	"{{moduleName}}/internal/model"
-	"{{moduleName}}/internal/repository"
-)
-
-var ErrEmailExists = errors.New("email already in use")
-
-type UsersService struct {
-	repo *repository.UsersRepository
-	cfg  *config.Config
-}
-
-func NewUsersService(r *repository.UsersRepository, cfg *config.Config) *UsersService {
-	return &UsersService{repo: r, cfg: cfg}
-}
-
-func (s *UsersService) Page(ctx context.Context, page, limit int) ([]*model.User, int64, error) {
-	offset := int64((page - 1) * limit)
-	items, err := s.repo.Page(ctx, offset, int64(limit))
-	if err != nil {
-		return nil, 0, err
-	}
-	total, err := s.repo.Count(ctx)
-	if err != nil {
-		return nil, 0, err
-	}
-	return items, total, nil
-}
-
-func (s *UsersService) Create(ctx context.Context, email, password, role string) (*model.User, error) {
-	email = strings.TrimSpace(strings.ToLower(email))
-	existing, err := s.repo.FindByEmail(ctx, email)
-	if err != nil {
-		return nil, err
-	}
-	if existing != nil {
-		return nil, ErrEmailExists
-	}
-	hash, err := bcrypt.GenerateFromPassword([]byte(password), s.cfg.BcryptCost)
-	if err != nil {
-		return nil, err
-	}
-	return s.repo.Create(ctx, email, string(hash), role)
-}
+package service
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"golang.org/x/crypto/bcrypt"
+
+	"{{moduleName}}/internal/config"
+	"{{moduleName}}/internal/model"
+	"{{moduleName}}/internal/repository"
+)
+
+var ErrEmailExists = errors.New("email already in use")
+
+type UsersService struct {
+	repo *repository.UsersRepository
+	cfg  *config.Config
+}
+
+func NewUsersService(r *repository.UsersRepository, cfg *config.Config) *UsersService {
+	return &UsersService{repo: r, cfg: cfg}
+}
+
+func (s *UsersService) Page(ctx context.Context, page, limit int) ([]*model.User, int64, error) {
+	offset := int64((page - 1) * limit)
+	items, err := s.repo.Page(ctx, offset, int64(limit))
+	if err != nil {
+		return nil, 0, err
+	}
+	total, err := s.repo.Count(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+	return items, total, nil
+}
+
+func (s *UsersService) Create(ctx context.Context, email, password, role string) (*model.User, error) {
+	email = strings.TrimSpace(strings.ToLower(email))
+	existing, err := s.repo.FindByEmail(ctx, email)
+	if err != nil {
+		return nil, err
+	}
+	if existing != nil {
+		return nil, ErrEmailExists
+	}
+	hash, err := bcrypt.GenerateFromPassword([]byte(password), s.cfg.BcryptCost)
+	if err != nil {
+		return nil, err
+	}
+	return s.repo.Create(ctx, email, string(hash), role)
+}