@nakedev/go-scaffold 0.4.3 → 0.5.1

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/queries.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"
-)
-
-// queryRepository is the outbound port for read-only use cases.
-type queryRepository interface {
-	FindAll(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error)
-	FindByID(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error)
-	// go-scaffold:query-repository-interface
-}
-
-// queryService is the inbound application port consumed by query routes.
-type queryService interface {
-	// go-scaffold:query-interface
-}
-
-// QueryHandler owns read-only use cases for {{pkg}}.
-type QueryHandler struct {
-	repo queryRepository
-}
-
-func NewQueryHandler(repo queryRepository) *QueryHandler {
-	return &QueryHandler{repo: repo}
-}
-
-// unused until `generate method` adds a get-one method that calls it
-//
-//nolint:unused
-func wrapFindErr(err error) error {
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return errNotFound()
-	}
-	return apperror.NewInternal(err)
-}
-
-// go-scaffold:query-methods

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

@@ -1,71 +0,0 @@
-package {{pkg}}
-
-{{#if cqrs}}
-// repository is the complete data dependency retained for the compatibility
-// facade below. CQRS handlers consume the narrower command/query ports.
-type repository interface {
-	commandRepository
-	queryRepository
-	// go-scaffold:repository-interface
-}
-
-// Service is a compatibility facade. New code should depend on
-// commandService or queryService directly.
-type Service struct {
-	commands commandService
-	queries  queryService
-}
-
-func NewService(repo repository) *Service {
-	return &Service{
-		commands: NewCommandHandler(repo),
-		queries:  NewQueryHandler(repo),
-	}
-}
-
-// go-scaffold:service-methods
-{{else}}
-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(err)
-}
-
-// go-scaffold:service-methods
-{{/if}}

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/queries.go.hbs

@@ -1,62 +0,0 @@
-package {{pkg}}
-
-import (
-	"context"
-	"errors"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/apperror"
-
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-)
-
-// queryRepository is the outbound port for read-only use cases. A separate
-// port makes it possible to replace this with a projection/read model later
-// without changing command handlers.
-type queryRepository interface {
-	FindAll(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error)
-	FindByID(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error)
-	// go-scaffold:query-repository-interface
-}
-
-// queryService is the inbound application port consumed by read endpoints.
-type queryService interface {
-	List(context.Context, int, int) ([]model.{{pascalName}}, error)
-	Get(context.Context, uuid.UUID) (*model.{{pascalName}}, error)
-	// go-scaffold:query-interface
-}
-
-// QueryHandler owns read-only use cases for {{pkg}}.
-type QueryHandler struct {
-	repo queryRepository
-}
-
-func NewQueryHandler(repo queryRepository) *QueryHandler {
-	return &QueryHandler{repo: repo}
-}
-
-func (h *QueryHandler) List(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
-	items, err := h.repo.FindAll(ctx, limit, offset)
-	if err != nil {
-		return nil, apperror.NewInternal(err)
-	}
-	return items, nil
-}
-
-func (h *QueryHandler) Get(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
-	m, err := h.repo.FindByID(ctx, id)
-	if err != nil {
-		return nil, wrapFindErr(err)
-	}
-	return m, nil
-}
-
-func wrapFindErr(err error) error {
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return errNotFound()
-	}
-	return apperror.NewInternal(err)
-}
-
-// go-scaffold:query-methods

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

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

@@ -1,164 +0,0 @@
-package {{pkg}}
-
-{{#if cqrs}}
-import (
-	"context"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-
-	"github.com/google/uuid"
-)
-
-// repository is the complete data dependency retained for the compatibility
-// facade below. The actual CQRS handlers consume the narrower
-// commandRepository/queryRepository ports declared in commands.go/queries.go.
-type repository interface {
-	commandRepository
-	queryRepository
-	// go-scaffold:repository-interface
-}
-
-// Service is a compatibility facade for callers that still want one feature
-// service. New code should depend on commandService or queryService instead,
-// so the read and write paths remain independently replaceable.
-type Service struct {
-	commands commandService
-	queries  queryService
-}
-
-func NewService(repo repository) *Service {
-	return &Service{
-		commands: NewCommandHandler(repo),
-		queries:  NewQueryHandler(repo),
-	}
-}
-
-func (s *Service) Create(ctx context.Context, in createInput) (*model.{{pascalName}}, error) {
-	return s.commands.Create(ctx, in)
-}
-
-func (s *Service) List(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
-	return s.queries.List(ctx, limit, offset)
-}
-
-func (s *Service) Get(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
-	return s.queries.Get(ctx, id)
-}
-
-func (s *Service) Update(ctx context.Context, id uuid.UUID, in updateInput) (*model.{{pascalName}}, error) {
-	return s.commands.Update(ctx, id, in)
-}
-
-func (s *Service) Delete(ctx context.Context, id uuid.UUID) error {
-	return s.commands.Delete(ctx, id)
-}
-
-// go-scaffold:service-methods
-{{else}}
-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"
-)
-
-// repository = what the service needs from the data layer (declared on the consumer side, so it can be mocked in tests)
-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)
-// input shape validation happens in the handler (binding tags)
-type Service struct {
-	repo repository
-}
-
-func NewService(repo repository) *Service {
-	return &Service{repo: repo}
-}
-
-func (s *Service) Create(ctx context.Context, in createInput) (*model.{{pascalName}}, error) {
-	// TODO: set real fields from in
-	_ = in
-	m := &model.{{pascalName}}{ID: id.New()}
-	if err := s.repo.Create(ctx, m); err != nil {
-		if dberr.IsDuplicate(err) {
-			return nil, errConflict()
-		}
-		return nil, apperror.NewInternal(err)
-	}
-	return m, nil
-}
-
-func (s *Service) List(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
-	items, err := s.repo.FindAll(ctx, limit, offset)
-	if err != nil {
-		return nil, apperror.NewInternal(err)
-	}
-	return items, nil
-}
-
-func (s *Service) Get(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
-	m, err := s.repo.FindByID(ctx, id)
-	if err != nil {
-		return nil, wrapFindErr(err)
-	}
-	return m, nil
-}
-
-func (s *Service) Update(ctx context.Context, id uuid.UUID, in updateInput) (*model.{{pascalName}}, error) {
-	m, err := s.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 := s.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 (s *Service) Delete(ctx context.Context, id uuid.UUID) error {
-	if err := s.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
-}
-
-func wrapFindErr(err error) error {
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return errNotFound()
-	}
-	return apperror.NewInternal(err)
-}
-
-// go-scaffold:service-methods
-{{/if}}