@nakedev/go-scaffold 0.1.3 → 0.3.0

package/dist/utils/golangci-patcher.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchGolangciForModule = patchGolangciForModule;
+exports.unpatchGolangciForModule = unpatchGolangciForModule;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const marker_patch_1 = require("./marker-patch");
+const DEPGUARD_MARKER = "# go-scaffold:depguard-rules";
+function ruleName(pkg) {
+    return `domain-isolation-${pkg}`;
+}
+// depguardRule is the per-domain boundary rule. It has to be per-domain
+// because depguard matches import paths as static prefixes with no idea which
+// domain a file belongs to: a single `deny: internal/app` rule would also
+// reject `order` importing its own `order/model`. Scoping with `files:` and
+// allowing exactly this domain's own path gives "may import myself, may not
+// import a sibling".
+//
+// Written with no leading indentation — insertBeforeMarker re-indents the
+// whole block to match the marker's own column.
+function depguardRule(goModule, pkg) {
+    return [
+        `${ruleName(pkg)}:`,
+        `  list-mode: lax`,
+        `  files:`,
+        `    - "**/internal/app/${pkg}/**"`,
+        `  allow:`,
+        `    - "${goModule}/internal/app/${pkg}"`,
+        `  deny:`,
+        `    - pkg: "${goModule}/internal/app"`,
+        `      desc: >-`,
+        `        a domain must not import another domain directly — declare a`,
+        `        consumer-side interface for what you need and let`,
+        `        cmd/api/wiring.go wire the concrete service in`,
+        `        (docs/architect/patterns.md)`,
+    ].join("\n");
+}
+// patchGolangciForModule adds this domain's boundary rule. No-op on a project
+// whose .golangci.yml predates the marker (or was replaced wholesale) — a
+// missing lint rule must never fail code generation.
+function patchGolangciForModule(golangciPath, goModule, pkg) {
+    if (!fs_extra_1.default.existsSync(golangciPath))
+        return;
+    const content = fs_extra_1.default.readFileSync(golangciPath, "utf8");
+    if (!content.includes(DEPGUARD_MARKER))
+        return;
+    fs_extra_1.default.writeFileSync(golangciPath, (0, marker_patch_1.insertBeforeMarkerOnce)(content, DEPGUARD_MARKER, depguardRule(goModule, pkg), `${ruleName(pkg)}:`));
+}
+// unpatchGolangciForModule drops the rule again, matched by its heading and
+// everything indented under it — the inverse of patchGolangciForModule.
+function unpatchGolangciForModule(golangciPath, pkg) {
+    if (!fs_extra_1.default.existsSync(golangciPath))
+        return;
+    const lines = fs_extra_1.default.readFileSync(golangciPath, "utf8").split("\n");
+    const heading = `${ruleName(pkg)}:`;
+    const start = lines.findIndex((l) => l.trim() === heading);
+    if (start === -1)
+        return;
+    const indent = lines[start].length - lines[start].trimStart().length;
+    let end = start + 1;
+    while (end < lines.length) {
+        const line = lines[end];
+        // blank lines belong to the block only if something indented follows
+        const deeper = line.trim() === "" || line.length - line.trimStart().length > indent;
+        if (!deeper)
+            break;
+        end++;
+    }
+    lines.splice(start, end - start);
+    fs_extra_1.default.writeFileSync(golangciPath, lines.join("\n"));
+}

package/dist/utils/gomod-patcher.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchGoModRequires = patchGoModRequires;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+// Every `add` command pulls in third-party packages, and none of them used to
+// touch go.mod — the imports just appeared and `go mod tidy` was left to
+// resolve them. Tidy picks the latest release of anything it doesn't already
+// have a version for, so two people running `add auth` a month apart got
+// different builds from the same CLI, and nothing recorded which versions the
+// scaffold was actually written and tested against.
+//
+// Pinning here fixes that: tidy honours a version that's already in go.mod
+// rather than reaching for latest. It's a floor, not a ceiling — if another
+// feature needs something newer, tidy still resolves upward, which is why
+// golang.org/x/crypto can be pinned by `add auth` and later raised by
+// `add observability`.
+//
+// Users still need to run `go mod tidy` (every command says so): these lines
+// have no go.sum entries, and only tidy can add those.
+function patchGoModRequires(goModPath, requires) {
+    if (!fs_extra_1.default.existsSync(goModPath))
+        return;
+    let content = fs_extra_1.default.readFileSync(goModPath, "utf8");
+    // already-present modules are left at whatever version they're on: a
+    // re-run, or a version the user deliberately bumped, is not ours to reset
+    const missing = requires.filter((line) => !hasModule(content, modulePathOf(line)));
+    if (missing.length === 0)
+        return;
+    const block = content.match(/^require \(\n(?:.*\n)*?\)$/m);
+    if (!block) {
+        // no grouped require block (hand-edited, or single-line `require x y`
+        // form) — append one rather than trying to rewrite what's there
+        content = content.replace(/\n?$/, "\n") + `\nrequire (\n${missing.map((l) => `\t${l}`).join("\n")}\n)\n`;
+        fs_extra_1.default.writeFileSync(goModPath, content);
+        return;
+    }
+    const updated = block[0].replace(/\n\)$/, `\n${missing.map((l) => `\t${l}`).join("\n")}\n)`);
+    // function replacer: a version string can't contain $ today, but this is the
+    // same trap ensureImport documents and costs nothing to avoid
+    fs_extra_1.default.writeFileSync(goModPath, content.replace(block[0], () => updated));
+}
+function modulePathOf(requireLine) {
+    return requireLine.trim().split(/\s+/)[0];
+}
+// Word-boundary match on the module path, so `go.opentelemetry.io/otel`
+// doesn't count as already-present when only `go.opentelemetry.io/otel/sdk`
+// is there.
+function hasModule(goMod, modulePath) {
+    return goMod.split("\n").some((line) => modulePathOf(line) === modulePath);
+}

package/dist/utils/main-patcher.js

@@ -3,11 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertMainGoPatchable = assertMainGoPatchable;
 exports.patchMainGo = patchMainGo;
 exports.unpatchMainGo = unpatchMainGo;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const marker_patch_1 = require("./marker-patch");
 const IMPORT_MARKER = "// go-scaffold:imports";
+const SCHEMA_MARKER = "// go-scaffold:schemas";
 const MODEL_MARKER = "// go-scaffold:models";
 const ROUTE_MARKER = "// go-scaffold:routes";
 // no leading tab: insertBeforeMarker re-indents, and removeLines matches by
@@ -15,9 +17,19 @@ const ROUTE_MARKER = "// go-scaffold:routes";
 const UNUSED_API_LINE = "_ = api // dropped once `generate module` registers the first route";
 // the exact lines patchMainGo inserts for a module — one source of truth so
 // unpatchMainGo removes precisely what patch added.
+//
+// The service gets its own named variable rather than being constructed
+// inline inside NewHandler(...). docs/architect/patterns.md tells you to wire
+// one domain's service into another's constructor when it needs behaviour
+// from it, which means editing this block by hand — and an inline expression
+// has nowhere to hold the result. With a named variable the edit is "add an
+// argument to the end of line one", and unpatchMainGo can still find the line
+// afterwards because it matches on the `<pkg>Svc :=` prefix, not the whole
+// text.
 function mainGoLines(patch) {
     const modelAlias = `${patch.pkg}model`; // every domain's model subpackage is named "model"
-    const handlerArgs = [`${patch.pkg}.NewService(${patch.pkg}.NewRepository(db))`];
+    const svcVar = `${patch.pkg}Svc`;
+    const handlerArgs = [svcVar];
     if (patch.auth)
         handlerArgs.push("cfg.JWTSecret");
     if (patch.permission)
@@ -25,7 +37,20 @@ function mainGoLines(patch) {
     return {
         importLine: `"${patch.goModule}/internal/app/${patch.modulePath}"`,
         modelImportLine: `${modelAlias} "${patch.goModule}/internal/app/${patch.modulePath}/model"`,
+        // AutoMigrate (dev) creates tables but not the schema they live in — see
+        // the comment on go-scaffold:schemas in main.go.hbs. One Exec per schema,
+        // guarded by its own sentinel so two modules sharing a schema name only
+        // ever produce one line (not expected today, but cheap to keep safe).
+        schemaLines: [
+            `if err := db.Exec("CREATE SCHEMA IF NOT EXISTS ${patch.schemaName}").Error; err != nil {`,
+            `\treturn fmt.Errorf("create schema ${patch.schemaName}: %w", err)`,
+            `}`,
+        ].join("\n"),
+        schemaSentinel: `CREATE SCHEMA IF NOT EXISTS ${patch.schemaName}`,
         migrateLine: `&${modelAlias}.${patch.pascalName}{},`,
+        serviceLine: `${svcVar} := ${patch.pkg}.NewService(${patch.pkg}.NewRepository(db))`,
+        // matches the service line however the user has since extended it
+        servicePrefix: `${svcVar} :=`,
         // `api` is the one route group declared by main.go.hbs, prefixed with
         // whatever apiPrefix the project chose at create time (e.g. /v1, /api,
         // or none) — every module registers on it, there is no per-module choice.
@@ -34,20 +59,43 @@ function mainGoLines(patch) {
         routeLine: `${patch.pkg}.NewHandler(${handlerArgs.join(", ")}).Register(api)`,
     };
 }
-// patchMainGo wires a newly generated module into cmd/api/main.go: its
+// assertMainGoPatchable is the pre-flight for it: every marker patchMainGo
+// needs, checked before the caller writes anything. Without it a missing
+// marker surfaced only once the module files and its migration were already
+// on disk, and the retry then hit "internal/app/<pkg> already exists" — a
+// dead end that pointed nowhere useful.
+function assertMainGoPatchable(mainGoPath) {
+    if (!fs_extra_1.default.existsSync(mainGoPath)) {
+        throw new Error(`${mainGoPath} not found — this doesn't look like a go-scaffold project`);
+    }
+    const content = fs_extra_1.default.readFileSync(mainGoPath, "utf8");
+    const missing = [IMPORT_MARKER, SCHEMA_MARKER, MODEL_MARKER, ROUTE_MARKER].filter((m) => !(0, marker_patch_1.hasMarker)(content, m));
+    if (missing.length) {
+        throw new Error(`cmd/api/wiring.go is missing the marker comment${missing.length > 1 ? "s" : ""} this command patches at:\n` +
+            missing.map((m) => `  ${m}`).join("\n") +
+            `\n\nEither the file was hand-edited, or it was scaffolded by an older go-scaffold that\n` +
+            `didn't emit ${missing.length > 1 ? "them" : "it"} yet. Add the marker${missing.length > 1 ? "s" : ""} back where the generated code should go, or\n` +
+            `wire this module into main.go by hand.`);
+    }
+}
+// patchMainGo wires a newly generated module into cmd/api/wiring.go: its
 // import, its model in the AutoMigrate call, and its route registration —
 // via marker comments rather than a Go AST rewrite (ponytail: text insertion
 // at a fixed marker is enough here; reach for go/ast if main.go ever needs
 // edits markers can't express).
 function patchMainGo(mainGoPath, patch) {
     let content = fs_extra_1.default.readFileSync(mainGoPath, "utf8");
-    const { importLine, modelImportLine, migrateLine, routeLine } = mainGoLines(patch);
+    const { importLine, modelImportLine, schemaLines, schemaSentinel, migrateLine, serviceLine, servicePrefix, routeLine } = mainGoLines(patch);
     // each guarded by its own sentinel so re-running after only the module
     // folder was deleted (main.go still wired) is a no-op, not a dup that
     // panics gin at startup.
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, importLine, importLine);
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, modelImportLine, modelImportLine);
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, SCHEMA_MARKER, schemaLines, schemaSentinel);
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, MODEL_MARKER, migrateLine, migrateLine);
+    // sentinel is the prefix, not the whole line: a re-run must not add a
+    // second service line just because the first one gained a dependency.
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, ROUTE_MARKER, serviceLine, servicePrefix);
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, ROUTE_MARKER, routeLine, routeLine);
     content = (0, marker_patch_1.removeLines)(content, [UNUSED_API_LINE]);
     fs_extra_1.default.writeFileSync(mainGoPath, content);
@@ -57,8 +105,14 @@ function patchMainGo(mainGoPath, patch) {
 // main.go still compiles (api would otherwise be declared-and-unused).
 function unpatchMainGo(mainGoPath, patch) {
     let content = fs_extra_1.default.readFileSync(mainGoPath, "utf8");
-    const { importLine, modelImportLine, migrateLine, routeLine } = mainGoLines(patch);
+    const { importLine, modelImportLine, schemaLines, migrateLine, servicePrefix, routeLine } = mainGoLines(patch);
     content = (0, marker_patch_1.removeLines)(content, [importLine, modelImportLine, migrateLine, routeLine]);
+    // by prefix: the service line may have grown arguments since it was written
+    content = (0, marker_patch_1.removeLinesByPrefix)(content, [servicePrefix]);
+    // by contiguous block, not removeLines: every module's schema block is
+    // identical except the schema name, so a line-by-line removal would also
+    // strip another module's matching lines.
+    content = (0, marker_patch_1.removeBlock)(content, schemaLines);
     if (!content.includes(".Register(api)") && !content.includes(UNUSED_API_LINE)) {
         content = (0, marker_patch_1.insertBeforeMarker)(content, ROUTE_MARKER, UNUSED_API_LINE);
     }

package/dist/utils/marker-patch.js

@@ -10,6 +10,8 @@ exports.hasMarker = hasMarker;
 exports.ensureImport = ensureImport;
 exports.insertBeforeMarkerOnce = insertBeforeMarkerOnce;
 exports.removeLines = removeLines;
+exports.removeBlock = removeBlock;
+exports.removeLinesByPrefix = removeLinesByPrefix;
 exports.insertBeforeMarker = insertBeforeMarker;
 function hasMarker(content, marker) {
     return content.split("\n").some((l) => l.trim() === marker);
@@ -24,7 +26,12 @@ function ensureImport(content, importPath) {
     const importLine = `"${importPath}"`;
     if (content.includes(importLine))
         return content;
-    return content.replace(/import \(\n/, `import (\n\t${importLine}\n`);
+    // A function replacer, not a string one: String.replace treats "$$", "$&",
+    // digit-groups etc. in a *string* replacement as special patterns even when
+    // the search argument is a plain string, not a regex — collapsing any "$$"
+    // that happens to appear in importLine. A function's return value is spliced
+    // in literally, so this holds regardless of what importPath contains.
+    return content.replace(/import \(\n/, () => `import (\n\t${importLine}\n`);
 }
 // insertBeforeMarkerOnce: like insertBeforeMarker but a no-op if `sentinel`
 // already appears in the file. Makes module wiring idempotent — re-running
@@ -38,7 +45,7 @@ function insertBeforeMarkerOnce(content, marker, block, sentinel) {
     return insertBeforeMarker(content, marker, block);
 }
 // removeLines drops every line whose trimmed text exactly equals one of the
-// given lines — the inverse of insertBeforeMarker for `remove module`, which
+// given lines — the inverse of insertBeforeMarker for `undo module`, which
 // needs to pull a module's import/route/path entries back out. Exact-trim
 // match so it can't clip an unrelated line that merely contains the text.
 function removeLines(content, trimmedLines) {
@@ -48,6 +55,116 @@ function removeLines(content, trimmedLines) {
         .filter((l) => !drop.has(l.trim()))
         .join("\n");
 }
+// removeBlock removes a multi-line block inserted by insertBeforeMarker,
+// matched as one contiguous run (each line compared trimmed) rather than
+// line-by-line like removeLines. Needed when a block's individual lines
+// aren't unique on their own — two modules' schema-creation blocks in
+// main.go are identical except for the schema name itself, and removeLines
+// would delete the shared lines from both when asked to remove just one.
+function removeBlock(content, block) {
+    const blockLines = block.split("\n").map((l) => l.trim());
+    const lines = content.split("\n");
+    const out = [];
+    for (let i = 0; i < lines.length;) {
+        const matches = blockLines.every((bl, j) => lines[i + j]?.trim() === bl);
+        if (matches) {
+            i += blockLines.length;
+        }
+        else {
+            out.push(lines[i]);
+            i += 1;
+        }
+    }
+    return out.join("\n");
+}
+// removeLinesByPrefix is removeLines for a line the user is expected to edit
+// after it was generated — a service constructor that has since gained a
+// dependency, say. Matching the whole line would miss it and leave the
+// project un-compilable after `undo module`; matching a distinctive prefix
+// (`orderSvc :=`) still finds it. Only use it where the prefix is unique.
+//
+// A match consumes lines until its brackets balance, not just the first one:
+// docs/architect/patterns.md tells you to expand that single wiring line into
+// a multi-line adapter literal, and dropping only line one leaves an orphaned
+// func body behind — a main.go that no longer parses, reported by the Go
+// compiler long after `undo module` has printed success.
+function removeLinesByPrefix(content, prefixes) {
+    const lines = content.split("\n");
+    const out = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        if (!prefixes.some((p) => lines[i].trim().startsWith(p))) {
+            out.push(lines[i]);
+            continue;
+        }
+        const start = i;
+        let depth = 0;
+        let overran = false;
+        do {
+            // A marker comment is a structural anchor — no wiring statement can
+            // contain one. Reaching it with brackets still open means the count is
+            // wrong (a malformed line above), and carrying on would swallow the
+            // marker plus every module wired after it. Stop at the boundary.
+            if (i > start && lines[i].trim().startsWith("// go-scaffold:")) {
+                overran = true;
+                break;
+            }
+            depth += bracketDelta(lines[i]);
+            i += 1;
+        } while (depth > 0 && i < lines.length);
+        // Either we hit a marker or ran out of file with brackets still open.
+        // Consuming anyway deletes everything in between — in main.go that's the
+        // other modules' wiring and the closing brace, from a command whose whole
+        // job is to touch one module. Refuse: undo un-wires before it deletes
+        // anything, so throwing here costs the user nothing.
+        if (overran || depth > 0) {
+            throw new Error(`the statement starting at line ${start + 1} never closes its brackets:\n` +
+                `  ${lines[start].trim()}\n\n` +
+                `Refusing to guess where it ends — removing through to where the count finally balances\n` +
+                `would take the lines in between with it. Fix the brackets, or remove it by hand.`);
+        }
+        i -= 1; // the for's own increment steps past the last consumed line
+    }
+    return out.join("\n");
+}
+// bracketDelta counts on code only. Brackets inside a string literal or a
+// trailing comment are text, not structure — `order.WithPrefix("(")` on the
+// wiring line would otherwise leave the count permanently open.
+//
+// ponytail: a raw string that spans lines is still counted wrong, since this
+// works a line at a time. Nothing generated produces one; reach for go/ast if
+// that ever changes.
+function bracketDelta(line) {
+    let delta = 0;
+    for (const ch of stripLiteralsAndComments(line)) {
+        if (ch === "(" || ch === "{" || ch === "[")
+            delta += 1;
+        else if (ch === ")" || ch === "}" || ch === "]")
+            delta -= 1;
+    }
+    return delta;
+}
+function stripLiteralsAndComments(line) {
+    let out = "";
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (ch === "/" && line[i + 1] === "/")
+            break; // rest of the line is a comment
+        if (ch !== '"' && ch !== "'" && ch !== "`") {
+            out += ch;
+            continue;
+        }
+        // skip to the closing quote; \" doesn't close an interpreted string, but
+        // a backslash is literal inside a raw one
+        const quote = ch;
+        i += 1;
+        while (i < line.length && line[i] !== quote) {
+            if (quote !== "`" && line[i] === "\\")
+                i += 1;
+            i += 1;
+        }
+    }
+    return out;
+}
 function insertBeforeMarker(content, marker, block) {
     const lines = content.split("\n");
     const markerLine = lines.find((l) => l.trim() === marker);
@@ -59,5 +176,10 @@ function insertBeforeMarker(content, marker, block) {
         .split("\n")
         .map((line) => (line ? `${indent}${line}` : line))
         .join("\n");
-    return content.replace(markerLine, `${indentedBlock}\n${markerLine}`);
+    // Function replacer, not a string one — see the comment on ensureImport.
+    // Every caller of this — main.go/patterns.md route and import wiring,
+    // depguard rules, rbac's main.go patches — funnels through here, so fixing
+    // it here is what actually closes the bug off, rather than auditing every
+    // block a caller happens to pass in today.
+    return content.replace(markerLine, () => `${indentedBlock}\n${markerLine}`);
 }

package/dist/utils/method-patcher.js

@@ -12,9 +12,12 @@ const DTO_MARKER = "// go-scaffold:dto";
 const REPO_INTERFACE_MARKER = "// go-scaffold:repository-interface";
 const REPO_IMPL_MARKER = "// go-scaffold:repository-methods";
 const SERVICE_MARKER = "// go-scaffold:service-methods";
+const SERVICE_INTERFACE_MARKER = "// go-scaffold:service-interface";
 const HANDLER_ROUTES_MARKER = "// go-scaffold:handler-routes";
 const HANDLER_FUNCS_MARKER = "// go-scaffold:handler-funcs";
-const FAKE_REPO_MARKER = "// go-scaffold:fake-repo-methods";
+const REPOSITORY_STUB_FIELDS_MARKER = "// go-scaffold:repository-stub-fields";
+const REPOSITORY_STUB_METHODS_MARKER = "// go-scaffold:repository-stub-methods";
+const LEGACY_FAKE_REPO_METHODS_MARKER = "// go-scaffold:fake-repo-methods";
 const UNUSED_G_LINE = "\t_ = g\n";
 // writeHandler ensures whatever packages the new handler code references are
 // imported (a minimal module starts with only "gin" imported) and drops the
@@ -62,6 +65,48 @@ function patchMethod(paths, naming, method, opts, goModule) {
     else {
         patchDelete(paths, method, goModule);
     }
+    patchHandlerServiceInterface(paths.handlerPath, naming, method, opts, goModule);
+}
+function patchHandlerServiceInterface(handlerPath, naming, method, opts, goModule) {
+    let signature;
+    let needsModel = true;
+    let needsUUID = false;
+    if (opts.type === "get" && opts.getMode === "all") {
+        signature = `${method.pascalName}(context.Context, int, int) ([]model.${naming.pascalName}, error)`;
+    }
+    else if (opts.type === "get") {
+        signature = `${method.pascalName}(context.Context, string) (*model.${naming.pascalName}, error)`;
+    }
+    else if (opts.type === "post") {
+        signature = `${method.pascalName}(context.Context, ${method.pascalName}Input) (*model.${naming.pascalName}, error)`;
+    }
+    else if (opts.type === "put" || opts.type === "patch") {
+        signature = `${method.pascalName}(context.Context, uuid.UUID) (*model.${naming.pascalName}, error)`;
+        needsUUID = true;
+    }
+    else {
+        signature = `${method.pascalName}(context.Context, uuid.UUID) error`;
+        needsModel = false;
+        needsUUID = true;
+    }
+    let handler = fs_extra_1.default.readFileSync(handlerPath, "utf8");
+    if (!(0, marker_patch_1.hasMarker)(handler, SERVICE_INTERFACE_MARKER)) {
+        // Projects scaffolded before the narrow service interface stored *Service
+        // directly. The concrete type already exposes generated methods, so there
+        // is no interface declaration to patch and no migration is required.
+        if (handler.includes("svc *Service"))
+            return;
+        throw new Error(`marker "${SERVICE_INTERFACE_MARKER}" not found and Handler does not use legacy *Service wiring`);
+    }
+    handler = (0, marker_patch_1.insertBeforeMarker)(handler, SERVICE_INTERFACE_MARKER, signature);
+    handler = (0, marker_patch_1.ensureImport)(handler, "context");
+    if (needsModel) {
+        handler = (0, marker_patch_1.ensureImport)(handler, `${goModule}/internal/app/${naming.pkg}/model`);
+    }
+    if (needsUUID) {
+        handler = (0, marker_patch_1.ensureImport)(handler, "github.com/google/uuid");
+    }
+    fs_extra_1.default.writeFileSync(handlerPath, handler);
 }
 function patchGetAll(paths, naming, method, goModule) {
     let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
@@ -106,8 +151,13 @@ function patchGetOne(paths, naming, method, rawField, goModule) {
     repo = (0, marker_patch_1.insertBeforeMarker)(repo, REPO_IMPL_MARKER, [
         `func (r *Repository) FindBy${fieldPascal}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error) {`,
         `\tvar m model.${naming.pascalName}`,
-        `\t// TODO: confirm "${fieldColumn}" is the real column name for ${fieldParam}`,
-        `\tif err := r.db.WithContext(ctx).First(&m, "${fieldColumn} = ?", ${fieldParam}).Error; err != nil {`,
+        `\t// TODO: add the "${fieldColumn}" column and an index on it — this query`,
+        `\t// compiles against any table and only fails when it runs.`,
+        `\t//`,
+        `\t// tx.From, like every other method here: a lookup that reached for r.db`,
+        `\t// directly would read outside a transaction its caller had opened, and`,
+        `\t// so miss that transaction's own uncommitted writes.`,
+        `\tif err := tx.From(ctx, r.db).WithContext(ctx).First(&m, "${fieldColumn} = ?", ${fieldParam}).Error; err != nil {`,
         `\t\treturn nil, err`,
         `\t}`,
         `\treturn &m, nil`,
@@ -117,22 +167,40 @@ function patchGetOne(paths, naming, method, rawField, goModule) {
     fs_extra_1.default.writeFileSync(paths.repositoryPath, repo);
     let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
     service = (0, marker_patch_1.insertBeforeMarker)(service, REPO_INTERFACE_MARKER, `FindBy${fieldPascal}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error)`);
-    // the interface just grew, so the hand-written fakeRepo mock in
-    // service_test.go needs a matching stub or the test file stops compiling
+    // The repository interface just grew, so the test double needs a matching
+    // method or focused service tests stop compiling. New projects use a
+    // function-backed stub; projects scaffolded before that refactor retain the
+    // old fakeRepo marker and error behavior.
     let serviceTest = fs_extra_1.default.readFileSync(paths.serviceTestPath, "utf8");
-    serviceTest = (0, marker_patch_1.insertBeforeMarker)(serviceTest, FAKE_REPO_MARKER, [
-        // nolint: only matters for a minimal module (fakeRepo never instantiated
-        // yet, so unused flags every one of its methods individually); harmless
-        // no-op on a full module where fakeRepo is already in use.
-        `//nolint:unused`,
-        `func (f *fakeRepo) FindBy${fieldPascal}(context.Context, string) (*model.${naming.pascalName}, error) {`,
-        `\tif f.err != nil {`,
-        `\t\treturn nil, f.err`,
-        `\t}`,
-        `\treturn f.m, nil`,
-        `}`,
-        ``,
-    ].join("\n"));
+    if ((0, marker_patch_1.hasMarker)(serviceTest, REPOSITORY_STUB_FIELDS_MARKER) &&
+        (0, marker_patch_1.hasMarker)(serviceTest, REPOSITORY_STUB_METHODS_MARKER)) {
+        serviceTest = (0, marker_patch_1.insertBeforeMarker)(serviceTest, REPOSITORY_STUB_FIELDS_MARKER, `findBy${fieldPascal}Fn func(context.Context, string) (*model.${naming.pascalName}, error)`);
+        serviceTest = (0, marker_patch_1.insertBeforeMarker)(serviceTest, REPOSITORY_STUB_METHODS_MARKER, [
+            `//nolint:unused`,
+            `func (s *repositoryStub) FindBy${fieldPascal}(ctx context.Context, value string) (*model.${naming.pascalName}, error) {`,
+            `\tif s.findBy${fieldPascal}Fn == nil {`,
+            `\t\tpanic("unexpected repository.FindBy${fieldPascal} call")`,
+            `\t}`,
+            `\treturn s.findBy${fieldPascal}Fn(ctx, value)`,
+            `}`,
+            ``,
+        ].join("\n"));
+    }
+    else if ((0, marker_patch_1.hasMarker)(serviceTest, LEGACY_FAKE_REPO_METHODS_MARKER)) {
+        serviceTest = (0, marker_patch_1.insertBeforeMarker)(serviceTest, LEGACY_FAKE_REPO_METHODS_MARKER, [
+            `//nolint:unused`,
+            `func (f *fakeRepo) FindBy${fieldPascal}(context.Context, string) (*model.${naming.pascalName}, error) {`,
+            `\tif f.err != nil {`,
+            `\t\treturn nil, f.err`,
+            `\t}`,
+            `\treturn f.m, nil`,
+            `}`,
+            ``,
+        ].join("\n"));
+    }
+    else {
+        throw new Error(`neither current repository stub markers nor legacy "${LEGACY_FAKE_REPO_METHODS_MARKER}" found in ${paths.serviceTestPath}`);
+    }
     fs_extra_1.default.writeFileSync(paths.serviceTestPath, serviceTest);
     service = (0, marker_patch_1.insertBeforeMarker)(service, SERVICE_MARKER, [
         `func (s *Service) ${method.pascalName}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error) {`,
@@ -224,7 +292,17 @@ function patchResourceAction(paths, naming, method, type, goModule) {
         `\t\treturn nil, wrapFindErr(err)`,
         `\t}`,
         `\t// TODO: implement "${method.name}" — currently a no-op save`,
+        `\t// The version compared here is the one just read, so this only`,
+        `\t// catches a writer that lands between the read above and this write.`,
+        `\t// It is NOT the check Update does: that one compares against the version`,
+        `\t// the *client* last saw, which is what catches someone submitting a`,
+        `\t// form built from a copy that has since gone stale. If this endpoint`,
+        `\t// needs that, give it an input struct carrying Version and assign it`,
+        `\t// to m.Version here, the way service.go's Update does.`,
         `\tif err := s.repo.Update(ctx, m); err != nil {`,
+        `\t\tif errors.Is(err, ErrStaleVersion) {`,
+        `\t\t\treturn nil, errStale()`,
+        `\t\t}`,
         `\t\treturn nil, apperror.NewInternal()`,
         `\t}`,
         `\treturn m, nil`,
@@ -266,6 +344,7 @@ function markersPresent(handlerPath, servicePath) {
     const service = fs_extra_1.default.readFileSync(servicePath, "utf8");
     return ((0, marker_patch_1.hasMarker)(handler, HANDLER_ROUTES_MARKER) &&
         (0, marker_patch_1.hasMarker)(handler, HANDLER_FUNCS_MARKER) &&
+        ((0, marker_patch_1.hasMarker)(handler, SERVICE_INTERFACE_MARKER) || handler.includes("svc *Service")) &&
         (0, marker_patch_1.hasMarker)(service, SERVICE_MARKER) &&
         (0, marker_patch_1.hasMarker)(service, REPO_INTERFACE_MARKER));
 }

package/dist/utils/module-location.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.existingModulePackages = existingModulePackages;
+exports.resolveProjectModuleNaming = resolveProjectModuleNaming;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const naming_1 = require("./naming");
+function existingModulePackages(projectDir) {
+    const appDir = path_1.default.join(projectDir, "internal", "app");
+    if (!fs_extra_1.default.existsSync(appDir))
+        return [];
+    return fs_extra_1.default
+        .readdirSync(appDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+}
+// A Go package name has no word boundaries: "orderitem" cannot tell you it
+// came from "order-items". Everything else a command derives — the model type
+// (OrderItem), the route (/order-items), the table (order_items), the
+// migration filename — does depend on those boundaries, so re-deriving them
+// from the package name yields Orderitem/orderitems and code that doesn't
+// compile.
+//
+// That mattered because the package name is the one form of the name the user
+// actually sees: it's the folder on disk, and it's what `generate module`
+// prints as the next command to run. Following that instruction produced
+// `undefined: model.Orderitem (but have OrderItem)`.
+//
+// model/model.go is where the boundaries survive — the struct name is
+// PascalCase, so kebab-casing it recovers the exact string `generate module`
+// was originally given.
+function pascalNameOnDisk(projectDir, pkg) {
+    const modelPath = path_1.default.join(projectDir, "internal", "app", pkg, "model", "model.go");
+    if (!fs_extra_1.default.existsSync(modelPath))
+        return null;
+    const match = fs_extra_1.default.readFileSync(modelPath, "utf8").match(/^type\s+([A-Z]\w*)\s+struct\b/m);
+    return match ? match[1] : null;
+}
+function resolveProjectModuleNaming(projectDir, rawName) {
+    const located = (0, naming_1.resolveExistingModuleNaming)(rawName, existingModulePackages(projectDir));
+    const pascal = pascalNameOnDisk(projectDir, located.pkg);
+    if (!pascal || pascal === located.pascalName)
+        return located;
+    let fromDisk;
+    try {
+        fromDisk = (0, naming_1.resolveModuleNaming)((0, naming_1.toKebabCase)(pascal));
+    }
+    catch {
+        return located; // model.go holds something we can't derive a module name from
+    }
+    // Only trust the correction when it still points at the same package.
+    // A hand-renamed struct, or a legacy module whose type never matched its
+    // folder, would otherwise silently retarget the command at another module.
+    return fromDisk.pkg === located.pkg ? fromDisk : located;
+}