@nakedev/go-scaffold 0.4.0 → 0.5.0

package/dist/utils/hexagonal-method-patcher.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexagonalMarkersPresent = hexagonalMarkersPresent;
+exports.assertHexagonalMethodAbsent = assertHexagonalMethodAbsent;
+exports.patchHexagonalMethod = patchHexagonalMethod;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const marker_patch_1 = require("./marker-patch");
+const naming_1 = require("./naming");
+const DTO_MARKER = "// go-scaffold:dto";
+const REPOSITORY_INTERFACE_MARKER = "// go-scaffold:repository-interface";
+const QUERY_REPOSITORY_INTERFACE_MARKER = "// go-scaffold:query-repository-interface";
+const REPOSITORY_METHODS_MARKER = "// go-scaffold:repository-methods";
+const SERVICE_MARKER = "// go-scaffold:service-methods";
+const SERVICE_INTERFACE_MARKER = "// go-scaffold:service-interface";
+const COMMAND_MARKER = "// go-scaffold:command-methods";
+const COMMAND_INTERFACE_MARKER = "// go-scaffold:command-interface";
+const QUERY_MARKER = "// go-scaffold:query-methods";
+const QUERY_INTERFACE_MARKER = "// go-scaffold:query-interface";
+const HANDLER_ROUTES_MARKER = "// go-scaffold:handler-routes";
+const HANDLER_FUNCS_MARKER = "// go-scaffold:handler-funcs";
+const REPOSITORY_STUB_FIELDS_MARKER = "// go-scaffold:repository-stub-fields";
+const REPOSITORY_STUB_METHODS_MARKER = "// go-scaffold:repository-stub-methods";
+function isCqrs(paths) {
+    return Boolean(paths.commandPath && paths.queryPath);
+}
+function read(files, file) {
+    const value = files.get(file);
+    if (value !== undefined)
+        return value;
+    const content = fs_extra_1.default.readFileSync(file, "utf8");
+    files.set(file, content);
+    return content;
+}
+function write(files, file, content) {
+    files.set(file, content);
+}
+function addImport(content, importPath) {
+    return (0, marker_patch_1.ensureImport)(content, importPath);
+}
+function requestDTOMarker(content) {
+    if ((0, marker_patch_1.hasMarker)(content, DTO_MARKER))
+        return DTO_MARKER;
+    if ((0, marker_patch_1.hasMarker)(content, "// go-scaffold:user-dto"))
+        return "// go-scaffold:user-dto";
+    throw new Error("inbound HTTP DTO file is missing a go-scaffold DTO marker");
+}
+function insert(content, marker, block) {
+    return (0, marker_patch_1.insertBeforeMarker)(content, marker, block);
+}
+function serviceApplicationTarget(paths, type) {
+    if (isCqrs(paths)) {
+        if (type === "get")
+            return { path: paths.queryPath, marker: QUERY_MARKER, receiver: "h *QueryHandler" };
+        return { path: paths.commandPath, marker: COMMAND_MARKER, receiver: "h *CommandHandler" };
+    }
+    if (!paths.servicePath)
+        throw new Error("service module is missing application/service.go");
+    return { path: paths.servicePath, marker: SERVICE_MARKER, receiver: "s *Service" };
+}
+function applicationInterfaceMarker(paths, type) {
+    if (isCqrs(paths)) {
+        return type === "get"
+            ? { path: paths.queryPath, marker: QUERY_INTERFACE_MARKER }
+            : { path: paths.commandPath, marker: COMMAND_INTERFACE_MARKER };
+    }
+    return { path: paths.servicePath, marker: SERVICE_INTERFACE_MARKER };
+}
+function methodSignature(naming, method, opts) {
+    if (opts.type === "get" && opts.getMode === "all") {
+        return `${method.pascalName}(context.Context, int, int) ([]domain.${naming.pascalName}, error)`;
+    }
+    if (opts.type === "get") {
+        return `${method.pascalName}(context.Context, string) (*domain.${naming.pascalName}, error)`;
+    }
+    if (opts.type === "post") {
+        return `${method.pascalName}(context.Context, ${method.pascalName}Input) (*domain.${naming.pascalName}, error)`;
+    }
+    return `${method.pascalName}(context.Context, uuid.UUID) error`;
+}
+function applicationMethod(naming, method, opts, receiver) {
+    const target = receiver.startsWith("s ") ? "s" : "h";
+    if (opts.type === "get" && opts.getMode === "all") {
+        return [
+            `func (${receiver}) ${method.pascalName}(ctx context.Context, limit, offset int) ([]domain.${naming.pascalName}, error) {`,
+            `\treturn ${target}.repo.FindAll(ctx, limit, offset)`,
+            `}`,
+            "",
+        ].join("\n");
+    }
+    if (opts.type === "get") {
+        const field = (0, naming_1.toCamelCase)(opts.field ?? "field");
+        const fieldPascal = (0, naming_1.toPascalCase)(opts.field ?? "field");
+        return [
+            `func (${receiver}) ${method.pascalName}(ctx context.Context, ${field} string) (*domain.${naming.pascalName}, error) {`,
+            `\treturn ${target}.repo.FindBy${fieldPascal}(ctx, ${field})`,
+            `}`,
+            "",
+        ].join("\n");
+    }
+    if (opts.type === "post") {
+        return [
+            `func (${receiver}) ${method.pascalName}(ctx context.Context, in ${method.pascalName}Input) (*domain.${naming.pascalName}, error) {`,
+            `\t_ = ctx`,
+            `\t_ = in`,
+            `\treturn nil, domain.ErrNotImplemented`,
+            `}`,
+            "",
+        ].join("\n");
+    }
+    return [
+        `func (${receiver}) ${method.pascalName}(ctx context.Context, id uuid.UUID) error {`,
+        `\t_ = ctx`,
+        `\t_ = id`,
+        `\treturn domain.ErrNotImplemented`,
+        `}`,
+        "",
+    ].join("\n");
+}
+function handlerMethod(naming, method, opts, cqrs, routeReceiver, errorMapper) {
+    const receiver = cqrs ? (opts.type === "get" ? "h.queries" : "h.commands") : "h.svc";
+    if (opts.type === "get" && opts.getMode === "all") {
+        return {
+            route: `${routeReceiver}.GET("/${method.pathSegment}", h.${method.handlerName})`,
+            imports: ["net/http", "pagination"],
+            body: [
+                `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
+                `\tp := pagination.Parse(c)`,
+                `\titems, err := ${receiver}.${method.pascalName}(c.Request.Context(), p.Limit, p.Offset)`,
+                `\tif err != nil {`,
+                `\t\tc.Error(${errorMapper}(err))`,
+                `\t\treturn`,
+                `\t}`,
+                `\tout := make([]response, len(items))`,
+                `\tfor i := range items {`,
+                `\t\tout[i] = toResponse(application.ToResponse(&items[i]))`,
+                `\t}`,
+                `\tc.JSON(http.StatusOK, p.Response(out))`,
+                `}`,
+                "",
+            ].join("\n"),
+        };
+    }
+    if (opts.type === "get") {
+        const field = (0, naming_1.toCamelCase)(opts.field ?? "field");
+        const column = (0, naming_1.toDbName)(opts.field ?? "field");
+        return {
+            route: `${routeReceiver}.GET("/${column}/:${field}", h.${method.handlerName})`,
+            imports: ["net/http"],
+            body: [
+                `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
+                `\t${field} := c.Param("${field}")`,
+                `\tm, err := ${receiver}.${method.pascalName}(c.Request.Context(), ${field})`,
+                `\tif err != nil {`,
+                `\t\tc.Error(${errorMapper}(err))`,
+                `\t\treturn`,
+                `\t}`,
+                `\tc.JSON(http.StatusOK, toResponse(application.ToResponse(m)))`,
+                `}`,
+                "",
+            ].join("\n"),
+        };
+    }
+    if (opts.type === "post") {
+        return {
+            route: `${routeReceiver}.POST("/${method.pathSegment}", h.${method.handlerName})`,
+            imports: ["net/http", "httpx"],
+            body: [
+                `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
+                `\tvar in ${method.pascalName}Input`,
+                `\tif err := c.ShouldBindJSON(&in); err != nil {`,
+                `\t\tc.Error(httpx.BindErr(err))`,
+                `\t\treturn`,
+                `\t}`,
+                `\tm, err := ${receiver}.${method.pascalName}(c.Request.Context(), to${method.pascalName}Input(in))`,
+                `\tif err != nil {`,
+                `\t\tc.Error(${errorMapper}(err))`,
+                `\t\treturn`,
+                `\t}`,
+                `\tc.JSON(http.StatusCreated, toResponse(application.ToResponse(m)))`,
+                `}`,
+                "",
+            ].join("\n"),
+        };
+    }
+    return {
+        route: `${routeReceiver}.${opts.type.toUpperCase()}("/:id/${method.pathSegment}", h.${method.handlerName})`,
+        imports: ["net/http", "httpx"],
+        body: [
+            `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
+            `\tid, ok := httpx.ParseID(c)`,
+            `\tif !ok {`,
+            `\t\treturn`,
+            `\t}`,
+            `\tif err := ${receiver}.${method.pascalName}(c.Request.Context(), id); err != nil {`,
+            `\t\tc.Error(${errorMapper}(err))`,
+            `\t\treturn`,
+            `\t}`,
+            `\tc.Status(http.StatusNoContent)`,
+            `}`,
+            "",
+        ].join("\n"),
+    };
+}
+function assertNotDuplicate(content, needle, what) {
+    if (content.includes(needle))
+        throw new Error(`${what} already exists — pick a different method name`);
+}
+function handlerRouteReceiver(content) {
+    // Auth's protected routes use usersGroup; generated CRUD modules use the
+    // local g group. Both remain the module's inbound adapter boundary.
+    return (0, marker_patch_1.hasMarker)(content, "// go-scaffold:user-routes") ? "usersGroup" : "g";
+}
+function hexagonalMarkersPresent(paths) {
+    if (!fs_extra_1.default.existsSync(paths.dtoPath) || !fs_extra_1.default.existsSync(paths.requestDTOPath) || !fs_extra_1.default.existsSync(paths.portsPath) || !fs_extra_1.default.existsSync(paths.repositoryAdapterPath) || !fs_extra_1.default.existsSync(paths.handlerPath) || !fs_extra_1.default.existsSync(paths.serviceTestPath))
+        return false;
+    const handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
+    if (!(0, marker_patch_1.hasMarker)(handler, HANDLER_ROUTES_MARKER) || !(0, marker_patch_1.hasMarker)(handler, HANDLER_FUNCS_MARKER))
+        return false;
+    const dto = fs_extra_1.default.readFileSync(paths.dtoPath, "utf8");
+    const requestDTO = fs_extra_1.default.readFileSync(paths.requestDTOPath, "utf8");
+    const ports = fs_extra_1.default.readFileSync(paths.portsPath, "utf8");
+    const adapter = fs_extra_1.default.readFileSync(paths.repositoryAdapterPath, "utf8");
+    if (!(0, marker_patch_1.hasMarker)(dto, DTO_MARKER) ||
+        (!(0, marker_patch_1.hasMarker)(requestDTO, DTO_MARKER) && !(0, marker_patch_1.hasMarker)(requestDTO, "// go-scaffold:user-dto")) ||
+        !(0, marker_patch_1.hasMarker)(adapter, REPOSITORY_METHODS_MARKER))
+        return false;
+    if (isCqrs(paths)) {
+        return Boolean(paths.commandPath && paths.queryPath && (0, marker_patch_1.hasMarker)(fs_extra_1.default.readFileSync(paths.commandPath, "utf8"), COMMAND_MARKER) && (0, marker_patch_1.hasMarker)(fs_extra_1.default.readFileSync(paths.commandPath, "utf8"), COMMAND_INTERFACE_MARKER) && (0, marker_patch_1.hasMarker)(fs_extra_1.default.readFileSync(paths.queryPath, "utf8"), QUERY_MARKER) && (0, marker_patch_1.hasMarker)(fs_extra_1.default.readFileSync(paths.queryPath, "utf8"), QUERY_INTERFACE_MARKER) && (0, marker_patch_1.hasMarker)(ports, COMMAND_REPOSITORY_INTERFACE_MARKER) && (0, marker_patch_1.hasMarker)(ports, QUERY_REPOSITORY_INTERFACE_MARKER));
+    }
+    return Boolean(paths.servicePath && (0, marker_patch_1.hasMarker)(fs_extra_1.default.readFileSync(paths.servicePath, "utf8"), SERVICE_MARKER) && (0, marker_patch_1.hasMarker)(fs_extra_1.default.readFileSync(paths.servicePath, "utf8"), SERVICE_INTERFACE_MARKER) && (0, marker_patch_1.hasMarker)(ports, REPOSITORY_INTERFACE_MARKER));
+}
+const COMMAND_REPOSITORY_INTERFACE_MARKER = "// go-scaffold:command-repository-interface";
+function assertHexagonalMethodAbsent(paths, method) {
+    assertNotDuplicate(fs_extra_1.default.readFileSync(paths.handlerPath, "utf8"), `func (h *Handler) ${method.handlerName}(`, `handler method "${method.handlerName}"`);
+    const appFiles = [paths.servicePath, paths.commandPath, paths.queryPath].filter((file) => Boolean(file));
+    for (const file of appFiles)
+        assertNotDuplicate(fs_extra_1.default.readFileSync(file, "utf8"), `) ${method.pascalName}(`, `application method "${method.pascalName}"`);
+}
+function patchHexagonalMethod(paths, naming, method, opts, goModule) {
+    assertHexagonalMethodAbsent(paths, method);
+    if (opts.type === "get" && opts.getMode !== "all" && !opts.field)
+        throw new Error("--field is required for --type get --get-mode one");
+    if (opts.type === "get" && opts.field?.toLowerCase() === "id")
+        throw new Error('--field cannot be "id" — GET /:id already exists as the default lookup');
+    const files = new Map();
+    const cqrs = isCqrs(paths);
+    const interfaceTarget = applicationInterfaceMarker(paths, opts.type);
+    let interfaceFile = read(files, interfaceTarget.path);
+    interfaceFile = insert(interfaceFile, interfaceTarget.marker, methodSignature(naming, method, opts));
+    write(files, interfaceTarget.path, interfaceFile);
+    const target = serviceApplicationTarget(paths, opts.type);
+    let applicationFile = read(files, target.path);
+    applicationFile = addImport(applicationFile, "context");
+    if (opts.type !== "get" && opts.type !== "post")
+        applicationFile = addImport(applicationFile, "github.com/google/uuid");
+    applicationFile = insert(applicationFile, target.marker, applicationMethod(naming, method, opts, target.receiver));
+    write(files, target.path, applicationFile);
+    let handler = read(files, paths.handlerPath);
+    const handlerResult = handlerMethod(naming, method, opts, cqrs, handlerRouteReceiver(handler), paths.handlerErrorMapper ?? "appError");
+    handler = insert(handler, HANDLER_ROUTES_MARKER, handlerResult.route);
+    handler = insert(handler, HANDLER_FUNCS_MARKER, handlerResult.body);
+    for (const need of handlerResult.imports)
+        handler = addImport(handler, need.startsWith("net/") ? need : `${goModule}/internal/shared/${need}`);
+    write(files, paths.handlerPath, handler);
+    if (opts.type === "post") {
+        let dto = read(files, paths.dtoPath);
+        const inputName = `${method.pascalName}Input`;
+        assertNotDuplicate(dto, `type ${inputName} struct`, `DTO "${inputName}"`);
+        dto = insert(dto, DTO_MARKER, [`type ${inputName} struct {`, `\t// TODO: add request fields`, `}`, ""].join("\n"));
+        write(files, paths.dtoPath, dto);
+        let requestDTO = read(files, paths.requestDTOPath);
+        assertNotDuplicate(requestDTO, `type ${inputName} struct`, `HTTP DTO "${inputName}"`);
+        requestDTO = addImport(requestDTO, `${goModule}/internal/app/${naming.pkg}/application`);
+        requestDTO = insert(requestDTO, requestDTOMarker(requestDTO), [
+            `type ${inputName} struct {`,
+            `\t// TODO: mirror request fields from application.${inputName} and add JSON/binding tags`,
+            `}`,
+            "",
+            `func to${inputName}(in ${inputName}) application.${inputName} {`,
+            `\t// TODO: map request fields explicitly into the application input.`,
+            `\t_ = in`,
+            `\treturn application.${inputName}{}`,
+            `}`,
+            "",
+        ].join("\n"));
+        write(files, paths.requestDTOPath, requestDTO);
+    }
+    if (opts.type === "get" && opts.getMode !== "all") {
+        const fieldPascal = (0, naming_1.toPascalCase)(opts.field);
+        const fieldParam = (0, naming_1.toCamelCase)(opts.field);
+        const repoInterfaceMarker = cqrs ? QUERY_REPOSITORY_INTERFACE_MARKER : REPOSITORY_INTERFACE_MARKER;
+        let ports = read(files, paths.portsPath);
+        ports = insert(ports, repoInterfaceMarker, `FindBy${fieldPascal}(context.Context, string) (*domain.${naming.pascalName}, error)`);
+        write(files, paths.portsPath, ports);
+        let adapter = read(files, paths.repositoryAdapterPath);
+        const column = (0, naming_1.toDbName)(opts.field);
+        const modelType = paths.repositoryModelType ?? `${naming.pascalName}Model`;
+        const toDomain = paths.repositoryToDomain ?? "toDomain";
+        const errorMapper = paths.repositoryErrorMapper ?? "mapDatabaseError";
+        adapter = insert(adapter, REPOSITORY_METHODS_MARKER, [
+            `func (r *Repository) FindBy${fieldPascal}(ctx context.Context, ${fieldParam} string) (*domain.${naming.pascalName}, error) {`,
+            `\tvar row ${modelType}`,
+            `\tif err := tx.From(ctx, r.db).WithContext(ctx).First(&row, "${column} = ?", ${fieldParam}).Error; err != nil {`,
+            `\t\treturn nil, ${errorMapper}(err)`,
+            `\t}`,
+            `\treturn ${toDomain}(&row), nil`,
+            `}`,
+            "",
+        ].join("\n"));
+        write(files, paths.repositoryAdapterPath, adapter);
+        let test = read(files, paths.serviceTestPath);
+        const stubField = `findBy${fieldPascal}Fn`;
+        assertNotDuplicate(test, `${stubField} func(`, `repository stub field "${stubField}"`);
+        test = insert(test, REPOSITORY_STUB_FIELDS_MARKER, `\t${stubField} func(context.Context, string) (*domain.${naming.pascalName}, error)`);
+        const stubReceiver = paths.repositoryStubReceiver ?? "s *repositoryStub";
+        const stubVariable = stubReceiver.split(" ")[0];
+        assertNotDuplicate(test, `func (${stubReceiver}) FindBy${fieldPascal}(`, `repository stub method "FindBy${fieldPascal}"`);
+        test = insert(test, REPOSITORY_STUB_METHODS_MARKER, [
+            `func (${stubReceiver}) FindBy${fieldPascal}(ctx context.Context, value string) (*domain.${naming.pascalName}, error) {`,
+            `\tif ${stubVariable}.${stubField} == nil {`,
+            `\t\tpanic("unexpected repository.FindBy${fieldPascal} call")`,
+            `\t}`,
+            `\treturn ${stubVariable}.${stubField}(ctx, value)`,
+            `}`,
+            "",
+        ].join("\n"));
+        write(files, paths.serviceTestPath, test);
+    }
+    for (const [file, content] of files)
+        fs_extra_1.default.writeFileSync(file, content);
+}

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 modelAlias = `${patch.pkg}postgres`; // every domain's persistence adapter is named "postgres"
+    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
+        modelImportLine: `${modelAlias} "${patch.goModule}/internal/app/${patch.modulePath}/adapters/outbound/postgres"`,
+        // 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).
@@ -47,16 +49,18 @@ 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} :=`,
+        migrateLine: `&${modelAlias}.${patch.pascalName}Model{},`,
+        // 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

package/dist/utils/module-location.js

@@ -18,7 +18,7 @@ function existingModulePackages(projectDir) {
         .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
+// came from "order-items". Everything else a command derives — the entity 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
@@ -29,15 +29,21 @@ function existingModulePackages(projectDir) {
 // 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.
+// The outbound persistence model is where the generated PascalCase type
+// survives, 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;
+    // Split hexagonal modules keep persistence models in the outbound adapter.
+    // The package name still loses word boundaries (`orderitem`), so recover
+    // the original PascalCase entity from the generated `OrderItemModel` type
+    // before commands such as `undo module orderitem` rebuild their wiring.
+    const adapterModelPath = path_1.default.join(projectDir, "internal", "app", pkg, "adapters", "outbound", "postgres", "model.go");
+    if (fs_extra_1.default.existsSync(adapterModelPath)) {
+        const match = fs_extra_1.default.readFileSync(adapterModelPath, "utf8").match(/^type\s+([A-Z]\w*)Model\s+struct\b/m);
+        if (match)
+            return match[1];
+    }
+    return null;
 }
 function resolveProjectModuleNaming(projectDir, rawName) {
     const located = (0, naming_1.resolveExistingModuleNaming)(rawName, existingModulePackages(projectDir));
@@ -52,7 +58,7 @@ function resolveProjectModuleNaming(projectDir, rawName) {
         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.
+    // A hand-renamed struct whose type no longer matches its folder would
+    // otherwise silently retarget the command at another module.
     return fromDisk.pkg === located.pkg ? fromDisk : located;
 }

package/dist/utils/module-profile.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleProfileFor = moduleProfileFor;
+exports.architectureForModuleProfile = architectureForModuleProfile;
+exports.describeModuleProfile = describeModuleProfile;
+function moduleProfileFor(moduleSurface, applicationStyle) {
+    if (moduleSurface === "minimal" && applicationStyle === "service")
+        return "lean";
+    if (moduleSurface === "crud" && applicationStyle === "service")
+        return "crud";
+    if (moduleSurface === "minimal" && applicationStyle === "cqrs")
+        return "cqrs";
+    return "advanced";
+}
+function architectureForModuleProfile(profile) {
+    if (profile === "crud") {
+        return { moduleSurface: "crud", applicationStyle: "service" };
+    }
+    if (profile === "cqrs") {
+        return { moduleSurface: "minimal", applicationStyle: "cqrs" };
+    }
+    return { moduleSurface: "minimal", applicationStyle: "service" };
+}
+function describeModuleProfile(profile) {
+    if (profile === "lean")
+        return "Lean (minimal + service)";
+    if (profile === "crud")
+        return "CRUD (CRUD surface + service)";
+    if (profile === "cqrs")
+        return "CQRS (minimal surface + CQRS)";
+    return "Advanced (choose surface + application boundary)";
+}