@nakedev/go-scaffold 0.1.0

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

@@ -0,0 +1,49 @@
+package {{pkg}}
+
+import (
+	"context"
+
+	"{{goModule}}/internal/app/{{modulePath}}/model"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// 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
+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 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 := 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 := r.db.WithContext(ctx).First(&m, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (r *Repository) Update(ctx context.Context, m *model.{{pascalName}}) error {
+	return r.db.WithContext(ctx).Save(m).Error
+}
+
+func (r *Repository) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&model.{{pascalName}}{}, "id = ?", id).Error
+}
+
+// go-scaffold:repository-methods

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

@@ -0,0 +1,97 @@
+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"
+)
+
+// 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) (*model.{{pascalName}}, error) {
+	// TODO: accept and set real fields from createInput
+	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()
+	}
+	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()
+	}
+	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) (*model.{{pascalName}}, error) {
+	m, err := s.repo.FindByID(ctx, id)
+	if err != nil {
+		return nil, wrapFindErr(err)
+	}
+	// TODO: apply real fields from updateInput before saving
+	if err := s.repo.Update(ctx, m); err != nil {
+		if dberr.IsDuplicate(err) {
+			return nil, errConflict()
+		}
+		return nil, apperror.NewInternal()
+	}
+	return m, nil
+}
+
+func (s *Service) Delete(ctx context.Context, id uuid.UUID) error {
+	if err := s.repo.Delete(ctx, id); err != nil {
+		// deleting a {{pkg}} that's still referenced elsewhere → FK RESTRICT trips = 409, not 500
+		if dberr.IsForeignKey(err) {
+			return errHasReferences()
+		}
+		return apperror.NewInternal()
+	}
+	return nil
+}
+
+func wrapFindErr(err error) error {
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return errNotFound()
+	}
+	return apperror.NewInternal()
+}
+
+// go-scaffold:service-methods

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

@@ -0,0 +1,65 @@
+package {{pkg}}
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"{{goModule}}/internal/app/{{modulePath}}/model"
+	"{{goModule}}/internal/shared/apperror"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// fakeRepo = mock of the repository interface, so the service can be tested without a DB
+type fakeRepo struct {
+	err error
+	m   *model.{{pascalName}}
+}
+
+func (f *fakeRepo) Create(context.Context, *model.{{pascalName}}) error                    { return f.err }
+func (f *fakeRepo) FindAll(context.Context, int, int) ([]model.{{pascalName}}, error) { return nil, f.err }
+func (f *fakeRepo) FindByID(context.Context, uuid.UUID) (*model.{{pascalName}}, error) {
+	if f.err != nil {
+		return nil, f.err
+	}
+	return f.m, nil
+}
+func (f *fakeRepo) Update(context.Context, *model.{{pascalName}}) error { return f.err }
+func (f *fakeRepo) Delete(context.Context, uuid.UUID) error             { return f.err }
+
+// go-scaffold:fake-repo-methods
+
+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
+}
+
+func TestService_Create_Duplicate(t *testing.T) {
+	svc := NewService(&fakeRepo{err: gorm.ErrDuplicatedKey})
+	_, err := svc.Create(context.Background())
+	if got := status(t, err); got != 409 {
+		t.Fatalf("want 409 conflict, got %d", got)
+	}
+}
+
+func TestService_Get_NotFound(t *testing.T) {
+	svc := NewService(&fakeRepo{err: gorm.ErrRecordNotFound})
+	_, err := svc.Get(context.Background(), uuid.New())
+	if got := status(t, err); got != 404 {
+		t.Fatalf("want 404, got %d", got)
+	}
+}
+
+func TestService_List_DBError_Becomes500(t *testing.T) {
+	svc := NewService(&fakeRepo{err: errors.New("connection refused")})
+	_, err := svc.List(context.Background(), 20, 0)
+	if got := status(t, err); got != 500 {
+		t.Fatalf("want 500, got %d", got)
+	}
+}