@nakedev/go-scaffold 0.1.3 → 0.3.0

package/dist/utils/naming.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pluralize = pluralize;
 exports.toPascalCase = toPascalCase;
@@ -9,22 +12,21 @@ exports.toDbName = toDbName;
 exports.validateGoModulePath = validateGoModulePath;
 exports.assertValidGoModulePath = assertValidGoModulePath;
 exports.assertNotGoKeyword = assertNotGoKeyword;
+exports.assertGoIdentifier = assertGoIdentifier;
 exports.validateModuleName = validateModuleName;
 exports.normalizeApiPrefix = normalizeApiPrefix;
 exports.validateApiPrefix = validateApiPrefix;
 exports.resolveModuleNaming = resolveModuleNaming;
+exports.resolveExistingModuleNaming = resolveExistingModuleNaming;
+exports.migrationSlug = migrationSlug;
+exports.migrationSlugAliases = migrationSlugAliases;
 exports.resolveMethodNaming = resolveMethodNaming;
-// ponytail: heuristic pluralizer, not a dependency — covers common English
-// nouns (order/user/category/address); irregular plurals still need a manual
-// rename in the generated file, add a dictionary if that becomes frequent.
+const pluralize_1 = __importDefault(require("pluralize"));
+// Pluralization must be idempotent because module names may come from the
+// interactive prompt (singular) or a documented/scripted command (often
+// plural). Keep this wrapper exported for callers that only need inflection.
 function pluralize(word) {
-    if (/[sxz]$/.test(word) || /[^aeiou](ch|sh)$/.test(word))
-        return word + "es";
-    if (/[^aeiou]y$/.test(word))
-        return word.slice(0, -1) + "ies";
-    if (word.endsWith("s"))
-        return word;
-    return word + "s";
+    return pluralize_1.default.plural(word);
 }
 function toPascalCase(value) {
     return value
@@ -86,6 +88,13 @@ const GO_PREDECLARED_TYPES = new Set([
     "float32", "float64", "int", "int8", "int16", "int32", "int64", "rune",
     "string", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr",
 ]);
+// Directory names the go tool reserves. A module named "vendors" singularises
+// to "vendor", and internal/app/vendor is then treated as a vendor directory:
+// the build fails with "use of vendored package not allowed" and "must be
+// imported as model", for a project that was generated, not hand-written.
+// Not caught by the drift check either — that compares before and after, and
+// this breaks the whole module at once.
+const GO_RESERVED_DIRS = new Set(["vendor", "testdata"]);
 // method/handler/param identifier: only keywords are hard-illegal (a param or
 // func named `string` is legal Go, just shadows the builtin locally).
 function assertNotGoKeyword(ident, role) {
@@ -93,12 +102,25 @@ function assertNotGoKeyword(ident, role) {
         throw new Error(`"${ident}" is a Go keyword — can't use it as a ${role} name; pick another`);
     }
 }
+// Anything that ends up spliced into a Go declaration has to be a legal
+// identifier first. Without this, `generate method thing 2fa` exits 0 over a
+// `func (s *Service) 2fa(...)` spread across four files, and a --field like
+// `x string) error { panic(0) } // ` is injected straight into the generated
+// signatures. Neither is caught later: gofmt's failure is only advisory and
+// go vet needs a project that compiled a moment ago.
+function assertGoIdentifier(ident, role) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(ident)) {
+        throw new Error(`"${ident}" is not a valid Go identifier — can't use it as a ${role} name.\n` +
+            `Letters, digits and underscores only, and it can't start with a digit.`);
+    }
+    assertNotGoKeyword(ident, role);
+}
 // module name becomes a Go package name; keywords and predeclared type names
 // both produce code that won't compile (`package func`, or a `string` package
 // shadowing the builtin in main.go). Returns true|message for inquirer, and
 // backs the assert in resolveModuleNaming — one source of truth for both.
 function validateModuleName(rawName) {
-    const pkg = toPackageName(rawName);
+    const pkg = toPackageName(pluralize_1.default.singular(toKebabCase(rawName)));
     if (!pkg)
         return `invalid module name: "${rawName}" (must contain letters/numbers)`;
     if (/^[0-9]/.test(pkg)) {
@@ -107,6 +129,9 @@ function validateModuleName(rawName) {
     if (GO_KEYWORDS.has(pkg) || GO_PREDECLARED_TYPES.has(pkg)) {
         return `"${pkg}" is a reserved Go word — a package named it won't compile; pick another module name`;
     }
+    if (GO_RESERVED_DIRS.has(pkg)) {
+        return `"${pkg}" is a directory name the go tool reserves — internal/app/${pkg} would be treated as a ${pkg} directory and the project wouldn't build; pick another module name`;
+    }
     return true;
 }
 // strips whitespace and leading/trailing slashes so "/api/v1/" and "api/v1"
@@ -134,23 +159,109 @@ function resolveModuleNaming(rawName) {
     const check = validateModuleName(rawName);
     if (check !== true)
         throw new Error(check);
+    const singular = pluralize_1.default.singular(toKebabCase(rawName));
+    const pkg = toPackageName(singular);
+    const plural = pluralize_1.default.plural(singular);
+    return {
+        name: singular,
+        pkg,
+        pascalName: toPascalCase(singular),
+        plural,
+        tableName: toDbName(plural),
+        schemaName: `${pkg}_svc`,
+        errorPrefix: toDbName(singular).toUpperCase(),
+    };
+}
+function legacyPluralize(word) {
+    if (/[sxz]$/.test(word) || /[^aeiou](ch|sh)$/.test(word))
+        return word + "es";
+    if (/[^aeiou]y$/.test(word))
+        return word.slice(0, -1) + "ies";
+    if (word.endsWith("s"))
+        return word;
+    return word + "s";
+}
+function resolveLegacyModuleNaming(rawName) {
     const pkg = toPackageName(rawName);
+    const plural = legacyPluralize(pkg);
     return {
         name: pkg,
         pkg,
         pascalName: toPascalCase(pkg),
-        plural: pluralize(pkg),
+        plural,
+        tableName: toDbName(plural),
+        // Not meaningful for a legacy match: its table already exists in
+        // whatever schema the project's own migrations put it in (usually
+        // "public", from before this field existed), and nothing re-renders its
+        // model/migration templates to move it. Every consumer of this result is
+        // generate method/undo module, neither of which reads schemaName.
+        schemaName: `${pkg}_svc`,
         errorPrefix: pkg.toUpperCase(),
     };
 }
+// Projects generated before canonical inflection used the raw input as the Go
+// package name. Prefer the canonical package when present, but keep locating
+// legacy plural packages so upgrade does not make method/remove commands lose
+// sight of existing code. Two matches are unsafe: silently choosing one can
+// patch or delete the wrong module.
+function resolveExistingModuleNaming(rawName, existingPackages) {
+    const requestedLegacy = resolveLegacyModuleNaming(rawName);
+    const existing = new Set(existingPackages);
+    let canonical;
+    try {
+        canonical = resolveModuleNaming(rawName);
+    }
+    catch (error) {
+        if (existing.has(requestedLegacy.pkg))
+            return requestedLegacy;
+        throw error;
+    }
+    const aliases = existingPackages.filter((pkg) => {
+        if (pkg === canonical.pkg)
+            return false;
+        try {
+            return resolveModuleNaming(pkg).pkg === canonical.pkg;
+        }
+        catch {
+            return false;
+        }
+    });
+    const matches = [
+        ...(existing.has(canonical.pkg) ? [canonical.pkg] : []),
+        ...aliases,
+    ];
+    if (matches.length > 1) {
+        throw new Error(`ambiguous module "${rawName}": ${matches.map((pkg) => `internal/app/${pkg}`).join(" and ")} exist`);
+    }
+    if (matches[0] === canonical.pkg)
+        return canonical;
+    if (matches[0])
+        return resolveLegacyModuleNaming(matches[0]);
+    return canonical;
+}
+// Migration filenames read like the thing they create, so they use the
+// snake_case table name: create_order_items.up.sql for order_svc.order_items.
+// Older projects were written with the kebab-case route slug instead
+// (create_order-items.up.sql), so anything that *looks up* an existing pair
+// has to accept both — upgrading the CLI must not strand a module's
+// migrations where `undo` can no longer see them. Identical for the
+// single-word names that are the common case.
+function migrationSlug(naming) {
+    return naming.tableName;
+}
+function migrationSlugAliases(naming) {
+    return naming.tableName === naming.plural ? [naming.tableName] : [naming.tableName, naming.plural];
+}
 function resolveMethodNaming(rawName) {
     const cleaned = rawName.trim();
     const pascalName = toPascalCase(cleaned);
     if (!pascalName) {
         throw new Error(`invalid method name: "${rawName}" (must contain letters/numbers)`);
     }
-    // handlerName becomes a Go method name (`func (h *Handler) <name>`)
-    assertNotGoKeyword(toCamelCase(cleaned), "method");
+    // both become Go identifiers: handlerName as a method name
+    // (`func (h *Handler) <name>`), pascalName as a DTO type (`<Name>Input`)
+    assertGoIdentifier(toCamelCase(cleaned), "method");
+    assertGoIdentifier(pascalName, "method");
     return {
         name: cleaned,
         pascalName,

package/dist/utils/observability-patcher.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchMainGoForObservability = patchMainGoForObservability;
+exports.patchDatabaseGoForObservability = patchDatabaseGoForObservability;
+exports.patchConfigForObservability = patchConfigForObservability;
+exports.patchEnvExampleForObservability = patchEnvExampleForObservability;
+exports.patchOpenapiIndexForObservability = patchOpenapiIndexForObservability;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const marker_patch_1 = require("./marker-patch");
+const IMPORT_MARKER = "// go-scaffold:imports";
+const PLATFORM_INIT_MARKER = "// go-scaffold:platform-init";
+const EXTRA_ROUTES_MARKER = "// go-scaffold:extra-routes";
+const CONFIG_FIELDS_MARKER = "// go-scaffold:config-fields";
+const CONFIG_LOAD_MARKER = "// go-scaffold:config-load";
+const OPENAPI_PATHS_MARKER = "# go-scaffold:paths";
+// The exact line `create` renders — matched literally rather than through a
+// marker because it's a single call in the middle of other middleware, not a
+// standalone line a marker comment can sit next to.
+const USE_LINE = "r.Use(gin.Recovery(), middleware.CORS(cfg.CORSAllowedOrigins), middleware.RequestID(), middleware.Logger(logger), middleware.Error(!cfg.IsProd()))";
+// patchMainGoForObservability wires telemetry init, the tracing/metrics
+// middleware, and the /metrics route into cmd/api/wiring.go — the same
+// text-marker approach every other `add` command uses, since main.go is a
+// real file a human may have already edited by the time this runs, not a
+// template rendered fresh.
+function patchMainGoForObservability(mainGoPath, goModule, projectName) {
+    let content = fs_extra_1.default.readFileSync(mainGoPath, "utf8");
+    const telemetryImport = `"${goModule}/internal/platform/telemetry"`;
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, telemetryImport, telemetryImport);
+    const promhttpImport = `"github.com/prometheus/client_golang/prometheus/promhttp"`;
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, promhttpImport, promhttpImport);
+    // telemetry.go's GORM plugin looks up otel.Tracer() fresh on every query
+    // rather than once at registration, so it doesn't matter that this runs
+    // after database.Open has already called db.Use(NewGormPlugin()) — no
+    // query happens between here and the server actually accepting traffic.
+    const initBlock = [
+        `shutdownTelemetry, err := telemetry.Init(context.Background(), "${projectName}", cfg.OTELExporterEndpoint)`,
+        "if err != nil {",
+        '\treturn fmt.Errorf("init telemetry: %w", err)',
+        "}",
+        "defer func() { _ = shutdownTelemetry(context.Background()) }()",
+    ].join("\n");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, PLATFORM_INIT_MARKER, initBlock, "shutdownTelemetry, err := telemetry.Init(");
+    if (!content.includes(USE_LINE)) {
+        throw new Error("cmd/api/wiring.go's r.Use(...) call doesn't match the text this command expects — " +
+            "it looks like it's been hand-edited. Add middleware.Metrics() and middleware.Tracing(\"<project>\") to it yourself.");
+    }
+    const newUseLine = `${USE_LINE.slice(0, -1)}, middleware.Metrics(), middleware.Tracing("${projectName}"))`;
+    content = content.replace(USE_LINE, () => newUseLine);
+    // Not gated on APP_ENV the way /docs is: production is exactly where you
+    // want a scrape target, and Prometheus reaches it in-cluster. It is still
+    // unauthenticated and does disclose your route list and traffic shape, so
+    // block /metrics at the ingress rather than publishing it to the internet.
+    const metricsRoute = 'r.GET("/metrics", gin.WrapH(promhttp.Handler()))';
+    const metricsBlock = [
+        "// Unauthenticated on purpose (Prometheus scrapes it in-cluster) — block",
+        "// /metrics at your ingress so it isn't reachable from the internet.",
+        metricsRoute,
+    ].join("\n");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, EXTRA_ROUTES_MARKER, metricsBlock, metricsRoute);
+    fs_extra_1.default.writeFileSync(mainGoPath, content);
+}
+// patchDatabaseGoForObservability wires the GORM OpenTelemetry plugin into
+// database.Open, so every query gets a span alongside the HTTP request it
+// came from.
+function patchDatabaseGoForObservability(databaseGoPath, goModule) {
+    let content = fs_extra_1.default.readFileSync(databaseGoPath, "utf8");
+    const telemetryImport = `"${goModule}/internal/platform/telemetry"`;
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, telemetryImport, telemetryImport);
+    const pluginBlock = ["if err := db.Use(telemetry.NewGormPlugin()); err != nil {", "\treturn nil, err", "}"].join("\n");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, PLATFORM_INIT_MARKER, pluginBlock, "if err := db.Use(telemetry.NewGormPlugin())");
+    fs_extra_1.default.writeFileSync(databaseGoPath, content);
+}
+// patchConfigForObservability adds OTELExporterEndpoint to Config and its
+// env() load — the same marker-based approach patchConfigForWorker uses.
+function patchConfigForObservability(configGoPath) {
+    let content = fs_extra_1.default.readFileSync(configGoPath, "utf8");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_FIELDS_MARKER, "OTELExporterEndpoint string", "OTELExporterEndpoint");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_LOAD_MARKER, 'OTELExporterEndpoint: env("OTEL_EXPORTER_OTLP_ENDPOINT", ""),', 'env("OTEL_EXPORTER_OTLP_ENDPOINT"');
+    fs_extra_1.default.writeFileSync(configGoPath, content);
+}
+// patchEnvExampleForObservability appends OTEL_EXPORTER_OTLP_ENDPOINT —
+// .env.example has no marker infrastructure of its own, so this follows the
+// same append-once pattern as add worker/add auth's env patchers.
+function patchEnvExampleForObservability(envExamplePath) {
+    if (!fs_extra_1.default.existsSync(envExamplePath))
+        return;
+    const content = fs_extra_1.default.readFileSync(envExamplePath, "utf8");
+    if (content.includes("OTEL_EXPORTER_OTLP_ENDPOINT"))
+        return;
+    fs_extra_1.default.writeFileSync(envExamplePath, content.replace(/\n?$/, "\n") +
+        "\n# OTLP/HTTP endpoint for trace export (e.g. localhost:4318) — empty disables\n" +
+        "# tracing entirely: no exporter is created, no network calls are made\n" +
+        "OTEL_EXPORTER_OTLP_ENDPOINT=\n");
+}
+// patchOpenapiIndexForObservability wires /metrics into docs/openapi.yaml.
+// Not routed through patchOpenapiIndexRaw (used for auth/rbac's paths):
+// /metrics is registered directly on the router like /livez and /readyz, not
+// under the api prefix group, so it must never be prefixed.
+function patchOpenapiIndexForObservability(openapiPath) {
+    let content = fs_extra_1.default.readFileSync(openapiPath, "utf8");
+    const block = "/metrics:\n  $ref: './observability/metrics.yaml'";
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, OPENAPI_PATHS_MARKER, block, "/metrics:");
+    fs_extra_1.default.writeFileSync(openapiPath, content);
+}

package/dist/utils/openapi-patcher.js

@@ -44,7 +44,25 @@ function patchOpenapiIndex(openapiPath, naming, apiPrefix) {
 function unpatchOpenapiIndex(openapiPath, naming, apiPrefix) {
     const content = fs_extra_1.default.readFileSync(openapiPath, "utf8");
     const { paths, schemas } = openapiLines(naming, apiPrefix);
-    fs_extra_1.default.writeFileSync(openapiPath, (0, marker_patch_1.removeLines)(content, [...paths, ...schemas]));
+    const withoutKnownEntries = (0, marker_patch_1.removeLines)(content, [...paths, ...schemas]);
+    // `generate method` can add any number of module-specific path documents.
+    // Remove every two-line path/$ref block owned by this module, otherwise the
+    // index keeps dangling references after the docs folder is deleted.
+    const lines = withoutKnownEntries.split("\n");
+    const moduleRefPrefix = `./${naming.plural}/`;
+    const kept = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const current = lines[i];
+        const next = lines[i + 1];
+        const isPathKey = /^\s*\/[^:]+:\s*$/.test(current);
+        const refMatch = next?.match(/^\s*\$ref:\s*['"]([^'"]+)['"]\s*$/);
+        if (isPathKey && refMatch?.[1].startsWith(moduleRefPrefix)) {
+            i += 1;
+            continue;
+        }
+        kept.push(current);
+    }
+    fs_extra_1.default.writeFileSync(openapiPath, kept.join("\n"));
 }
 // patchOpenapiIndexRaw wires hand-written path docs into the index — used by
 // `add auth`/`add rbac`, whose endpoints aren't a single CRUD resource so

package/dist/utils/platform-patcher.js

@@ -3,7 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchComposeForRedis = patchComposeForRedis;
+exports.patchCiForRedis = patchCiForRedis;
+exports.patchConfigForRedis = patchConfigForRedis;
 exports.patchConfigForWorker = patchConfigForWorker;
+exports.patchConfigForSMTP = patchConfigForSMTP;
 exports.patchMainGoForWorker = patchMainGoForWorker;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const marker_patch_1 = require("./marker-patch");
@@ -13,25 +17,107 @@ const CONFIG_LOAD_MARKER = "// go-scaffold:config-load";
 const PLATFORM_INIT_MARKER = "// go-scaffold:platform-init";
 const READYZ_MARKER = "// go-scaffold:readyz-checks";
 const SHUTDOWN_MARKER = "// go-scaffold:shutdown";
-// patchConfigForWorker adds RedisURL + SMTP_* fields to Config and their
-// env() loads to Load() — via marker comments, the same text-insertion
-// approach as patchMainGo, since config.go.hbs is only rendered once (at
-// `create`) and everything after that is a real file a human may have
-// already edited.
-function patchConfigForWorker(configGoPath) {
+// patchComposeForRedis adds a redis service to docker-compose.yml. Whatever
+// pulls Redis in — `add worker --queue redis`, or `add auth`'s refresh-token
+// store on top of a Postgres queue — makes cmd/api call cache.Open and adds a
+// Redis ping to /readyz. Leaving compose Postgres-only meant the documented
+// path (`make docker-up` then `make run`) produced a permanent 503, which is
+// a rough first five minutes with a brand new project.
+//
+// No-op when the project was scaffolded with --no-docker.
+function patchComposeForRedis(composePath) {
+    if (!fs_extra_1.default.existsSync(composePath))
+        return;
+    const content = fs_extra_1.default.readFileSync(composePath, "utf8");
+    if (/^\s{2}redis:/m.test(content))
+        return;
+    const service = [
+        "  redis:",
+        "    image: redis:7-alpine",
+        "    ports:",
+        '      - "6379:6379"',
+    ].join("\n");
+    // before the top-level `volumes:` key, so redis stays inside `services:`
+    const out = content.includes("\nvolumes:")
+        ? content.replace("\nvolumes:", () => `\n${service}\n\nvolumes:`)
+        : content.replace(/\n?$/, "\n") + `\n${service}\n`;
+    fs_extra_1.default.writeFileSync(composePath, out);
+}
+// patchCiForRedis adds a redis service to .github/workflows/ci.yml, for the
+// same reason patchComposeForRedis exists: once cmd/api calls cache.Open, a
+// test that touches the token store has nothing to connect to on a runner
+// whose only service is Postgres. The generated workflow was written at
+// `create` time, before anything needed Redis, and nothing patched it after.
+//
+// No-op when the workflow was deleted or replaced by hand.
+function patchCiForRedis(ciPath) {
+    if (!fs_extra_1.default.existsSync(ciPath))
+        return;
+    const content = fs_extra_1.default.readFileSync(ciPath, "utf8");
+    if (/^\s{6}redis:/m.test(content))
+        return;
+    // `steps:` sits one level under the job, so it's the first line that ends
+    // the `services:` block — insert the service just above it.
+    const stepsLine = content.split("\n").find((l) => l.trimEnd() === "    steps:");
+    if (!stepsLine)
+        return;
+    const service = [
+        "      redis:",
+        "        image: redis:7-alpine",
+        "        ports:",
+        "          - 6379:6379",
+        "        options: >-",
+        '          --health-cmd "redis-cli ping"',
+        "          --health-interval 10s",
+        "          --health-timeout 5s",
+        "          --health-retries 5",
+        "",
+    ].join("\n");
+    fs_extra_1.default.writeFileSync(ciPath, content.replace(stepsLine, () => `${service}\n${stepsLine}`));
+}
+// patchConfigForRedis adds RedisURL to Config and its env() load to Load().
+// Split out from the worker patch because Redis is no longer the worker's
+// concern by default — `add auth` needs it for the refresh-token store even
+// when the queue lives in Postgres.
+function patchConfigForRedis(configGoPath) {
     let content = fs_extra_1.default.readFileSync(configGoPath, "utf8");
-    const fieldsBlock = ["RedisURL string", "", "SMTPHost string", "SMTPPort string", "SMTPUsername string", "SMTPPassword string", "SMTPFrom string"].join("\n");
-    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_FIELDS_MARKER, fieldsBlock, "RedisURL string");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_FIELDS_MARKER, "RedisURL string", "RedisURL");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_LOAD_MARKER, 'RedisURL: env("REDIS_URL", "redis://localhost:6379/0"),', 'env("REDIS_URL"');
+    fs_extra_1.default.writeFileSync(configGoPath, content);
+}
+// patchConfigForWorker adds the SMTP_* fields (and RedisURL, when Redis is
+// the queue's backing store) to Config and their env() loads to Load() — via
+// marker comments, the same text-insertion approach as patchMainGo, since
+// config.go.hbs is only rendered once (at `create`) and everything after
+// that is a real file a human may have already edited.
+function patchConfigForWorker(configGoPath, opts) {
+    if (opts.redis)
+        patchConfigForRedis(configGoPath);
+    patchConfigForSMTP(configGoPath);
+}
+// Sentinels here match a bare identifier, never `Name string` or
+// `Name: env(...)`: gofmt aligns struct fields and map values into columns, so
+// the moment one of these blocks lands the literal spacing a sentinel was
+// written with no longer exists in the file. A sentinel that misses means the
+// block gets inserted a second time and the project stops compiling on a
+// redeclared field — which is exactly what `add auth` then `add worker` did.
+//
+// patchConfigForSMTP is split out because `add auth` needs these fields even
+// when there is no worker: without a queue it sends mail synchronously, and it
+// still has to know where to send it. Idempotent, so whichever command gets
+// here first wins and the second is a no-op.
+function patchConfigForSMTP(configGoPath) {
+    let content = fs_extra_1.default.readFileSync(configGoPath, "utf8");
+    const fieldsBlock = ["SMTPHost string", "SMTPPort string", "SMTPUsername string", "SMTPPassword string", "SMTPFrom string"].join("\n");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_FIELDS_MARKER, fieldsBlock, "SMTPHost");
     const loadBlock = [
-        'RedisURL: env("REDIS_URL", "redis://localhost:6379/0"),',
-        "",
         'SMTPHost:     env("SMTP_HOST", ""),',
         'SMTPPort:     env("SMTP_PORT", "587"),',
         'SMTPUsername: env("SMTP_USERNAME", ""),',
         'SMTPPassword: env("SMTP_PASSWORD", ""),',
         'SMTPFrom:     env("SMTP_FROM", "no-reply@example.local"),',
     ].join("\n");
-    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_LOAD_MARKER, loadBlock, 'RedisURL: env("REDIS_URL"');
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, CONFIG_LOAD_MARKER, loadBlock, 'env("SMTP_HOST"');
     fs_extra_1.default.writeFileSync(configGoPath, content);
 }
 // patchMainGoForWorker wires Redis into cmd/api: opened alongside the DB, and
@@ -44,7 +130,7 @@ function patchMainGoForWorker(mainGoPath, goModule) {
     let content = fs_extra_1.default.readFileSync(mainGoPath, "utf8");
     const cacheImport = `"${goModule}/internal/platform/cache"`;
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, cacheImport, cacheImport);
-    const initBlock = ["rdb, err := cache.Open(cfg)", "if err != nil {", '\tlogger.Error("open redis", "error", err)', "\tos.Exit(1)", "}"].join("\n");
+    const initBlock = ["rdb, err := cache.Open(cfg)", "if err != nil {", '\treturn fmt.Errorf("open redis: %w", err)', "}"].join("\n");
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, PLATFORM_INIT_MARKER, initBlock, "rdb, err := cache.Open(cfg)");
     const readyzBlock = [
         "if err := rdb.Ping(c.Request.Context()).Err(); err != nil {",

package/dist/utils/rbac-patcher.js

@@ -13,12 +13,17 @@ exports.patchUserServiceTestForRbac = patchUserServiceTestForRbac;
 exports.patchUserDTOForRbac = patchUserDTOForRbac;
 exports.patchUserHandlerForRbac = patchUserHandlerForRbac;
 exports.patchUserErrorsForRbac = patchUserErrorsForRbac;
+exports.userSvcLineFor = userSvcLineFor;
+exports.assertRbacPatchable = assertRbacPatchable;
 exports.patchMainGoForRbac = patchMainGoForRbac;
 exports.patchCmdSeedForRbac = patchCmdSeedForRbac;
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const auth_patcher_1 = require("./auth-patcher");
 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";
 const CONFIG_FIELDS_MARKER = "// go-scaffold:config-fields";
 const CONFIG_LOAD_MARKER = "// go-scaffold:config-load";
 // patchAuthDocsForRbac adds `role` to the hand-written MeResponse schema in
@@ -233,26 +238,71 @@ function patchUserErrorsForRbac(errorsGoPath) {
 // isn't enough — REPLACES the `add auth` PR's user.NewHandler(...) call with
 // a version that also builds roleSvc/authz and passes them through, plus
 // registers role's own routes right after it.
-function patchMainGoForRbac(mainGoPath, goModule) {
+// userSvcLineFor rebuilds the exact line `add auth` wrote, from the same
+// helper it used. Exported so the command can check for it *before* it starts
+// patching: every other file rbac touches is edited first, and until this
+// existed a mismatch here threw after user.NewService had already grown a
+// roleChecker parameter — leaving a project that no longer compiled and an
+// error telling you to restore a line that wouldn't have fixed it.
+function userSvcLineFor(goModule, store, worker) {
+    const { tokenStore, mailer } = (0, auth_patcher_1.authWiringLines)({ goModule, queueBackend: "river", store, worker });
+    return `userSvc := user.NewService(user.NewRepository(db), ${tokenStore}, ${mailer}, cfg)`;
+}
+function assertRbacPatchable(mainGoPath, goModule, store, worker) {
+    const expected = userSvcLineFor(goModule, store, worker);
+    if (fs_extra_1.default.readFileSync(mainGoPath, "utf8").includes(expected))
+        return;
+    throw new Error("cmd/api/wiring.go's userSvc line doesn't match what `add auth` wrote, so `add rbac` can't extend it.\n" +
+        `Expected to find:\n  ${expected}\n\n` +
+        "It was probably hand-edited. Restore that line and re-run — nothing has been changed yet.");
+}
+function patchMainGoForRbac(mainGoPath, goModule, store, worker) {
     let content = fs_extra_1.default.readFileSync(mainGoPath, "utf8");
     const importLine = `"${goModule}/internal/app/role"`;
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, importLine, importLine);
     const modelImportLine = `rolemodel "${goModule}/internal/app/role/model"`;
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, modelImportLine, modelImportLine);
+    const schemaBlock = [
+        'if err := db.Exec("CREATE SCHEMA IF NOT EXISTS role_svc").Error; err != nil {',
+        '\treturn fmt.Errorf("create schema role_svc: %w", err)',
+        "}",
+    ].join("\n");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, SCHEMA_MARKER, schemaBlock, "CREATE SCHEMA IF NOT EXISTS role_svc");
     const migrateLines = ["&rolemodel.Role{},", "&rolemodel.Permission{},", "&rolemodel.RolePermission{},"];
     for (const line of migrateLines) {
         content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, MODEL_MARKER, line, line);
     }
-    const oldRouteLine = "user.NewHandler(user.NewService(user.NewRepository(db), user.NewRedisTokenStore(rdb), mail.NewAsyncClient(q), cfg), cfg.JWTSecret, cfg.JWTRefreshTTL, cfg.CookieSecure, rdb).Register(api)";
-    if (content.includes(oldRouteLine)) {
-        const newRouteBlock = [
-            "roleSvc := role.NewService(role.NewRepository(db))",
-            "authz := middleware.NewAuthz(roleSvc.PermissionsOf, cfg.AuthzCacheTTL)",
-            "user.NewHandler(user.NewService(user.NewRepository(db), user.NewRedisTokenStore(rdb), mail.NewAsyncClient(q), cfg, roleSvc), cfg.JWTSecret, cfg.JWTRefreshTTL, cfg.CookieSecure, rdb, authz).Register(api)",
-            "role.NewHandler(roleSvc, cfg.JWTSecret, authz).Register(api)",
-        ].join("\n");
-        content = content.replace(oldRouteLine, newRouteBlock);
+    // roleSvc and authz have to be declared *above* userSvc, which now takes
+    // roleSvc — so this rewrites the service line in place rather than
+    // appending at the marker (which would land below it).
+    // Rebuilt from the same helper `add auth` used, so a project on either store
+    // gets its own line matched rather than a hardcoded guess at one of them.
+    const { limiter } = (0, auth_patcher_1.authWiringLines)({ goModule, queueBackend: "river", store, worker });
+    const userSvcLine = userSvcLineFor(goModule, store, worker);
+    // Throw rather than skip: the roleSvc/authz declarations this rewrite adds
+    // are what the unconditional patches below refer to. Skipping quietly still
+    // emits `roleSvc`/`authz` references with nothing declaring them, so the
+    // command reports success over a main.go that doesn't compile.
+    if (!content.includes(userSvcLine)) {
+        throw new Error(`cmd/api/wiring.go's userSvc line doesn't match what \`add auth\` wrote, so \`add rbac\` can't extend it.\n` +
+            `Expected to find:\n  ${userSvcLine}\n\n` +
+            `It was probably hand-edited. Restore that line (add rbac will re-extend it), or apply the rbac wiring by hand:\n` +
+            `  roleSvc := role.NewService(role.NewRepository(db))\n` +
+            `  authz := middleware.NewAuthz(roleSvc.PermissionsOf, cfg.AuthzCacheTTL)\n` +
+            `  ...then pass roleSvc as user.NewService's last argument.`);
     }
+    content = content.replace(userSvcLine, [
+        "roleSvc := role.NewService(role.NewRepository(db))",
+        "authz := middleware.NewAuthz(roleSvc.PermissionsOf, cfg.AuthzCacheTTL)",
+        `${userSvcLine.slice(0, -1)}, roleSvc)`,
+    ].join("\n"));
+    const userRouteLine = `user.NewHandler(userSvc, cfg.JWTSecret, cfg.JWTRefreshTTL, cfg.CookieSecure, cfg.CookieSameSite, ${limiter}).Register(api)`;
+    // strip the trailing `).Register(api)` — not just `.Register(api)` — so authz
+    // lands inside NewHandler's argument list rather than after its closing paren
+    const tail = ").Register(api)";
+    content = content.replace(userRouteLine, `${userRouteLine.slice(0, -tail.length)}, authz${tail}`);
+    const roleRouteLine = "role.NewHandler(roleSvc, cfg.JWTSecret, authz).Register(api)";
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, ROUTE_MARKER, roleRouteLine, roleRouteLine);
     fs_extra_1.default.writeFileSync(mainGoPath, content);
 }
 // patchCmdSeedForRbac makes the seeded admin actually an admin: wires a

package/dist/utils/smoke-run.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSmokeRunConfig = createSmokeRunConfig;
+const POSTGRES_HOST = "127.0.0.1";
+function assertPort(port, label) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`invalid smoke-test ${label}: ${port}`);
+    }
+}
+function createSmokeRunConfig(runID, port, dbPort = 5432) {
+    assertPort(port, "port");
+    assertPort(dbPort, "PostgreSQL port");
+    const normalizedRunID = runID.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (!normalizedRunID) {
+        throw new Error("smoke-test run ID must contain at least one letter or digit");
+    }
+    const dbName = `go_scaffold_smoke_${normalizedRunID}`;
+    return {
+        runID: normalizedRunID,
+        dbName,
+        dbHost: POSTGRES_HOST,
+        dbPort,
+        dbDsn: `postgres://postgres:postgres@${POSTGRES_HOST}:${dbPort}/${dbName}?sslmode=disable`,
+        port,
+        baseURL: `http://127.0.0.1:${port}`,
+        logPrefix: `go-scaffold-smoke-${normalizedRunID}`,
+        ownerToken: `go-scaffold-smoke-${normalizedRunID}`,
+        dockerLabel: `go-scaffold.smoke.owner=go-scaffold-smoke-${normalizedRunID}`,
+        containerNamePrefix: `go-scaffold-smoke-${normalizedRunID}`,
+    };
+}