@nakedev/go-scaffold 0.1.3 → 0.3.0

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

@@ -0,0 +1,109 @@
+package {{pkg}}
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"{{goModule}}/internal/app/{{modulePath}}/model"
+
+	"github.com/google/uuid"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+// repositoryDBForTest expects the test database schema to come from the same
+// versioned SQL migrations used in production. Unit tests stay database-free;
+// CI sets REQUIRE_TEST_DB=true so an unavailable/unmigrated database fails
+// instead of becoming a false-green skip.
+func repositoryDBForTest(t *testing.T) *gorm.DB {
+	t.Helper()
+	dsn := os.Getenv("TEST_DB_DSN")
+	if dsn == "" {
+		if os.Getenv("REQUIRE_TEST_DB") == "true" {
+			t.Fatal("TEST_DB_DSN is required when REQUIRE_TEST_DB=true")
+		}
+		t.Skip("repository integration test skipped: set TEST_DB_DSN to a migrated PostgreSQL database")
+	}
+
+	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{TranslateError: true})
+	if err != nil {
+		if os.Getenv("REQUIRE_TEST_DB") == "true" {
+			t.Fatalf("open required test database: %v", err)
+		}
+		t.Skipf("repository integration test skipped: %v", err)
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		t.Fatalf("get SQL database handle: %v", err)
+	}
+	if err := sqlDB.Ping(); err != nil {
+		if os.Getenv("REQUIRE_TEST_DB") == "true" {
+			t.Fatalf("ping required test database: %v", err)
+		}
+		t.Skipf("repository integration test skipped: %v", err)
+	}
+
+	tx := db.Begin()
+	if tx.Error != nil {
+		t.Fatalf("begin test transaction: %v", tx.Error)
+	}
+	t.Cleanup(func() {
+		if err := tx.Rollback().Error; err != nil {
+			t.Errorf("rollback test transaction: %v", err)
+		}
+	})
+	return tx
+}
+
+func TestRepository_CreateFindDelete(t *testing.T) {
+	repo := NewRepository(repositoryDBForTest(t))
+	ctx := context.Background()
+	id := uuid.New()
+	item := &model.{{pascalName}}{ID: id}
+
+	if err := repo.Create(ctx, item); err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	found, err := repo.FindByID(ctx, id)
+	if err != nil {
+		t.Fatalf("find by id: %v", err)
+	}
+	if found.ID != id {
+		t.Fatalf("want id %s, got %s", id, found.ID)
+	}
+	if err := repo.Delete(ctx, id); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+}
+
+// Two clients both hold version 1; the second save must be refused instead of
+// overwriting the first. Runs against the real database because the guard is
+// a WHERE clause — a stub would only be testing itself.
+func TestRepository_Update_RefusesStaleVersion(t *testing.T) {
+	repo := NewRepository(repositoryDBForTest(t))
+	ctx := context.Background()
+	item := &model.{{pascalName}}{ID: uuid.New()}
+
+	if err := repo.Create(ctx, item); err != nil {
+		t.Fatalf("create: %v", err)
+	}
+
+	first := &model.{{pascalName}}{ID: item.ID, Version: item.Version}
+	if err := repo.Update(ctx, first); err != nil {
+		t.Fatalf("first update: %v", err)
+	}
+	if first.Version != item.Version+1 {
+		t.Fatalf("want version bumped to %d, got %d", item.Version+1, first.Version)
+	}
+
+	stale := &model.{{pascalName}}{ID: item.ID, Version: item.Version}
+	if err := repo.Update(ctx, stale); !errors.Is(err, ErrStaleVersion) {
+		t.Fatalf("want ErrStaleVersion for the second writer, got %v", err)
+	}
+	if stale.Version != item.Version {
+		t.Fatalf("a refused update must leave the caller's version alone, got %d", stale.Version)
+	}
+}

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

@@ -33,8 +33,9 @@ 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
+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) {
@@ -61,13 +62,20 @@ func (s *Service) Get(ctx context.Context, id uuid.UUID) (*model.{{pascalName}},
 	return m, nil
 }
 
-func (s *Service) Update(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
+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 updateInput before saving
+	// 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()
 		}
@@ -78,6 +86,9 @@ func (s *Service) Update(ctx context.Context, id uuid.UUID) (*model.{{pascalName
 
 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()

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

@@ -12,24 +12,54 @@ import (
 	"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}}
+// repositoryStub exposes one function per dependency operation. Tests configure
+// only the calls they expect; an unexpected call panics instead of silently
+// returning a shared zero value/error that can hide broken orchestration.
+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
 }
 
-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
+func (s *repositoryStub) Create(ctx context.Context, m *model.{{pascalName}}) error {
+	if s.createFn == nil {
+		panic("unexpected repository.Create call")
 	}
-	return f.m, nil
+	return s.createFn(ctx, m)
 }
-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 (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)
+}
+
+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)
+}
+
+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)
+}
+
+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
 
 func status(t *testing.T, err error) int {
 	t.Helper()
@@ -41,25 +71,91 @@ func status(t *testing.T, err error) int {
 }
 
 func TestService_Create_Duplicate(t *testing.T) {
-	svc := NewService(&fakeRepo{err: gorm.ErrDuplicatedKey})
-	_, err := svc.Create(context.Background())
+	repo := &repositoryStub{
+		createFn: func(context.Context, *model.{{pascalName}}) error {
+			return gorm.ErrDuplicatedKey
+		},
+	}
+	svc := NewService(repo)
+
+	_, err := svc.Create(context.Background(), createInput{})
+
 	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})
+	repo := &repositoryStub{
+		findByIDFn: func(context.Context, uuid.UUID) (*model.{{pascalName}}, error) {
+			return nil, gorm.ErrRecordNotFound
+		},
+	}
+	svc := NewService(repo)
+
 	_, 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")})
+	repo := &repositoryStub{
+		findAllFn: func(context.Context, int, int) ([]model.{{pascalName}}, error) {
+			return nil, errors.New("connection refused")
+		},
+	}
+	svc := NewService(repo)
+
 	_, err := svc.List(context.Background(), 20, 0)
+
 	if got := status(t, err); got != 500 {
 		t.Fatalf("want 500, got %d", got)
 	}
 }
+
+// The check that stops one user's save from silently erasing another's: the
+// repository reports the row moved on, the client must see 409 rather than a
+// 500 or, worse, a success.
+func TestService_Update_StaleVersion(t *testing.T) {
+	repo := &repositoryStub{
+		findByIDFn: func(_ context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
+			return &model.{{pascalName}}{ID: id, Version: 7}, nil
+		},
+		updateFn: func(context.Context, *model.{{pascalName}}) error {
+			return ErrStaleVersion
+		},
+	}
+	svc := NewService(repo)
+
+	_, err := svc.Update(context.Background(), uuid.New(), updateInput{Version: 3})
+
+	if got := status(t, err); got != 409 {
+		t.Fatalf("want 409 stale, got %d", got)
+	}
+}
+
+// The version compared against the database has to be the one the client sent,
+// not the one just read back — comparing the row against itself would always
+// match and the guard would never fire.
+func TestService_Update_SendsClientVersion(t *testing.T) {
+	var seen int
+	repo := &repositoryStub{
+		findByIDFn: func(_ context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
+			return &model.{{pascalName}}{ID: id, Version: 7}, nil
+		},
+		updateFn: func(_ context.Context, m *model.{{pascalName}}) error {
+			seen = m.Version
+			return nil
+		},
+	}
+	svc := NewService(repo)
+
+	if _, err := svc.Update(context.Background(), uuid.New(), updateInput{Version: 3}); err != nil {
+		t.Fatalf("update: %v", err)
+	}
+	if seen != 3 {
+		t.Fatalf("want the client's version 3 to reach the repository, got %d", seen)
+	}
+}

package/dist/commands/remove.js

@@ -1,89 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeModule = removeModule;
-const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const picocolors_1 = __importDefault(require("picocolors"));
-const prompts_1 = require("@inquirer/prompts");
-const config_1 = require("../utils/config");
-const naming_1 = require("../utils/naming");
-const main_patcher_1 = require("../utils/main-patcher");
-const openapi_patcher_1 = require("../utils/openapi-patcher");
-const template_renderer_1 = require("../utils/template-renderer");
-const generate_wizard_1 = require("../prompts/generate-wizard");
-// removeModule is the inverse of generateModule: deletes the domain package and
-// pulls its wiring back out of main.go / openapi.yaml / migrations, so dropping
-// a domain is one command instead of hand-editing 3+ files (the error-prone
-// path that produced the duplicate-registration bug in the first place).
-async function removeModule(rawName, opts, projectDir = process.cwd()) {
-    const config = (0, config_1.readConfig)(projectDir);
-    const naming = (0, naming_1.resolveModuleNaming)(rawName ?? (await (0, generate_wizard_1.promptModuleName)()));
-    const modulePath = naming.pkg;
-    const moduleDir = path_1.default.join(projectDir, "internal", "app", modulePath);
-    if (!fs_extra_1.default.existsSync(moduleDir)) {
-        throw new Error(`module "${naming.pkg}" not found at internal/app/${modulePath} — nothing to remove`);
-    }
-    if (!opts.yes) {
-        const ok = await (0, prompts_1.confirm)({
-            message: `Remove module "${naming.pkg}"? Deletes internal/app/${modulePath}/, its migration, and un-wires main.go/openapi.yaml`,
-            default: false,
-        });
-        if (!ok)
-            throw new Error("removal cancelled");
-    }
-    // detect --auth/--permission from the generated handler.go itself (not
-    // stored anywhere else) — unpatchMainGo needs the exact same flags used at
-    // generate-time to reconstruct the identical line it's removing.
-    const handlerGoPath = path_1.default.join(moduleDir, "handler.go");
-    let auth;
-    let permission;
-    if (fs_extra_1.default.existsSync(handlerGoPath)) {
-        const handlerContent = fs_extra_1.default.readFileSync(handlerGoPath, "utf8");
-        auth = /jwtSecret\s+string/.test(handlerContent);
-        permission = handlerContent.match(/h\.authz\.Require\("([^"]+)"\)/)?.[1];
-    }
-    // 1. the domain package
-    fs_extra_1.default.removeSync(moduleDir);
-    // 2. main.go wiring
-    (0, main_patcher_1.unpatchMainGo)(path_1.default.join(projectDir, "cmd", "api", "main.go"), {
-        goModule: config.goModule,
-        modulePath,
-        pkg: naming.pkg,
-        pascalName: naming.pascalName,
-        auth,
-        permission,
-    });
-    // 3. openapi index + per-module docs
-    const openapiPath = path_1.default.join(projectDir, "docs", "openapi.yaml");
-    if (fs_extra_1.default.existsSync(openapiPath)) {
-        (0, openapi_patcher_1.unpatchOpenapiIndex)(openapiPath, naming, config.apiPrefix);
-        fs_extra_1.default.removeSync(path_1.default.join(projectDir, "docs", naming.plural));
-    }
-    // 4. migration files (up + down) — including the --permission seed
-    // migration, if this module was generated with one.
-    const migrationsDir = path_1.default.join(projectDir, "migrations");
-    const removedMigrations = [];
-    if (fs_extra_1.default.existsSync(migrationsDir)) {
-        for (const f of fs_extra_1.default.readdirSync(migrationsDir)) {
-            if (f.endsWith(`_create_${naming.plural}.up.sql`) ||
-                f.endsWith(`_create_${naming.plural}.down.sql`) ||
-                f.endsWith(`_add_${naming.plural}_permission.up.sql`) ||
-                f.endsWith(`_add_${naming.plural}_permission.down.sql`)) {
-                fs_extra_1.default.removeSync(path_1.default.join(migrationsDir, f));
-                removedMigrations.push(f);
-            }
-        }
-    }
-    (0, template_renderer_1.gofmtTree)(projectDir);
-    console.log(picocolors_1.default.green(`\nremoved module "${naming.pkg}"`));
-    console.log(`  deleted internal/app/${modulePath}/`);
-    console.log(`  un-wired cmd/api/main.go`);
-    if (fs_extra_1.default.existsSync(openapiPath))
-        console.log(`  un-wired docs/openapi.yaml + deleted docs/${naming.plural}/`);
-    if (removedMigrations.length)
-        console.log(`  deleted ${removedMigrations.join(", ")}`);
-    console.log(picocolors_1.default.yellow(`\nnote: the ${naming.plural} table (if migrated) is untouched — drop it yourself, or add a down migration`));
-}

package/templates/add/worker/internal/platform/queue/client.go.hbs

@@ -1,31 +0,0 @@
-package queue
-
-import (
-	"github.com/hibiken/asynq"
-)
-
-// Client enqueues tasks to Redis. Created by cmd/api; each domain or platform
-// package defines its own task types and calls Client.Enqueue.
-type Client struct {
-	inner *asynq.Client
-}
-
-func NewClient(redisURL string) (*Client, error) {
-	opt, err := asynq.ParseRedisURI(redisURL)
-	if err != nil {
-		return nil, err
-	}
-	return &Client{inner: asynq.NewClient(opt)}, nil
-}
-
-func (c *Client) Enqueue(task *asynq.Task, opts ...asynq.Option) (string, error) {
-	info, err := c.inner.Enqueue(task, opts...)
-	if err != nil {
-		return "", err
-	}
-	return info.ID, nil
-}
-
-func (c *Client) Close() error {
-	return c.inner.Close()
-}

package/templates/add/worker/internal/platform/queue/server.go.hbs

@@ -1,68 +0,0 @@
-package queue
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-
-	"github.com/hibiken/asynq"
-)
-
-// Server runs the background worker. Created by cmd/worker; handlers register
-// their task types on the mux before Start is called.
-type Server struct {
-	inner *asynq.Server
-	mux   *asynq.ServeMux
-}
-
-// slogAdapter wraps *slog.Logger to implement asynq.Logger. Asynq calls these
-// like the stdlib `log` package (a plain message, sometimes several args
-// meant to be concatenated) — fmt.Sprint joins them into one message string
-// rather than passing them as slog key-value pairs, which would otherwise
-// misinterpret a lone message argument as a key with no value.
-type slogAdapter struct {
-	inner *slog.Logger
-}
-
-func (a *slogAdapter) Debug(args ...interface{}) { a.inner.Debug(fmt.Sprint(args...)) }
-func (a *slogAdapter) Info(args ...interface{})  { a.inner.Info(fmt.Sprint(args...)) }
-func (a *slogAdapter) Warn(args ...interface{})  { a.inner.Warn(fmt.Sprint(args...)) }
-func (a *slogAdapter) Error(args ...interface{}) { a.inner.Error(fmt.Sprint(args...)) }
-func (a *slogAdapter) Fatal(args ...interface{}) { a.inner.Error(fmt.Sprint(args...)) }
-
-func NewServer(redisURL string) (*Server, error) {
-	opt, err := asynq.ParseRedisURI(redisURL)
-	if err != nil {
-		return nil, err
-	}
-	srv := &Server{
-		inner: asynq.NewServer(opt, asynq.Config{
-			Concurrency: 10,
-			Logger:      &slogAdapter{inner: slog.Default()},
-		}),
-		mux: asynq.NewServeMux(),
-	}
-	// Global error handler for tasks that panic or return a non-Retryable error.
-	srv.mux.Use(func(next asynq.Handler) asynq.Handler {
-		return asynq.HandlerFunc(func(ctx context.Context, task *asynq.Task) error {
-			err := next.ProcessTask(ctx, task)
-			if err != nil {
-				slog.Error("task failed", "type", task.Type(), "error", err)
-			}
-			return err
-		})
-	})
-	return srv, nil
-}
-
-func (s *Server) Handle(pattern string, handler asynq.Handler) {
-	s.mux.Handle(pattern, handler)
-}
-
-func (s *Server) Start() error {
-	return s.inner.Start(s.mux)
-}
-
-func (s *Server) Shutdown() {
-	s.inner.Shutdown()
-}