@nakedev/go-scaffold 0.1.4 → 0.3.0

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

@@ -2,15 +2,23 @@ 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
+// 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
 }
@@ -20,30 +28,76 @@ func NewRepository(db *gorm.DB) *Repository {
 }
 
 func (r *Repository) Create(ctx context.Context, m *model.{{pascalName}}) error {
-	return r.db.WithContext(ctx).Create(m).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 := r.db.WithContext(ctx).Order("id desc").Limit(limit).Offset(offset).Find(&items).Error
+	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 := r.db.WithContext(ctx).First(&m, "id = ?", id).Error; err != nil {
+	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 {
-	return r.db.WithContext(ctx).Save(m).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 {
-	return r.db.WithContext(ctx).Delete(&model.{{pascalName}}{}, "id = ?", id).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/repository_test.go.hbs

@@ -2,6 +2,7 @@ package {{pkg}}
 
 import (
 	"context"
+	"errors"
 	"os"
 	"testing"
 
@@ -77,3 +78,32 @@ func TestRepository_CreateFindDelete(t *testing.T) {
 		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

@@ -68,8 +68,14 @@ func (s *Service) Update(ctx context.Context, id uuid.UUID, in updateInput) (*mo
 		return nil, wrapFindErr(err)
 	}
 	// TODO: apply real fields from in before saving
-	_ = in
+	// 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()
 		}
@@ -80,6 +86,9 @@ func (s *Service) Update(ctx context.Context, id uuid.UUID, in updateInput) (*mo
 
 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

@@ -114,3 +114,48 @@ func TestService_List_DBError_Becomes500(t *testing.T) {
 		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,88 +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 module_location_1 = require("../utils/module-location");
-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 deletes application code and reverses generated wiring while
-// preserving immutable migration history and table data. Destructive schema
-// removal must be an explicit new migration, never a deletion of an applied one.
-async function removeModule(rawName, opts, projectDir = process.cwd()) {
-    const config = (0, config_1.readConfig)(projectDir);
-    const naming = (0, module_location_1.resolveProjectModuleNaming)(projectDir, 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}/ and its docs, ` +
-                `then un-wires main.go/openapi.yaml. Existing migrations, table, and data are preserved.`,
-            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 history is immutable. A migration may already be recorded in
-    // schema_migrations on production databases, so deleting its file would make
-    // existing and fresh environments disagree and can prevent the app booting.
-    // Re-generating the same module reuses this create migration.
-    const migrationsDir = path_1.default.join(projectDir, "migrations");
-    const preservedMigrations = fs_extra_1.default.existsSync(migrationsDir)
-        ? fs_extra_1.default.readdirSync(migrationsDir).filter((f) => 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`))
-        : [];
-    (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 (preservedMigrations.length) {
-        console.log(`  preserved migration history: ${preservedMigrations.join(", ")}`);
-    }
-    console.log(picocolors_1.default.yellow(`\nnote: the ${naming.tableName} table and its data are untouched. ` +
-        `To remove them safely, run \`go-scaffold generate migration drop_${naming.tableName}\` ` +
-        `and write an explicit up/down migration.`));
-}