@nakedev/go-scaffold 0.4.3 → 0.5.0

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

@@ -0,0 +1,25 @@
+package application
+
+import (
+	"time"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+
+	"github.com/google/uuid"
+)
+
+// A lean module starts with no use-case input type. `generate method` adds
+// the exact input beside the endpoint that needs it.
+// Response is a transport-neutral application output. The inbound adapter
+// maps it to its protocol response before serialization.
+type Response struct {
+	ID        uuid.UUID
+	CreatedAt time.Time
+	Version   int
+}
+
+func ToResponse(m *domain.{{pascalName}}) Response {
+	return Response{ID: m.ID, CreatedAt: m.CreatedAt, Version: m.Version}
+}
+
+// go-scaffold:dto

package/templates/generate/module/hexagonal/application/queries.crud.go.hbs

@@ -0,0 +1,33 @@
+package application
+
+import (
+	"context"
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+	"{{goModule}}/internal/app/{{modulePath}}/ports"
+
+	"github.com/google/uuid"
+)
+
+type QueryPort interface {
+	List(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	Get(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	// go-scaffold:query-interface
+}
+
+type QueryHandler struct {
+	repo ports.QueryRepository
+}
+
+func NewQueryHandler(repo ports.QueryRepository) *QueryHandler {
+	return &QueryHandler{repo: repo}
+}
+
+func (h *QueryHandler) List(ctx context.Context, limit, offset int) ([]domain.{{pascalName}}, error) {
+	return h.repo.FindAll(ctx, limit, offset)
+}
+
+func (h *QueryHandler) Get(ctx context.Context, id uuid.UUID) (*domain.{{pascalName}}, error) {
+	return h.repo.FindByID(ctx, id)
+}
+
+// go-scaffold:query-methods

package/templates/generate/module/hexagonal/application/queries.go.hbs

@@ -0,0 +1,25 @@
+package application
+
+import (
+	"context"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+	"{{goModule}}/internal/app/{{modulePath}}/ports"
+)
+
+type QueryPort interface {
+	// go-scaffold:query-interface
+}
+
+type QueryHandler struct {
+	repo ports.QueryRepository
+}
+
+func NewQueryHandler(repo ports.QueryRepository) *QueryHandler {
+	return &QueryHandler{repo: repo}
+}
+
+var _ context.Context
+var _ *domain.{{pascalName}}
+
+// go-scaffold:query-methods

package/templates/generate/module/hexagonal/application/service.crud.go.hbs

@@ -0,0 +1,73 @@
+package application
+
+import (
+	"context"
+	"errors"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+	"{{goModule}}/internal/app/{{modulePath}}/ports"
+	"{{goModule}}/internal/shared/id"
+
+	"github.com/google/uuid"
+)
+
+type ServicePort interface {
+	Create(context.Context, CreateInput) (*domain.{{pascalName}}, error)
+	List(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	Get(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	Update(context.Context, uuid.UUID, UpdateInput) (*domain.{{pascalName}}, error)
+	Delete(context.Context, uuid.UUID) error
+	// go-scaffold:service-interface
+}
+
+type Service struct {
+	repo ports.Repository
+}
+
+func NewService(repo ports.Repository) *Service {
+	return &Service{repo: repo}
+}
+
+func (s *Service) Create(ctx context.Context, in CreateInput) (*domain.{{pascalName}}, error) {
+	// TODO: map in to real domain fields and enforce invariants.
+	_ = in
+	m := &domain.{{pascalName}}{ID: id.New(), Version: 1}
+	if err := s.repo.Create(ctx, m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (s *Service) List(ctx context.Context, limit, offset int) ([]domain.{{pascalName}}, error) {
+	return s.repo.FindAll(ctx, limit, offset)
+}
+
+func (s *Service) Get(ctx context.Context, id uuid.UUID) (*domain.{{pascalName}}, error) {
+	return s.repo.FindByID(ctx, id)
+}
+
+func (s *Service) Update(ctx context.Context, id uuid.UUID, in UpdateInput) (*domain.{{pascalName}}, error) {
+	m, err := s.repo.FindByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	// TODO: map in to real domain fields before saving.
+	m.Version = in.Version
+	if err := s.repo.Update(ctx, m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (s *Service) Delete(ctx context.Context, id uuid.UUID) error {
+	if err := s.repo.Delete(ctx, id); err != nil {
+		return err
+	}
+	return nil
+}
+
+// IsNotFound is useful to non-HTTP callers without exposing persistence
+// errors. The inbound HTTP adapter maps the same domain sentinel to 404.
+func IsNotFound(err error) bool { return errors.Is(err, domain.ErrNotFound) }
+
+// go-scaffold:service-methods

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

@@ -0,0 +1,29 @@
+package application
+
+import (
+	"context"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+	"{{goModule}}/internal/app/{{modulePath}}/ports"
+)
+
+// ServicePort is the inbound application port used by the HTTP adapter.
+type ServicePort interface {
+	// go-scaffold:service-interface
+}
+
+// Service orchestrates {{pkg}} use cases and depends only on ports.
+type Service struct {
+	repo ports.Repository
+}
+
+func NewService(repo ports.Repository) *Service {
+	return &Service{repo: repo}
+}
+
+// Keep these imports and the port visible in a lean module before its first
+// method is generated. Methods are added to this file by `generate method`.
+var _ context.Context
+var _ *domain.{{pascalName}}
+
+// go-scaffold:service-methods

package/templates/generate/module/hexagonal/application/service_test.go.hbs

@@ -0,0 +1,62 @@
+package application
+
+import (
+	"context"
+	"testing"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+
+	"github.com/google/uuid"
+)
+
+// repositoryStub exposes one function per dependency operation. Focused
+// application tests can configure only the calls they expect; an unexpected
+// call panics instead of silently returning a zero value that hides broken
+// orchestration.
+type repositoryStub struct {
+	createFn   func(context.Context, *domain.{{pascalName}}) error
+	findAllFn  func(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	findByIDFn func(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	updateFn   func(context.Context, *domain.{{pascalName}}) error
+	deleteFn   func(context.Context, uuid.UUID) error
+	// go-scaffold:repository-stub-fields
+}
+
+func (s *repositoryStub) Create(ctx context.Context, m *domain.{{pascalName}}) error {
+	if s.createFn == nil {
+		panic("unexpected repository.Create call")
+	}
+	return s.createFn(ctx, m)
+}
+func (s *repositoryStub) FindAll(ctx context.Context, limit, offset int) ([]domain.{{pascalName}}, error) {
+	if s.findAllFn == nil {
+		panic("unexpected repository.FindAll call")
+	}
+	return s.findAllFn(ctx, limit, offset)
+}
+func (s *repositoryStub) FindByID(ctx context.Context, id uuid.UUID) (*domain.{{pascalName}}, error) {
+	if s.findByIDFn == nil {
+		panic("unexpected repository.FindByID call")
+	}
+	return s.findByIDFn(ctx, id)
+}
+func (s *repositoryStub) Update(ctx context.Context, m *domain.{{pascalName}}) error {
+	if s.updateFn == nil {
+		panic("unexpected repository.Update call")
+	}
+	return s.updateFn(ctx, m)
+}
+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)
+}
+
+func TestService_ComposesWithRepositoryPort(t *testing.T) {
+	if NewService(&repositoryStub{}) == nil {
+		t.Fatal("expected service")
+	}
+}
+
+// go-scaffold:repository-stub-methods

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

@@ -0,0 +1,27 @@
+package {{pkg}}
+
+import (
+	httpadapter "{{goModule}}/internal/app/{{modulePath}}/adapters/inbound/http"
+	"{{goModule}}/internal/app/{{modulePath}}/adapters/outbound/postgres"
+	"{{goModule}}/internal/app/{{modulePath}}/application"
+{{#unless cqrs}}
+	"{{goModule}}/internal/app/{{modulePath}}/ports"
+{{/unless}}
+	"gorm.io/gorm"
+{{#if permission}}	"{{goModule}}/internal/shared/middleware"
+{{/if}}
+)
+
+// NewHandlerFromDB is this module's composition root. The process root owns
+// the database handle; this package owns the feature's adapter graph.
+func NewHandlerFromDB(db *gorm.DB{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *httpadapter.Handler {
+	repo := postgres.NewRepository(db)
+{{#if cqrs}}
+	commands := application.NewCommandHandler(repo)
+	queries := application.NewQueryHandler(repo)
+	return httpadapter.NewHandler(commands, queries{{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}})
+{{else}}
+	var service ports.Repository = repo
+	return httpadapter.NewHandler(application.NewService(service){{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}})
+{{/if}}
+}

package/templates/generate/module/hexagonal/domain/entity.go.hbs

@@ -0,0 +1,20 @@
+// Package domain contains {{pkg}}'s business state and invariants. It does
+// not import Gin, GORM, SQL drivers, or HTTP concerns.
+package domain
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// {{pascalName}} is the domain entity. Persistence and transport models are
+// deliberately separate so a database column or JSON field cannot silently
+// become part of the business API.
+type {{pascalName}} struct {
+	ID        uuid.UUID
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	Version   int
+	// TODO: add business fields and invariants here.
+}

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

@@ -0,0 +1,11 @@
+package domain
+
+import "errors"
+
+var (
+	ErrNotFound      = errors.New("{{pkg}} not found")
+	ErrConflict      = errors.New("{{pkg}} conflicts with an existing record")
+	ErrStaleVersion  = errors.New("{{pkg}} was modified by someone else")
+	ErrHasReferences = errors.New("{{pkg}} still has related records")
+	ErrNotImplemented = errors.New("{{pkg}} operation is not implemented")
+)

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

@@ -0,0 +1,38 @@
+// Package ports declares the dependencies owned by the {{pkg}} application.
+// Adapters implement these interfaces; application code never imports a
+// database driver.
+package ports
+
+import (
+	"context"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+
+	"github.com/google/uuid"
+)
+
+// Repository is the complete persistence port for service-style modules.
+type Repository interface {
+	Create(context.Context, *domain.{{pascalName}}) error
+	FindAll(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	FindByID(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	Update(context.Context, *domain.{{pascalName}}) error
+	Delete(context.Context, uuid.UUID) error
+	// go-scaffold:repository-interface
+}
+
+// CommandRepository and QueryRepository keep CQRS handlers honest: a write
+// use case cannot grow a read dependency by accident, and vice versa.
+type CommandRepository interface {
+	Create(context.Context, *domain.{{pascalName}}) error
+	FindByID(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	Update(context.Context, *domain.{{pascalName}}) error
+	Delete(context.Context, uuid.UUID) error
+	// go-scaffold:command-repository-interface
+}
+
+type QueryRepository interface {
+	FindAll(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	FindByID(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	// go-scaffold:query-repository-interface
+}

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

@@ -1,4 +1,4 @@
--- one schema per domain — see model.go's TableName for why
+-- one schema per domain — see adapters/outbound/postgres/model.go's TableName for why
 CREATE SCHEMA IF NOT EXISTS {{schemaName}};
 
 CREATE TABLE {{schemaName}}.{{tableName}} (