@nakedev/go-scaffold 0.4.0 → 0.5.0

package/templates/generate/module/handler.go.hbs

@@ -1,134 +0,0 @@
-package {{pkg}}
-
-import (
-	"context"
-	"net/http"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/httpx"
-{{#if auth}}
-	"{{goModule}}/internal/shared/middleware"
-{{/if}}
-	"{{goModule}}/internal/shared/pagination"
-
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-)
-
-// service is the narrow application API required by this HTTP adapter. Keeping
-// the dependency as an interface makes handler tests fast and database-free.
-type service interface {
-	Create(context.Context, createInput) (*model.{{pascalName}}, error)
-	List(context.Context, int, int) ([]model.{{pascalName}}, error)
-	Get(context.Context, uuid.UUID) (*model.{{pascalName}}, error)
-	Update(context.Context, uuid.UUID, updateInput) (*model.{{pascalName}}, error)
-	Delete(context.Context, uuid.UUID) error
-	// go-scaffold:service-interface
-}
-
-// Handler = delivery for {{pkg}} (parses HTTP, calls the service, attaches errors for the middleware to render)
-type Handler struct {
-	svc service
-{{#if auth}}
-	jwtSecret string
-{{/if}}
-{{#if permission}}
-	authz *middleware.Authz
-{{/if}}
-}
-
-func NewHandler(svc service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
-	return &Handler{
-		svc: svc,
-{{#if auth}}
-		jwtSecret: jwtSecret,
-{{/if}}
-{{#if permission}}
-		authz: authz,
-{{/if}}
-	}
-}
-
-// Register wires {{pkg}}'s routes onto the router group (takes an IRouter so it can be nested under /v1)
-func (h *Handler) Register(rg gin.IRouter) {
-	g := rg.Group("/{{plural}}"{{#if auth}}, middleware.RequireAuth(h.jwtSecret){{/if}}{{#if permission}}, h.authz.Require("{{permission}}"){{/if}})
-	g.POST("", h.create)
-	g.GET("", h.list)
-	g.GET("/:id", h.get)
-	g.PUT("/:id", h.update)
-	g.DELETE("/:id", h.delete)
-	// go-scaffold:handler-routes
-}
-
-func (h *Handler) create(c *gin.Context) {
-	var in createInput
-	if err := c.ShouldBindJSON(&in); err != nil {
-		c.Error(httpx.BindErr(err))
-		return
-	}
-	m, err := h.svc.Create(c.Request.Context(), in)
-	if err != nil {
-		c.Error(err)
-		return
-	}
-	c.JSON(http.StatusCreated, toResponse(m))
-}
-
-func (h *Handler) list(c *gin.Context) {
-	p := pagination.Parse(c)
-	items, err := h.svc.List(c.Request.Context(), p.Limit, p.Offset)
-	if err != nil {
-		c.Error(err)
-		return
-	}
-	out := make([]response, len(items))
-	for i := range items {
-		out[i] = toResponse(&items[i])
-	}
-	c.JSON(http.StatusOK, p.Response(out))
-}
-
-func (h *Handler) get(c *gin.Context) {
-	id, ok := httpx.ParseID(c)
-	if !ok {
-		return
-	}
-	m, err := h.svc.Get(c.Request.Context(), id)
-	if err != nil {
-		c.Error(err)
-		return
-	}
-	c.JSON(http.StatusOK, toResponse(m))
-}
-
-func (h *Handler) update(c *gin.Context) {
-	id, ok := httpx.ParseID(c)
-	if !ok {
-		return
-	}
-	var in updateInput
-	if err := c.ShouldBindJSON(&in); err != nil {
-		c.Error(httpx.BindErr(err))
-		return
-	}
-	m, err := h.svc.Update(c.Request.Context(), id, in)
-	if err != nil {
-		c.Error(err)
-		return
-	}
-	c.JSON(http.StatusOK, toResponse(m))
-}
-
-func (h *Handler) delete(c *gin.Context) {
-	id, ok := httpx.ParseID(c)
-	if !ok {
-		return
-	}
-	if err := h.svc.Delete(c.Request.Context(), id); err != nil {
-		c.Error(err)
-		return
-	}
-	c.Status(http.StatusNoContent)
-}
-
-// go-scaffold:handler-funcs

package/templates/generate/module/handler_test.go.hbs

@@ -1,174 +0,0 @@
-package {{pkg}}
-
-import (
-	"bytes"
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-{{#if auth}}
-	"time"
-{{/if}}
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/middleware"
-
-	"github.com/gin-gonic/gin"
-{{#if auth}}
-	"github.com/golang-jwt/jwt/v5"
-{{/if}}
-	"github.com/google/uuid"
-)
-
-// serviceStub keeps handler tests at the HTTP boundary. It exercises binding,
-// routing, middleware, status codes, and serialization without a database.
-type serviceStub struct {
-	// Embedding keeps this stub source-compatible when `generate method` adds a
-	// new operation to the handler's service interface. Base CRUD methods below
-	// still override the promoted concrete methods for focused unit tests.
-	*Service
-	createFn func(context.Context, createInput) (*model.{{pascalName}}, error)
-	listFn   func(context.Context, int, int) ([]model.{{pascalName}}, error)
-	getFn    func(context.Context, uuid.UUID) (*model.{{pascalName}}, error)
-	updateFn func(context.Context, uuid.UUID, updateInput) (*model.{{pascalName}}, error)
-	deleteFn func(context.Context, uuid.UUID) error
-}
-
-func (s *serviceStub) Create(ctx context.Context, in createInput) (*model.{{pascalName}}, error) {
-	if s.createFn == nil {
-		panic("unexpected service.Create call")
-	}
-	return s.createFn(ctx, in)
-}
-
-func (s *serviceStub) List(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
-	if s.listFn == nil {
-		panic("unexpected service.List call")
-	}
-	return s.listFn(ctx, limit, offset)
-}
-
-func (s *serviceStub) Get(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
-	if s.getFn == nil {
-		panic("unexpected service.Get call")
-	}
-	return s.getFn(ctx, id)
-}
-
-func (s *serviceStub) Update(ctx context.Context, id uuid.UUID, in updateInput) (*model.{{pascalName}}, error) {
-	if s.updateFn == nil {
-		panic("unexpected service.Update call")
-	}
-	return s.updateFn(ctx, id, in)
-}
-
-func (s *serviceStub) Delete(ctx context.Context, id uuid.UUID) error {
-	if s.deleteFn == nil {
-		panic("unexpected service.Delete call")
-	}
-	return s.deleteFn(ctx, id)
-}
-
-// go-scaffold:service-stub-methods
-
-func setupHandlerTest(t *testing.T, svc service) *gin.Engine {
-	t.Helper()
-	gin.SetMode(gin.TestMode)
-	r := gin.New()
-	r.Use(middleware.RequestID(), middleware.Error(true))
-{{#if permission}}
-	// The handler unit test verifies route composition, not the role repository.
-	authz := middleware.NewAuthz(func(_ context.Context, _ string) (map[string]struct{}, error) {
-		return map[string]struct{}{"{{permission}}": {}}, nil
-	}, time.Minute)
-{{/if}}
-	NewHandler(svc{{#if auth}}, testJWTSecret{{/if}}{{#if permission}}, authz{{/if}}).Register(r)
-	return r
-}
-
-{{#if auth}}
-const testJWTSecret = "test-secret"
-
-func authHeader() string {
-	claims := jwt.MapClaims{
-		"typ":  "access",
-		"sub":  uuid.NewString(),
-		"role": "staff",
-		"exp":  time.Now().Add(time.Hour).Unix(),
-		"iat":  time.Now().Unix(),
-	}
-	tok, _ := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(testJWTSecret))
-	return "Bearer " + tok
-}
-
-{{/if}}
-func doHandlerRequest(r *gin.Engine, method, requestPath, body string) *httptest.ResponseRecorder {
-	req := httptest.NewRequest(method, requestPath, bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-{{#if auth}}
-	req.Header.Set("Authorization", authHeader())
-{{/if}}
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-	return w
-}
-
-// createBody is the JSON these tests POST. It starts empty because createInput
-// starts empty — add a value here for every field you add to createInput in
-// dto.go. Miss that and this test fails with a 400 the moment one of those
-// fields is `binding:"required"`: the handler is fine, the fixture just no
-// longer satisfies it.
-const createBody = `{}`
-
-func TestHandler_Create_OK(t *testing.T) {
-	svc := &serviceStub{
-		createFn: func(context.Context, createInput) (*model.{{pascalName}}, error) {
-			return &model.{{pascalName}}{ID: uuid.New()}, nil
-		},
-	}
-	r := setupHandlerTest(t, svc)
-
-	w := doHandlerRequest(r, http.MethodPost, "/{{plural}}", createBody)
-
-	if w.Code != http.StatusCreated {
-		t.Fatalf("want 201, got %d body=%s", w.Code, w.Body)
-	}
-}
-
-func TestHandler_Get_NotFound(t *testing.T) {
-	svc := &serviceStub{
-		getFn: func(context.Context, uuid.UUID) (*model.{{pascalName}}, error) {
-			return nil, errNotFound()
-		},
-	}
-	r := setupHandlerTest(t, svc)
-
-	w := doHandlerRequest(r, http.MethodGet, "/{{plural}}/"+uuid.NewString(), "")
-
-	if w.Code != http.StatusNotFound {
-		t.Fatalf("want 404, got %d body=%s", w.Code, w.Body)
-	}
-}
-
-func TestHandler_Get_InvalidID_DoesNotCallService(t *testing.T) {
-	r := setupHandlerTest(t, &serviceStub{})
-
-	w := doHandlerRequest(r, http.MethodGet, "/{{plural}}/not-a-uuid", "")
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("want 400, got %d body=%s", w.Code, w.Body)
-	}
-}
-
-func TestHandler_Delete_OK(t *testing.T) {
-	svc := &serviceStub{
-		deleteFn: func(context.Context, uuid.UUID) error { return nil },
-	}
-	r := setupHandlerTest(t, svc)
-
-	w := doHandlerRequest(r, http.MethodDelete, "/{{plural}}/"+uuid.NewString(), "")
-
-	if w.Code != http.StatusNoContent {
-		t.Fatalf("want 204, got %d body=%s", w.Code, w.Body)
-	}
-}

package/templates/generate/module/minimal/dto.go.hbs

@@ -1,28 +0,0 @@
-package {{pkg}}
-
-import (
-	"time"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-
-	"github.com/google/uuid"
-)
-
-// response = the DTO sent out (kept separate from the model so a later DB column doesn't leak automatically)
-// TODO: add fields as you generate methods that return more than id/created_at
-// unused until `generate method` adds a method that returns one
-//
-//nolint:unused
-type response struct {
-	ID        uuid.UUID `json:"id"`
-	CreatedAt time.Time `json:"created_at"`
-	// clients send this back on an update so a concurrent save can be detected
-	Version int `json:"version"`
-}
-
-//nolint:unused
-func toResponse(m *model.{{pascalName}}) response {
-	return response{ID: m.ID, CreatedAt: m.CreatedAt, Version: m.Version}
-}
-
-// go-scaffold:dto

package/templates/generate/module/minimal/handler.go.hbs

@@ -1,48 +0,0 @@
-package {{pkg}}
-
-import (
-{{#if auth}}
-	"{{goModule}}/internal/shared/middleware"
-
-{{/if}}
-	"github.com/gin-gonic/gin"
-)
-
-// service is intentionally empty until `generate method` adds the exact
-// application operations required by this HTTP adapter.
-type service interface {
-	// go-scaffold:service-interface
-}
-
-// Handler = delivery for {{pkg}} (parses HTTP, calls the service, attaches errors for the middleware to render)
-type Handler struct {
-	svc service
-{{#if auth}}
-	jwtSecret string
-{{/if}}
-{{#if permission}}
-	authz *middleware.Authz
-{{/if}}
-}
-
-func NewHandler(svc service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
-	return &Handler{
-		svc: svc,
-{{#if auth}}
-		jwtSecret: jwtSecret,
-{{/if}}
-{{#if permission}}
-		authz: authz,
-{{/if}}
-	}
-}
-
-// Register wires {{pkg}}'s routes onto the router group (takes an IRouter so it can be nested under /v1)
-// minimal module: no routes yet — add them with `go-scaffold generate method {{pkg}} <name> --type ...`
-func (h *Handler) Register(rg gin.IRouter) {
-	g := rg.Group("/{{plural}}"{{#if auth}}, middleware.RequireAuth(h.jwtSecret){{/if}}{{#if permission}}, h.authz.Require("{{permission}}"){{/if}})
-	_ = g
-	// go-scaffold:handler-routes
-}
-
-// go-scaffold:handler-funcs

package/templates/generate/module/minimal/handler_test.go.hbs

@@ -1,10 +0,0 @@
-package {{pkg}}
-
-// serviceStub embeds the concrete service so a generated method automatically
-// satisfies the handler's narrow service interface. Add explicit function-backed
-// overrides here when writing focused handler tests for that method.
-//
-//nolint:unused
-type serviceStub struct {
-	*Service
-}

package/templates/generate/module/minimal/service.go.hbs

@@ -1,45 +0,0 @@
-package {{pkg}}
-
-import (
-	"context"
-	"errors"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/apperror"
-
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-)
-
-// repository = what the service needs from the data layer (declared on the consumer side, so it can be mocked in tests)
-// minimal module: no CRUD wired yet, but the full data-access surface is here so `generate method` has something to call
-type repository interface {
-	Create(ctx context.Context, m *model.{{pascalName}}) error
-	FindAll(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error)
-	FindByID(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error)
-	Update(ctx context.Context, m *model.{{pascalName}}) error
-	Delete(ctx context.Context, id uuid.UUID) error
-	// go-scaffold:repository-interface
-}
-
-// Service = business logic for {{pkg}} (rules live here, it knows nothing about HTTP)
-// minimal module: add methods with `go-scaffold generate method {{pkg}} <name> --type ...`
-type Service struct {
-	repo repository
-}
-
-func NewService(repo repository) *Service {
-	return &Service{repo: repo}
-}
-
-// unused until `generate method` adds a get-one/patch/put/delete method that calls it
-//
-//nolint:unused
-func wrapFindErr(err error) error {
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return errNotFound()
-	}
-	return apperror.NewInternal()
-}
-
-// go-scaffold:service-methods

package/templates/generate/module/minimal/service_test.go.hbs

@@ -1,77 +0,0 @@
-package {{pkg}}
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/apperror"
-
-	"github.com/google/uuid"
-)
-
-// repositoryStub is ready for focused use-case tests added alongside generated
-// methods. Every unset dependency panics so unexpected orchestration is visible.
-//
-//nolint:unused
-type repositoryStub struct {
-	createFn   func(context.Context, *model.{{pascalName}}) error
-	findAllFn  func(context.Context, int, int) ([]model.{{pascalName}}, error)
-	findByIDFn func(context.Context, uuid.UUID) (*model.{{pascalName}}, error)
-	updateFn   func(context.Context, *model.{{pascalName}}) error
-	deleteFn   func(context.Context, uuid.UUID) error
-	// go-scaffold:repository-stub-fields
-}
-
-//nolint:unused
-func (s *repositoryStub) Create(ctx context.Context, m *model.{{pascalName}}) error {
-	if s.createFn == nil {
-		panic("unexpected repository.Create call")
-	}
-	return s.createFn(ctx, m)
-}
-
-//nolint:unused
-func (s *repositoryStub) FindAll(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
-	if s.findAllFn == nil {
-		panic("unexpected repository.FindAll call")
-	}
-	return s.findAllFn(ctx, limit, offset)
-}
-
-//nolint:unused
-func (s *repositoryStub) FindByID(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
-	if s.findByIDFn == nil {
-		panic("unexpected repository.FindByID call")
-	}
-	return s.findByIDFn(ctx, id)
-}
-
-//nolint:unused
-func (s *repositoryStub) Update(ctx context.Context, m *model.{{pascalName}}) error {
-	if s.updateFn == nil {
-		panic("unexpected repository.Update call")
-	}
-	return s.updateFn(ctx, m)
-}
-
-//nolint:unused
-func (s *repositoryStub) Delete(ctx context.Context, id uuid.UUID) error {
-	if s.deleteFn == nil {
-		panic("unexpected repository.Delete call")
-	}
-	return s.deleteFn(ctx, id)
-}
-
-// go-scaffold:repository-stub-methods
-
-//nolint:unused
-func status(t *testing.T, err error) int {
-	t.Helper()
-	var appErr *apperror.AppError
-	if !errors.As(err, &appErr) {
-		t.Fatalf("expected *apperror.AppError, got %T: %v", err, err)
-	}
-	return appErr.HTTPStatus
-}

package/templates/generate/module/model/model.go.hbs

@@ -1,36 +0,0 @@
-// Package model holds this domain's GORM tables — a folder (not a single
-// file) so a domain with more than one table can add a file per table
-// without cluttering the domain package's top level.
-package model
-
-import (
-	"time"
-
-	"github.com/google/uuid"
-)
-
-// {{pascalName}} = domain model + GORM table
-// TODO: add your real fields here.
-// ID = UUID v7 generated app-side (service.Create via id.New) instead of a DB
-// default, so the app has the id before insert without needing gen_random_uuid.
-type {{pascalName}} struct {
-	ID        uuid.UUID `json:"id" gorm:"type:uuid;primaryKey"`
-	CreatedAt time.Time `json:"created_at"`
-	UpdatedAt time.Time `json:"updated_at"`
-	// Version guards against two clients that both loaded this row overwriting
-	// each other: an update only applies if the version it carries still
-	// matches the stored one. Bumped by Repository.Update, never by hand.
-	Version int `json:"version" gorm:"not null;default:1"`
-}
-
-// TableName pins the persistence contract to the versioned SQL migrations.
-// Do not rely on GORM's English inflector: irregular/plural module names must
-// resolve to exactly the same table in development and production.
-//
-// Schema-qualified ("{{schemaName}}", not just "{{tableName}}") so this
-// domain's table can never collide with another domain's, and a raw SQL JOIN
-// reaching into it from outside this package fails loudly instead of quietly
-// coupling two domains together.
-func ({{pascalName}}) TableName() string {
-	return "{{schemaName}}.{{tableName}}"
-}

package/templates/generate/module/repository.go.hbs

@@ -1,103 +0,0 @@
-package {{pkg}}
-
-import (
-	"context"
-	"errors"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/tx"
-
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-)
-
-// ErrStaleVersion means the row moved on since the caller read it — someone
-// else saved first. Returned instead of overwriting their work.
-var ErrStaleVersion = errors.New("stale version")
-
-// Repository = data access for {{pkg}} (the only place that touches the DB for this domain)
-// every method takes ctx, so a cancelled request cancels the query too — and
-// so tx.From can pick up a transaction opened by the caller, letting two
-// repositories commit together without changing any signature here.
-type Repository struct {
-	db *gorm.DB
-}
-
-func NewRepository(db *gorm.DB) *Repository {
-	return &Repository{db: db}
-}
-
-func (r *Repository) Create(ctx context.Context, m *model.{{pascalName}}) error {
-	return tx.From(ctx, r.db).WithContext(ctx).Create(m).Error
-}
-
-func (r *Repository) FindAll(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
-	var items []model.{{pascalName}}
-	err := tx.From(ctx, r.db).WithContext(ctx).Order("id desc").Limit(limit).Offset(offset).Find(&items).Error
-	return items, err
-}
-
-func (r *Repository) FindByID(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
-	var m model.{{pascalName}}
-	// "id = ?" explicit — PK is a UUID, not an int, this avoids GORM misinterpreting the arg
-	if err := tx.From(ctx, r.db).WithContext(ctx).First(&m, "id = ?", id).Error; err != nil {
-		return nil, err
-	}
-	return &m, nil
-}
-
-// Update applies m only if the version it carries still matches the stored
-// row, then bumps it. Two clients that both loaded version 3 can't silently
-// overwrite each other: the second one gets ErrStaleVersion instead of the
-// first one's changes disappearing with no error anywhere.
-func (r *Repository) Update(ctx context.Context, m *model.{{pascalName}}) error {
-	expected := m.Version
-	m.Version = expected + 1
-
-	res := tx.From(ctx, r.db).WithContext(ctx).
-		Model(&model.{{pascalName}}{}).
-		Where("id = ? AND version = ?", m.ID, expected).
-		// Select("*") because Updates on a struct skips zero values, which
-		// would quietly ignore a field the caller meant to clear.
-		Select("*").Omit("id", "created_at").
-		Updates(m)
-	if res.Error != nil {
-		m.Version = expected
-		return res.Error
-	}
-	if res.RowsAffected == 0 {
-		m.Version = expected
-		return ErrStaleVersion
-	}
-	return nil
-}
-
-// Delete reports gorm.ErrRecordNotFound when the row wasn't there, so a
-// DELETE on an id that never existed answers 404 like GET does — a plain
-// GORM delete affects zero rows and returns no error, which had the same
-// request answer 204 as a real deletion.
-func (r *Repository) Delete(ctx context.Context, id uuid.UUID) error {
-	res := tx.From(ctx, r.db).WithContext(ctx).Delete(&model.{{pascalName}}{}, "id = ?", id)
-	if res.Error != nil {
-		return res.Error
-	}
-	if res.RowsAffected == 0 {
-		return gorm.ErrRecordNotFound
-	}
-	return nil
-}
-
-// Count is the total the list endpoint needs to say "page 3 of 12" — see
-// pagination.ResponseWithTotal. Separate from FindAll because it costs a second
-// query: an endpoint that only ever scrolls shouldn't pay for a count nobody
-// reads.
-//
-// Apply the same WHERE clause here that FindAll uses once you add filtering,
-// or the total will describe a different set than the rows.
-func (r *Repository) Count(ctx context.Context) (int64, error) {
-	var total int64
-	err := tx.From(ctx, r.db).WithContext(ctx).Model(&model.{{pascalName}}{}).Count(&total).Error
-	return total, err
-}
-
-// go-scaffold:repository-methods