@nakedev/go-scaffold 0.3.3 → 0.4.3

package/dist/utils/config.js

@@ -3,18 +3,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_SCHEMA_VERSION = void 0;
 exports.configPath = configPath;
+exports.parseModuleSurface = parseModuleSurface;
+exports.parseApplicationStyle = parseApplicationStyle;
+exports.parseModuleProfile = parseModuleProfile;
 exports.writeConfig = writeConfig;
 exports.readConfig = readConfig;
 exports.isProjectDir = isProjectDir;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const types_1 = require("../types");
 const CONFIG_FILE = "go-scaffold.config.json";
+exports.CONFIG_SCHEMA_VERSION = 1;
 function configPath(projectDir) {
     return path_1.default.join(projectDir, CONFIG_FILE);
 }
+function parseModuleSurface(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    assertOneOf(normalized, "--module-surface", ["minimal", "crud"]);
+    return normalized;
+}
+function parseApplicationStyle(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    assertOneOf(normalized, "--application-style", ["service", "cqrs"]);
+    return normalized;
+}
+function parseModuleProfile(value, flag = "--profile") {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    assertOneOf(normalized, flag, ["lean", "crud", "cqrs"]);
+    return normalized;
+}
 function writeConfig(projectDir, config) {
-    fs_extra_1.default.writeJsonSync(configPath(projectDir), config, { spaces: 2 });
+    fs_extra_1.default.writeJsonSync(configPath(projectDir), normalizeProjectConfig(config, projectDir), { spaces: 2 });
 }
 // readConfig falls back to detecting from go.mod when the config file is
 // missing (e.g. a project scaffolded before this file existed).
@@ -35,13 +62,127 @@ function readConfig(projectDir) {
     if (!fs_extra_1.default.existsSync(file))
         return detectConfig(projectDir);
     const config = fs_extra_1.default.readJsonSync(file);
+    if (!isRecord(config)) {
+        throw new Error(`${CONFIG_FILE} must contain a JSON object`);
+    }
+    const detected = detectFeatures(projectDir);
+    const features = { ...(isRecord(config.features) ? config.features : {}) };
+    for (const key of Object.keys(detected)) {
+        if (features[key] === undefined)
+            features[key] = detected[key];
+    }
+    return normalizeProjectConfig({ ...config, features: features }, projectDir);
+}
+/**
+ * Validate and fill defaults for the project manifest. Older projects have
+ * no architecture/modules keys yet; normalising them here lets every command
+ * consume one stable shape while keeping the old config file compatible.
+ */
+function normalizeProjectConfig(raw, projectDir) {
+    const projectName = requiredString(raw.projectName, "projectName");
+    const goModule = requiredString(raw.goModule, "goModule");
+    const apiPrefix = requiredString(raw.apiPrefix ?? "", "apiPrefix");
+    const schemaVersion = raw.schemaVersion ?? exports.CONFIG_SCHEMA_VERSION;
+    if (!Number.isInteger(schemaVersion) || schemaVersion < 1) {
+        throw new Error(`${CONFIG_FILE} has invalid schemaVersion "${String(schemaVersion)}" — expected a positive integer`);
+    }
+    if (schemaVersion > exports.CONFIG_SCHEMA_VERSION) {
+        throw new Error(`${CONFIG_FILE} uses schemaVersion ${schemaVersion}, but this CLI supports up to ${exports.CONFIG_SCHEMA_VERSION} — upgrade go-scaffold first`);
+    }
     const detected = detectFeatures(projectDir);
-    const features = { ...config.features };
+    const features = { ...(isRecord(raw.features) ? raw.features : {}) };
     for (const key of Object.keys(detected)) {
         if (features[key] === undefined)
             features[key] = detected[key];
     }
-    return { ...config, features };
+    validateFeatures(features);
+    const architecture = normalizeArchitecture(raw.architecture);
+    const modules = normalizeModules(raw.modules);
+    return {
+        schemaVersion,
+        projectName,
+        goModule,
+        apiPrefix,
+        features: features,
+        architecture,
+        modules,
+        ...(raw.scaffoldVersion ? { scaffoldVersion: raw.scaffoldVersion } : {}),
+    };
+}
+function normalizeArchitecture(raw) {
+    const value = raw === undefined ? {} : raw;
+    if (!isRecord(value)) {
+        throw new Error(`${CONFIG_FILE}.architecture must be a JSON object`);
+    }
+    const architecture = {
+        ...types_1.DEFAULT_ARCHITECTURE_CONFIG,
+        ...value,
+    };
+    assertOneOf(architecture.style, "architecture.style", ["modular-monolith"]);
+    assertOneOf(architecture.defaultModuleSurface, "architecture.defaultModuleSurface", ["minimal", "crud"]);
+    assertOneOf(architecture.defaultApplicationStyle, "architecture.defaultApplicationStyle", ["service", "cqrs"]);
+    return {
+        style: architecture.style,
+        defaultModuleSurface: architecture.defaultModuleSurface,
+        defaultApplicationStyle: architecture.defaultApplicationStyle,
+    };
+}
+function normalizeModules(raw) {
+    if (raw === undefined)
+        return {};
+    if (!isRecord(raw))
+        throw new Error(`${CONFIG_FILE}.modules must be a JSON object`);
+    const modules = {};
+    for (const [name, entry] of Object.entries(raw)) {
+        if (!name || name.includes("/") || name.includes("\\")) {
+            throw new Error(`${CONFIG_FILE}.modules has invalid module key "${name}" — use the module's Go package name`);
+        }
+        if (!isRecord(entry))
+            throw new Error(`${CONFIG_FILE}.modules.${name} must be a JSON object`);
+        assertOneOf(entry.surface, `modules.${name}.surface`, ["minimal", "crud"]);
+        assertOneOf(entry.applicationStyle, `modules.${name}.applicationStyle`, ["service", "cqrs"]);
+        modules[name] = {
+            surface: entry.surface,
+            applicationStyle: entry.applicationStyle,
+        };
+    }
+    return modules;
+}
+function validateFeatures(features) {
+    if (typeof features.docker !== "boolean")
+        throw new Error(`${CONFIG_FILE}.features.docker must be true or false`);
+    if (typeof features.openapiDocs !== "boolean")
+        throw new Error(`${CONFIG_FILE}.features.openapiDocs must be true or false`);
+    if (features.worker !== undefined && typeof features.worker !== "boolean") {
+        throw new Error(`${CONFIG_FILE}.features.worker must be true or false`);
+    }
+    if (features.queue !== undefined)
+        assertOneOf(features.queue, "features.queue", ["river", "asynq"]);
+    if (features.auth !== undefined && typeof features.auth !== "boolean") {
+        throw new Error(`${CONFIG_FILE}.features.auth must be true or false`);
+    }
+    if (features.authStore !== undefined)
+        assertOneOf(features.authStore, "features.authStore", ["postgres", "redis"]);
+    if (features.rbac !== undefined && typeof features.rbac !== "boolean") {
+        throw new Error(`${CONFIG_FILE}.features.rbac must be true or false`);
+    }
+    if (features.observability !== undefined && typeof features.observability !== "boolean") {
+        throw new Error(`${CONFIG_FILE}.features.observability must be true or false`);
+    }
+}
+function requiredString(value, field) {
+    if (typeof value !== "string")
+        throw new Error(`${CONFIG_FILE}.${field} must be a string`);
+    return value;
+}
+function assertOneOf(value, field, allowed) {
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        const label = field.startsWith("--") ? field : `${CONFIG_FILE}.${field}`;
+        throw new Error(`${label} must be one of: ${allowed.join(", ")} (got "${String(value)}")`);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // detectFeatures answers "what is actually installed here" from the tree
 // alone. Every `add` command leaves a directory or a file behind that nothing
@@ -107,10 +248,13 @@ function detectConfig(projectDir) {
     // already exists"), with no way out. Worse, the first `add` to succeed then
     // wrote a config that recorded the undetected features as absent.
     return {
+        schemaVersion: exports.CONFIG_SCHEMA_VERSION,
         projectName: path_1.default.basename(projectDir),
         goModule,
         apiPrefix,
         features: detectFeatures(projectDir),
+        architecture: { ...types_1.DEFAULT_ARCHITECTURE_CONFIG },
+        modules: {},
     };
 }
 // isProjectDir answers "would readConfig succeed here?" without throwing, so

package/dist/utils/main-patcher.js

@@ -18,26 +18,28 @@ const UNUSED_API_LINE = "_ = api // dropped once `generate module` registers the
 // 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.
+// Generated features own their repository/service/handler composition. The
+// API binary supplies infrastructure and security dependencies, then only
+// registers the feature's handler.
 function mainGoLines(patch) {
     const modelAlias = `${patch.pkg}model`; // every domain's model subpackage is named "model"
-    const svcVar = `${patch.pkg}Svc`;
-    const handlerArgs = [svcVar];
+    const handlerArgs = ["db"];
+    const legacyHandlerArgs = [`${patch.pkg}Svc`];
     if (patch.auth)
         handlerArgs.push("cfg.JWTSecret");
+    // RBAC's Authz is owned by role/composition.go. wiring.go registers a
+    // permission-gated feature with that public capability; it no longer keeps a
+    // standalone root variable named `authz`.
     if (patch.permission)
-        handlerArgs.push("authz");
+        handlerArgs.push("roleComposition.Authz");
+    if (patch.auth)
+        legacyHandlerArgs.push("cfg.JWTSecret");
+    if (patch.permission)
+        legacyHandlerArgs.push("roleComposition.Authz");
     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
+        // Development schema bootstrap 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).
@@ -48,15 +50,17 @@ function mainGoLines(patch) {
         ].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} :=`,
+        // kept only so undo can clean projects generated before feature-local
+        // composition was introduced.
+        legacyServicePrefix: `${patch.pkg}Svc :=`,
+        legacyRouteLine: `${patch.pkg}.NewHandler(${legacyHandlerArgs.join(", ")}).Register(api)`,
         // `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.
-        // `authz` only exists in main.go once `add rbac` has run — patch.permission
-        // is only ever set once that's already been verified by the caller.
-        routeLine: `${patch.pkg}.NewHandler(${handlerArgs.join(", ")}).Register(api)`,
+        // `roleComposition.Authz` only exists in main.go once `add rbac` has run —
+        // patch.permission is only ever set once that has been verified by the
+        // caller.
+        routeLine: `${patch.pkg}.NewHandlerFromDB(${handlerArgs.join(", ")}).Register(api)`,
     };
 }
 // assertMainGoPatchable is the pre-flight for it: every marker patchMainGo
@@ -79,13 +83,13 @@ function assertMainGoPatchable(mainGoPath) {
     }
 }
 // patchMainGo wires a newly generated module into cmd/api/wiring.go: its
-// import, its model in the AutoMigrate call, and its route registration —
+// import, its model in the development bootstrap, 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, schemaLines, schemaSentinel, migrateLine, serviceLine, servicePrefix, routeLine } = mainGoLines(patch);
+    const { importLine, modelImportLine, schemaLines, schemaSentinel, migrateLine, 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.
@@ -93,9 +97,6 @@ function patchMainGo(mainGoPath, patch) {
     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);
@@ -105,10 +106,11 @@ 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, 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]);
+    const { importLine, modelImportLine, schemaLines, migrateLine, legacyServicePrefix, legacyRouteLine, routeLine } = mainGoLines(patch);
+    content = (0, marker_patch_1.removeLines)(content, [importLine, modelImportLine, migrateLine, routeLine, legacyRouteLine]);
+    // by prefix: remove the named service line from projects generated before
+    // composition became feature-local.
+    content = (0, marker_patch_1.removeLinesByPrefix)(content, [legacyServicePrefix]);
     // 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.

package/dist/utils/marker-patch.js

@@ -31,7 +31,13 @@ function ensureImport(content, importPath) {
     // 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`);
+    if (content.includes("import (\n")) {
+        return content.replace(/import \(\n/, () => `import (\n\t${importLine}\n`);
+    }
+    // A minimal CQRS service has no imports until the first method is added.
+    // Create a complete block after the package clause so later generated
+    // methods can use the same idempotent path.
+    return content.replace(/^(package [^\n]+\n)/, (_match, packageLine) => `${packageLine}\nimport (\n\t${importLine}\n)\n`);
 }
 // insertBeforeMarkerOnce: like insertBeforeMarker but a no-op if `sentinel`
 // already appears in the file. Makes module wiring idempotent — re-running