@nakedev/go-scaffold 0.4.3 → 0.5.0

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

@@ -1,95 +0,0 @@
-package {{pkg}}
-
-import (
-	"context"
-	"errors"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/apperror"
-	"{{goModule}}/internal/shared/dberr"
-	"{{goModule}}/internal/shared/id"
-
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-)
-
-// commandRepository is the outbound port for state-changing use cases. It is
-// intentionally smaller than queryRepository so command handlers do not grow
-// a dependency on read-only operations by accident.
-type commandRepository interface {
-	Create(ctx context.Context, m *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:command-repository-interface
-}
-
-// commandService is the inbound application port consumed by the HTTP
-// adapter. Its implementation is free of Gin and is independently testable.
-type commandService interface {
-	Create(context.Context, createInput) (*model.{{pascalName}}, error)
-	Update(context.Context, uuid.UUID, updateInput) (*model.{{pascalName}}, error)
-	Delete(context.Context, uuid.UUID) error
-	// go-scaffold:command-interface
-}
-
-// CommandHandler owns state-changing use cases for {{pkg}}. It is deliberately
-// separate from QueryHandler even though both adapters may share one database.
-type CommandHandler struct {
-	repo commandRepository
-}
-
-func NewCommandHandler(repo commandRepository) *CommandHandler {
-	return &CommandHandler{repo: repo}
-}
-
-func (h *CommandHandler) Create(ctx context.Context, in createInput) (*model.{{pascalName}}, error) {
-	// TODO: set real fields from in
-	_ = in
-	m := &model.{{pascalName}}{ID: id.New()}
-	if err := h.repo.Create(ctx, m); err != nil {
-		if dberr.IsDuplicate(err) {
-			return nil, errConflict()
-		}
-		return nil, apperror.NewInternal(err)
-	}
-	return m, nil
-}
-
-func (h *CommandHandler) Update(ctx context.Context, id uuid.UUID, in updateInput) (*model.{{pascalName}}, error) {
-	m, err := h.repo.FindByID(ctx, id)
-	if err != nil {
-		return nil, wrapFindErr(err)
-	}
-	// TODO: apply real fields from in before saving
-	// The version the client read comes from the request, not from the row we
-	// just loaded — comparing the row against itself would always succeed and
-	// defeat the check.
-	m.Version = in.Version
-	if err := h.repo.Update(ctx, m); err != nil {
-		if errors.Is(err, ErrStaleVersion) {
-			return nil, errStale()
-		}
-		if dberr.IsDuplicate(err) {
-			return nil, errConflict()
-		}
-		return nil, apperror.NewInternal(err)
-	}
-	return m, nil
-}
-
-func (h *CommandHandler) Delete(ctx context.Context, id uuid.UUID) error {
-	if err := h.repo.Delete(ctx, id); err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return errNotFound()
-		}
-		// deleting a {{pkg}} that's still referenced elsewhere → FK RESTRICT trips = 409, not 500
-		if dberr.IsForeignKey(err) {
-			return errHasReferences()
-		}
-		return apperror.NewInternal(err)
-	}
-	return nil
-}
-
-// go-scaffold:command-methods

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

@@ -1,23 +0,0 @@
-package {{pkg}}
-
-import "gorm.io/gorm"
-{{#if permission}}
-import "{{goModule}}/internal/shared/middleware"
-{{/if}}
-
-// NewHandlerFromDB is this feature's local composition root. The API binary
-// only chooses infrastructure and registers the route; repository, application
-// handlers, and delivery construction stay next to the feature.
-func NewHandlerFromDB(db *gorm.DB{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
-	{{#if cqrs}}
-	repo := NewRepository(db)
-	return NewHandlerFromCQRS(
-		NewCommandHandler(repo),
-		NewQueryHandler(repo){{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}},
-	)
-	{{else}}
-	return NewHandler(
-		NewService(NewRepository(db)){{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}},
-	)
-	{{/if}}
-}

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

@@ -1,7 +0,0 @@
-package {{pkg}}
-
-// These compile-time assertions make the generated boundary visible to both
-// users and tooling: commands and queries are separate application ports even
-// when they share one Postgres adapter in this modular monolith.
-var _ commandService = (*CommandHandler)(nil)
-var _ queryService = (*QueryHandler)(nil)

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

@@ -1,36 +0,0 @@
-package {{pkg}}
-
-import (
-	"time"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-
-	"github.com/google/uuid"
-)
-
-// TODO: add request fields, e.g. Name string `json:"name" binding:"required"`
-// When you do: update createBody in handler_test.go to match, or the
-// generated create test starts failing on its own empty `{}` body.
-type createInput struct {
-}
-
-// TODO: add request fields, e.g. Name string `json:"name" binding:"omitempty"`
-type updateInput struct {
-	// Version the client last read. Required: without it an update is a blind
-	// overwrite of whatever anyone else has since saved.
-	Version int `json:"version" binding:"required"`
-}
-
-// response = the DTO sent out (kept separate from the model so a later DB column doesn't leak automatically)
-type response struct {
-	ID        uuid.UUID `json:"id"`
-	CreatedAt time.Time `json:"created_at"`
-	// echoed back so the client can send it with its next update
-	Version int `json:"version"`
-}
-
-func toResponse(m *model.{{pascalName}}) response {
-	return response{ID: m.ID, CreatedAt: m.CreatedAt, Version: m.Version}
-}
-
-// go-scaffold:dto

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

@@ -1,33 +0,0 @@
-package {{pkg}}
-
-import (
-	"net/http"
-
-	"{{goModule}}/internal/shared/apperror"
-)
-
-// error catalog specific to {{pkg}} — codes carry more meaning than the generic apperror ones
-// functions, not vars: the error middleware writes RequestID onto the returned pointer directly
-// (a shared instance would race across concurrent requests). Not every entry is called by every
-// module (a minimal module calls none of these until `generate method` wires one in), hence nolint.
-//
-//nolint:unused
-func errNotFound() *apperror.AppError {
-	return apperror.New(http.StatusNotFound, "{{errorPrefix}}_NOT_FOUND", "{{pkg}} not found")
-}
-
-//nolint:unused
-func errConflict() *apperror.AppError {
-	// TODO: rename/reword once a real unique field exists (e.g. email already exists)
-	return apperror.New(http.StatusConflict, "{{errorPrefix}}_CONFLICT", "{{pkg}} already exists")
-}
-
-//nolint:unused
-func errStale() *apperror.AppError {
-	return apperror.New(http.StatusConflict, "{{errorPrefix}}_STALE", "{{pkg}} was modified by someone else — reload and try again")
-}
-
-//nolint:unused
-func errHasReferences() *apperror.AppError {
-	return apperror.New(http.StatusConflict, "{{errorPrefix}}_HAS_REFERENCES", "{{pkg}} still has related records")
-}

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

@@ -1,179 +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"
-)
-
-{{#if cqrs}}
-// service is retained as a compatibility seam for handler tests and callers
-// that still want one feature facade. Production wiring uses the narrower
-// commandService/queryService ports through NewHandlerFromCQRS.
-type service interface {
-	commandService
-	queryService
-	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
-}
-{{else}}
-// 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
-}
-{{/if}}
-
-// Handler = delivery for {{pkg}} (parses HTTP, calls the service, attaches errors for the middleware to render)
-type Handler struct {
-	{{#if cqrs}}
-	commands commandService
-	queries  queryService
-	{{else}}
-	svc service
-	{{/if}}
-{{#if auth}}
-	jwtSecret string
-{{/if}}
-{{#if permission}}
-	authz *middleware.Authz
-{{/if}}
-}
-
-{{#if cqrs}}
-// NewHandler keeps the pre-CQRS constructor usable for focused handler tests
-// and hand-written callers. New production composition should use the explicit
-// command/query constructor below.
-func NewHandler(svc service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
-	return NewHandlerFromCQRS(svc, svc{{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}})
-}
-
-func NewHandlerFromCQRS(commands commandService, queries queryService{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
-	return &Handler{
-		commands: commands,
-		queries: queries,
-{{#if auth}}
-		jwtSecret: jwtSecret,
-{{/if}}
-{{#if permission}}
-		 authz: authz,
-{{/if}}
-	}
-}
-{{else}}
-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}}
-	}
-}
-{{/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
-	}
-	{{#if cqrs}}m, err := h.commands.Create(c.Request.Context(), in){{else}}m, err := h.svc.Create(c.Request.Context(), in){{/if}}
-	if err != nil {
-		c.Error(err)
-		return
-	}
-	c.JSON(http.StatusCreated, toResponse(m))
-}
-
-func (h *Handler) list(c *gin.Context) {
-	p := pagination.Parse(c)
-	{{#if cqrs}}items, err := h.queries.List(c.Request.Context(), p.Limit, p.Offset){{else}}items, err := h.svc.List(c.Request.Context(), p.Limit, p.Offset){{/if}}
-	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
-	}
-	{{#if cqrs}}m, err := h.queries.Get(c.Request.Context(), id){{else}}m, err := h.svc.Get(c.Request.Context(), id){{/if}}
-	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
-	}
-	{{#if cqrs}}m, err := h.commands.Update(c.Request.Context(), id, in){{else}}m, err := h.svc.Update(c.Request.Context(), id, in){{/if}}
-	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 cqrs}}	if err := h.commands.Delete(c.Request.Context(), id); err != nil {
-{{else}}	if err := h.svc.Delete(c.Request.Context(), id); err != nil {
-{{/if}}
-		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/commands.go.hbs

@@ -1,34 +0,0 @@
-package {{pkg}}
-
-import (
-	"context"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-
-	"github.com/google/uuid"
-)
-
-// commandRepository is the outbound port for state-changing use cases.
-type commandRepository interface {
-	Create(ctx context.Context, m *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:command-repository-interface
-}
-
-// commandService is the inbound application port consumed by command routes.
-type commandService interface {
-	// go-scaffold:command-interface
-}
-
-// CommandHandler owns state-changing use cases for {{pkg}}.
-type CommandHandler struct {
-	repo commandRepository
-}
-
-func NewCommandHandler(repo commandRepository) *CommandHandler {
-	return &CommandHandler{repo: repo}
-}
-
-// go-scaffold:command-methods

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,82 +0,0 @@
-package {{pkg}}
-
-import (
-{{#if auth}}
-	"{{goModule}}/internal/shared/middleware"
-
-{{/if}}
-	"github.com/gin-gonic/gin"
-)
-
-{{#if cqrs}}
-// service is retained as a compatibility seam. Production composition uses
-// the separate commandService/queryService ports below.
-type service interface {
-	commandService
-	queryService
-	// go-scaffold:service-interface
-}
-{{else}}
-// service is intentionally empty until `generate method` adds the exact
-// application operations required by this HTTP adapter.
-type service interface {
-	// go-scaffold:service-interface
-}
-{{/if}}
-
-// Handler = delivery for {{pkg}} (parses HTTP, calls the service, attaches errors for the middleware to render)
-type Handler struct {
-	{{#if cqrs}}
-	commands commandService
-	queries  queryService
-	{{else}}
-	svc service
-	{{/if}}
-{{#if auth}}
-	jwtSecret string
-{{/if}}
-{{#if permission}}
-	authz *middleware.Authz
-{{/if}}
-}
-
-{{#if cqrs}}
-func NewHandler(svc service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
-	return NewHandlerFromCQRS(svc, svc{{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}})
-}
-
-func NewHandlerFromCQRS(commands commandService, queries queryService{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
-	return &Handler{
-		commands: commands,
-		queries: queries,
-{{#if auth}}
-		jwtSecret: jwtSecret,
-{{/if}}
-{{#if permission}}
-		authz: authz,
-{{/if}}
-	}
-}
-{{else}}
-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}}
-	}
-}
-{{/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