@nakedev/go-scaffold 0.1.3 → 0.1.4

package/templates/create/base/.github/workflows/ci.yml.hbs

@@ -14,8 +14,8 @@ jobs:
         env:
           POSTGRES_USER: postgres
           POSTGRES_PASSWORD: postgres
-          # the test database, not the app's — CI only runs tests, and the
-          # integration harness drops/recreates its tables on every run
+          # repository integration tests run against this isolated database after
+          # applying the same versioned SQL migrations used in production
           POSTGRES_DB: {{dbName}}_test
         ports:
           - 5432:5432
@@ -43,6 +43,19 @@ jobs:
         with:
           version: latest
 
-      # TEST_DB_DSN not set: the default in handler_test.go already points at
-      # localhost:5432/{{dbName}}_test with postgres/postgres, matching the service above
-      - run: go test ./...
+      - name: Install migration runner
+        run: go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@v4.18.3
+
+      - name: Apply production migrations to the test database
+        env:
+          DB_DSN: postgres://postgres:postgres@localhost:5432/{{dbName}}_test?sslmode=disable
+        run: |
+          if compgen -G "migrations/*.up.sql" > /dev/null; then
+            migrate -path migrations -database "$DB_DSN" up
+          fi
+
+      - name: Test (required PostgreSQL integration tests cannot skip)
+        env:
+          TEST_DB_DSN: postgres://postgres:postgres@localhost:5432/{{dbName}}_test?sslmode=disable
+          REQUIRE_TEST_DB: "true"
+        run: go test ./...

package/templates/create/base/AGENTS.md.hbs

@@ -45,21 +45,19 @@ hand-rolling anything that looks like scaffolding.
 
 ## Command quick reference
 
-- `go-scaffold generate module <name>` — model + dto + errors + repository +
-  service + handler + tests, wired into `cmd/api/main.go` (AutoMigrate +
-  route registration) and appended to `migrations/`. Use `--no-full` for a
-  bare skeleton (no default CRUD/routes) when you'd rather add endpoints one
-  at a time with `generate method`
+- `go-scaffold generate module <name>` — safe minimal model + errors +
+  repository + service/handler plumbing, wired into `cmd/api/main.go` and
+  appended to `migrations/`. Add endpoints one at a time with `generate
+  method`, or pass `--full` to opt into a CRUD skeleton with TODO DTO fields
 - `go-scaffold generate method <module> <name> --type <get|post|put|patch|delete> [--get-mode all|one] [--field <name>]` —
   patches an *existing* module's handler + service (and repository, for a
   `get --get-mode one --field` lookup) in place; never overwrites a method
-  with the same name — pick a different one if it collides. Endpoint docs in
-  `docs/openapi.yaml` are **not** auto-updated for methods — the command
-  prints the route so you can add the spec entry by hand
-- `go-scaffold remove module <name>` — the inverse of `generate module`:
-  deletes the package and un-wires main.go / openapi.yaml / migrations. Use
-  this to drop a domain instead of hand-deleting the folder (a partial
-  hand-delete leaves duplicate wiring behind)
+  with the same name — pick a different one if it collides. With OpenAPI
+  enabled it also writes a valid TODO path document and wires the index;
+  replace placeholder schemas while implementing the method
+- `go-scaffold remove module <name>` — deletes the package and un-wires
+  main.go/OpenAPI while preserving immutable migrations and table data. Use
+  `generate migration drop_<table>` for an explicit reviewed data removal
 - Every route in this project is grouped under{{#if apiPrefix}} `/{{apiPrefix}}`{{else}} no prefix{{/if}}
   (set once at `create` time via `--api-prefix`) — there is no per-domain
   versioning; a breaking API change gets a new domain package or a new DTO

package/templates/create/base/Makefile.hbs

@@ -3,6 +3,7 @@ DB_PORT ?= 5432
 DB_USER ?= postgres
 DB_NAME ?= {{dbName}}
 PGPASSWORD ?= postgres
+POSTGRES_CONTAINER ?=
 
 # which env file to load — defaults to .env (your local override, gitignored).
 # override to run against another file, e.g. copy .env.example to .env.production,
@@ -47,14 +48,17 @@ tidy:
 # connects to the always-present "postgres" maintenance DB to run CREATE DATABASE,
 # since the target DB may not exist yet. Safe to re-run — skips if it already exists.
 # \gexec only works read from stdin, not through -c, hence the pipe.
-# no local psql? falls back to `docker exec` into whatever container is publishing
-# DB_PORT — the project's own `docker compose up`'d postgres, or an unrelated
-# shared Postgres container you already have running, either works the same way.
+# `POSTGRES_CONTAINER` selects an exact Docker container when no host psql is
+# installed; otherwise the fallback discovers a container publishing DB_PORT.
 # override DB_HOST/DB_PORT/DB_USER/DB_NAME/PGPASSWORD to point at a different server.
 db-create:
 	@if command -v psql >/dev/null 2>&1; then \
 		echo "SELECT 'CREATE DATABASE $(DB_NAME)' WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = '$(DB_NAME)')\gexec" | \
 			PGPASSWORD=$(PGPASSWORD) psql -h $(DB_HOST) -p $(DB_PORT) -U $(DB_USER) -d postgres && echo "SUCCESS! database $(DB_NAME) is ready"; \
+	elif [ -n "$(POSTGRES_CONTAINER)" ]; then \
+		echo "no local psql — using docker exec into $(POSTGRES_CONTAINER)"; \
+		echo "SELECT 'CREATE DATABASE $(DB_NAME)' WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = '$(DB_NAME)')\gexec" | \
+			docker exec -i -e PGPASSWORD=$(PGPASSWORD) $(POSTGRES_CONTAINER) psql -U $(DB_USER) -d postgres && echo "SUCCESS! database $(DB_NAME) is ready"; \
 	elif [ "$(DB_HOST)" = "localhost" ] || [ "$(DB_HOST)" = "127.0.0.1" ]; then \
 		container=$$(docker ps -q --filter "publish=$(DB_PORT)" | head -1); \
 		if [ -z "$$container" ]; then \
@@ -72,6 +76,8 @@ db-create:
 db-drop:
 	@if command -v psql >/dev/null 2>&1; then \
 		PGPASSWORD=$(PGPASSWORD) psql -h $(DB_HOST) -p $(DB_PORT) -U $(DB_USER) -d postgres -c "DROP DATABASE IF EXISTS $(DB_NAME);" && echo "SUCCESS! database $(DB_NAME) dropped"; \
+	elif [ -n "$(POSTGRES_CONTAINER)" ]; then \
+		docker exec -i -e PGPASSWORD=$(PGPASSWORD) $(POSTGRES_CONTAINER) psql -U $(DB_USER) -d postgres -c "DROP DATABASE IF EXISTS $(DB_NAME);" && echo "SUCCESS! database $(DB_NAME) dropped"; \
 	elif [ "$(DB_HOST)" = "localhost" ] || [ "$(DB_HOST)" = "127.0.0.1" ]; then \
 		container=$$(docker ps -q --filter "publish=$(DB_PORT)" | head -1); \
 		if [ -z "$$container" ]; then \

package/templates/create/base/README.md.hbs

@@ -2,12 +2,15 @@
 
 Gin + GORM backend, scaffolded by [go-scaffold](https://github.com/nakedev/go-scaffold). Organized by feature (domain), Postgres-backed, schema managed with [golang-migrate](https://github.com/golang-migrate/migrate).
 
-This is a bare skeleton — no domain modules yet. Add one with:
+This project starts as a bare skeleton. Add a safe minimal domain with:
 
 ```bash
 go-scaffold generate module orders
 ```
 
+Add endpoints one at a time with `generate method`, or pass `--full` to opt
+into a CRUD skeleton whose DTO fields and business rules remain explicit TODOs.
+
 See `docs/architect/` for the conventions every generated module follows, and `AGENTS.md`/`CLAUDE.md` if you're working with an AI coding agent in this repo.
 
 ## Layout
@@ -129,17 +132,23 @@ make migrate-verify   # up -> down-to-zero -> up, catches a broken down.sql befo
 
 ## Tests
 
-Integration tests (handler-level) run against a **real Postgres** instance (same engine as prod), each test in a transaction that's rolled back — no leftover rows. If the DB isn't reachable those tests **skip** (unit tests using a fake repo always run).
+Handler and service tests are fast unit tests: handlers depend on a narrow
+service interface, and services use function-backed repository stubs. Neither
+suite requires a database.
 
-They use a **separate `{{dbName}}_test` database**, not the one `DB_DSN` points at. That's deliberate: the harness runs `DropTable` + `AutoMigrate` on every real run, so pointing it at your dev database would wipe whatever `make migrate-up` built there — FK constraints and seed data included. Create it once:
+Repository integration tests run against a **real Postgres** instance using
+the same versioned SQL migrations as production, each test in a transaction
+that's rolled back. Locally they skip when `TEST_DB_DSN` is unset; CI sets
+`REQUIRE_TEST_DB=true`, so a missing or unmigrated database fails instead of
+becoming a false-green skip. Use a separate `{{dbName}}_test` database:
 
 ```bash
 {{#if docker}}
 make docker-up      # local postgres first
 {{/if}}
 make db-create DB_NAME={{dbName}}_test
-make test
-# point somewhere else entirely: TEST_DB_DSN=postgres://... go test ./...
+DB_DSN=postgres://postgres:postgres@localhost:5432/{{dbName}}_test?sslmode=disable make migrate-up
+TEST_DB_DSN=postgres://postgres:postgres@localhost:5432/{{dbName}}_test?sslmode=disable REQUIRE_TEST_DB=true go test ./...
 ```
 
 ## Error payload
@@ -170,4 +179,7 @@ Import `docs/openapi.bundled.yaml` instead. Tools that resolve `$ref` over HTTP
 go-scaffold generate module orders
 ```
 
-Scaffolds `internal/app/orders/` (model/dto/errors/repository/service/handler + tests), wires it into `cmd/api/main.go` (AutoMigrate, route registration), and appends a migration file. See `docs/architect/patterns.md` for the module shape and the rules for domains with foreign keys.
+Scaffolds the safe minimal `internal/app/order/` module, wires its empty route
+group/model into `cmd/api/main.go`, and appends a migration file. Add endpoints
+with `generate method`; use `--full` only when a CRUD skeleton is intentional.
+See `docs/architect/patterns.md` for the module shape and foreign-key rules.

package/templates/create/features/docs/openapi.yaml.hbs

@@ -1,11 +1,10 @@
 # ponytail: hand-written, not generated from annotations — cheap while the
-# endpoint count is low. Ceiling: must be updated by hand whenever an
-# endpoint/DTO changes beyond what `generate module` scaffolds.
+# endpoint count is low. Generated module/method stubs keep the index wired,
+# but request/response schemas still need to be completed with the code.
 # Switch to swaggo (comment-generated) if drift becomes a recurring problem.
 # multi-file: split by domain module (health/<domain>) + common/ for shared
-# pieces — this file is just the index. `generate module <name>`
-# adds its paths/schemas here automatically; `generate method` does not
-# (endpoint-specific docs stay hand-written).
+# pieces — this file is just the index. `generate module` and `generate method`
+# add path entries automatically.
 openapi: 3.0.3
 info:
   title: {{projectName}} API

package/templates/create/features/docs/patterns.md.hbs

@@ -17,8 +17,9 @@ internal/app/<domain>/
 ├── repository.go       # the only place that touches the DB for this domain, every method takes ctx
 ├── service.go          # business logic; declares the repository interface it needs (mockable in tests)
 ├── handler.go          # HTTP: routing, bind, delegate, respond
-├── service_test.go     # unit test, fake repo, no DB
-└── handler_test.go     # integration test, real Postgres, transaction rolled back per test
+├── service_test.go     # unit test, function-backed repository stub, no DB
+├── handler_test.go     # HTTP unit test, service stub, no DB
+└── repository_test.go  # Postgres integration test against migrated schema
 ```
 
 ### Model
@@ -137,10 +138,12 @@ placeholder fields.
 - Unit and integration tests live in the same directory as the code under
   test (Go convention) — never a separate `test/` folder. `test/` is only
   for e2e black-box suites or fixtures.
-- `service_test.go` uses a fake repository — no DB required, always runs.
-- `handler_test.go` runs against a real Postgres instance inside a
-  transaction that's rolled back after each test — skips automatically if
-  the DB isn't reachable.
+- `service_test.go` uses a function-backed repository stub so each dependency
+  method has independent behavior and argument assertions.
+- `handler_test.go` uses a service stub — HTTP tests never need Postgres.
+- `repository_test.go` runs against a migrated Postgres database inside a
+  transaction that's rolled back after each test. Local runs may skip when
+  `TEST_DB_DSN` is unset; CI sets `REQUIRE_TEST_DB=true` so it must run.
 
 ## Docs Maintenance
 

package/templates/generate/module/docs/item.yaml.hbs

@@ -29,9 +29,9 @@ put:
     "400": { $ref: '../common/responses.yaml#/ValidationError' }
     "404": { $ref: '../common/responses.yaml#/NotFoundError' }
 delete:
-  summary: Delete {{pkg}}
+  summary: Delete {{name}}
+  description: Idempotent — deleting an already-missing resource also returns 204.
   operationId: delete{{pascalName}}
   tags: [{{plural}}]
   responses:
-    "204": { description: deleted }
-    "404": { $ref: '../common/responses.yaml#/NotFoundError' }
+    "204": { description: deleted or already absent }

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

@@ -1,8 +1,10 @@
 package {{pkg}}
 
 import (
+	"context"
 	"net/http"
 
+	"{{goModule}}/internal/app/{{modulePath}}/model"
 	"{{goModule}}/internal/shared/httpx"
 {{#if auth}}
 	"{{goModule}}/internal/shared/middleware"
@@ -10,11 +12,23 @@ import (
 	"{{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
+	svc service
 {{#if auth}}
 	jwtSecret string
 {{/if}}
@@ -23,7 +37,7 @@ type Handler struct {
 {{/if}}
 }
 
-func NewHandler(svc *Service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
+func NewHandler(svc service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
 	return &Handler{
 		svc: svc,
 {{#if auth}}
@@ -52,7 +66,7 @@ func (h *Handler) create(c *gin.Context) {
 		c.Error(httpx.BindErr(err))
 		return
 	}
-	m, err := h.svc.Create(c.Request.Context())
+	m, err := h.svc.Create(c.Request.Context(), in)
 	if err != nil {
 		c.Error(err)
 		return
@@ -97,7 +111,7 @@ func (h *Handler) update(c *gin.Context) {
 		c.Error(httpx.BindErr(err))
 		return
 	}
-	m, err := h.svc.Update(c.Request.Context(), id)
+	m, err := h.svc.Update(c.Request.Context(), id, in)
 	if err != nil {
 		c.Error(err)
 		return

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

@@ -2,14 +2,9 @@ package {{pkg}}
 
 import (
 	"bytes"
-{{#if permission}}
 	"context"
-{{/if}}
-	"encoding/json"
 	"net/http"
 	"net/http/httptest"
-	"os"
-	"sync"
 	"testing"
 {{#if auth}}
 	"time"
@@ -23,67 +18,77 @@ import (
 	"github.com/golang-jwt/jwt/v5"
 {{/if}}
 	"github.com/google/uuid"
-	"gorm.io/driver/postgres"
-	"gorm.io/gorm"
 )
 
-// integration test backed by real Postgres (same engine as prod, no sqlite) — skips if the DB isn't reachable.
-// Runs against its own {{dbName}}_test database, never the one DB_DSN points at: the
-// harness does DropTable+AutoMigrate on every run, which would otherwise wipe the
-// schema `make migrate-up` built in your dev DB (FK constraints, seed data and all).
-// Create it once with `make db-create DB_NAME={{dbName}}_test`, or point TEST_DB_DSN
-// somewhere else.
-var (
-	testDBOnce sync.Once
-	testDB     *gorm.DB
-	testDBErr  error
-)
+// 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 dbForTest(t *testing.T) *gorm.DB {
-	t.Helper()
-	testDBOnce.Do(func() {
-		dsn := os.Getenv("TEST_DB_DSN")
-		if dsn == "" {
-			dsn = "postgres://postgres:postgres@localhost:5432/{{dbName}}_test?sslmode=disable"
-		}
-		if testDB, testDBErr = gorm.Open(postgres.Open(dsn), &gorm.Config{TranslateError: true}); testDBErr == nil {
-			// drop first — AutoMigrate can't change an existing column's type, always start from a fresh schema
-			_ = testDB.Migrator().DropTable(&model.{{pascalName}}{})
-			testDBErr = testDB.AutoMigrate(&model.{{pascalName}}{})
-		}
-	})
-	if testDBErr != nil {
-		t.Skipf("postgres not ready (make db-create DB_NAME={{dbName}}_test, or set TEST_DB_DSN): %v", testDBErr)
+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 testDB
+	return s.listFn(ctx, limit, offset)
 }
 
-// setup builds the full stack on a transaction that's rolled back at the end → each test is isolated, no leftover rows
-func setup(t *testing.T) *gin.Engine {
+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)
-	tx := dbForTest(t).Begin()
-	t.Cleanup(func() { tx.Rollback() })
 	r := gin.New()
 	r.Use(middleware.RequestID(), middleware.Error(true))
 {{#if permission}}
-	// stub authz: always grants "{{permission}}" — this test is about the
-	// CRUD handler, not re-proving RBAC (that's covered by the role
-	// package's own tests), so the resolver doesn't need a real DB lookup.
+	// 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(NewService(NewRepository(tx)){{#if auth}}, testJWTSecret{{/if}}{{#if permission}}, authz{{/if}}).Register(r)
+	NewHandler(svc{{#if auth}}, testJWTSecret{{/if}}{{#if permission}}, authz{{/if}}).Register(r)
 	return r
 }
 
 {{#if auth}}
 const testJWTSecret = "test-secret"
 
-// authHeader mints a valid access token signed with testJWTSecret — the
-// route's own RequireAuth(testJWTSecret) (wired in via NewHandler above)
-// verifies against the same secret, so this round-trips for real.
 func authHeader() string {
 	claims := jwt.MapClaims{
 		"typ":  "access",
@@ -97,8 +102,8 @@ func authHeader() string {
 }
 
 {{/if}}
-func do(r *gin.Engine, method, path, body string) *httptest.ResponseRecorder {
-	req := httptest.NewRequest(method, path, bytes.NewBufferString(body))
+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())
@@ -109,39 +114,53 @@ func do(r *gin.Engine, method, path, body string) *httptest.ResponseRecorder {
 }
 
 func TestHandler_Create_OK(t *testing.T) {
-	r := setup(t)
-	w := do(r, http.MethodPost, "/{{plural}}", `{}`)
+	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}}", `{}`)
+
 	if w.Code != http.StatusCreated {
 		t.Fatalf("want 201, got %d body=%s", w.Code, w.Body)
 	}
 }
 
 func TestHandler_Get_NotFound(t *testing.T) {
-	r := setup(t)
-	w := do(r, http.MethodGet, "/{{plural}}/"+uuid.NewString(), "")
+	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(t *testing.T) {
-	r := setup(t)
-	w := do(r, http.MethodGet, "/{{plural}}/not-a-uuid", "")
+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) {
-	r := setup(t)
-	created := do(r, http.MethodPost, "/{{plural}}", `{}`)
-	var body struct {
-		ID string `json:"id"`
+	svc := &serviceStub{
+		deleteFn: func(context.Context, uuid.UUID) error { return nil },
 	}
-	if err := json.Unmarshal(created.Body.Bytes(), &body); err != nil {
-		t.Fatalf("decode create response: %v", err)
-	}
-	w := do(r, http.MethodDelete, "/{{plural}}/"+body.ID, "")
+	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/migration.down.sql.hbs

@@ -1 +1 @@
-DROP TABLE IF EXISTS {{plural}};
+DROP TABLE IF EXISTS {{tableName}};

package/templates/generate/module/migration.up.sql.hbs

@@ -1,4 +1,4 @@
-CREATE TABLE {{plural}} (
+CREATE TABLE {{tableName}} (
     id         UUID PRIMARY KEY,
     created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
     updated_at TIMESTAMPTZ NOT NULL DEFAULT now()

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

@@ -8,9 +8,15 @@ import (
 	"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
+	svc service
 {{#if auth}}
 	jwtSecret string
 {{/if}}
@@ -19,7 +25,7 @@ type Handler struct {
 {{/if}}
 }
 
-func NewHandler(svc *Service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
+func NewHandler(svc service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
 	return &Handler{
 		svc: svc,
 {{#if auth}}