@nakedev/go-scaffold 0.3.3 → 0.4.3

package/dist/utils/method-patcher.js

@@ -6,19 +6,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertMethodAbsent = assertMethodAbsent;
 exports.patchMethod = patchMethod;
 exports.markersPresent = markersPresent;
+exports.markersPresentForPaths = markersPresentForPaths;
 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 AUTH_DTO_MARKER = "// go-scaffold:user-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 COMMAND_REPO_INTERFACE_MARKER = "// go-scaffold:command-repository-interface";
+const QUERY_REPO_INTERFACE_MARKER = "// go-scaffold:query-repository-interface";
+const COMMAND_MARKER = "// go-scaffold:command-methods";
+const QUERY_MARKER = "// go-scaffold:query-methods";
+const COMMAND_INTERFACE_MARKER = "// go-scaffold:command-interface";
+const QUERY_INTERFACE_MARKER = "// go-scaffold:query-interface";
 const HANDLER_ROUTES_MARKER = "// go-scaffold:handler-routes";
 const HANDLER_FUNCS_MARKER = "// go-scaffold:handler-funcs";
+// Auth deliberately keeps its route/service composition files focused rather
+// than using the generic CRUD marker names. `generate method user ...` is
+// still a supported extension point, so accept both marker vocabularies.
+const AUTH_REPO_INTERFACE_MARKER = "// go-scaffold:user-repository-interface";
+const AUTH_REPO_IMPL_MARKER = "// go-scaffold:user-repository-methods";
+const AUTH_SERVICE_MARKER = "// go-scaffold:user-service-methods";
+const AUTH_HANDLER_ROUTES_MARKER = "// go-scaffold:user-routes";
+const AUTH_HANDLER_FUNCS_MARKER = "// go-scaffold:user-handler-funcs";
 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 AUTH_FAKE_REPO_METHODS_MARKER = "// go-scaffold:user-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
@@ -31,6 +48,52 @@ function writeHandler(handlerPath, content, goModule, needs) {
     }
     fs_extra_1.default.writeFileSync(handlerPath, content.replace(UNUSED_G_LINE, ""));
 }
+function isCqrs(paths) {
+    return Boolean(paths.commandPath &&
+        paths.queryPath &&
+        fs_extra_1.default.existsSync(paths.commandPath) &&
+        fs_extra_1.default.existsSync(paths.queryPath));
+}
+function cqrsTarget(paths, type) {
+    if (!isCqrs(paths))
+        return null;
+    if (type === "get") {
+        return {
+            path: paths.queryPath,
+            implementationMarker: QUERY_MARKER,
+            interfaceMarker: QUERY_INTERFACE_MARKER,
+            callReceiver: "queries",
+        };
+    }
+    return {
+        path: paths.commandPath,
+        implementationMarker: COMMAND_MARKER,
+        interfaceMarker: COMMAND_INTERFACE_MARKER,
+        callReceiver: "commands",
+    };
+}
+function insertCqrsImplementation(paths, type, block, goModule) {
+    const target = cqrsTarget(paths, type);
+    if (!target)
+        return;
+    let content = fs_extra_1.default.readFileSync(target.path, "utf8");
+    if (type !== "get") {
+        content = (0, marker_patch_1.ensureImport)(content, `${goModule}/internal/shared/apperror`);
+    }
+    content = (0, marker_patch_1.insertBeforeMarker)(content, target.implementationMarker, block);
+    fs_extra_1.default.writeFileSync(target.path, content);
+}
+function insertCqrsFacade(servicePath, block, goModule, modulePath) {
+    let service = fs_extra_1.default.readFileSync(servicePath, "utf8");
+    // Minimal CQRS service.go intentionally has no imports until a method is
+    // generated. The compatibility facade still uses the normal feature input,
+    // model, and UUID types, so make the first generated method compile too.
+    service = (0, marker_patch_1.ensureImport)(service, "context");
+    service = (0, marker_patch_1.ensureImport)(service, `${goModule}/internal/app/${modulePath}/model`);
+    service = (0, marker_patch_1.ensureImport)(service, "github.com/google/uuid");
+    service = (0, marker_patch_1.insertBeforeMarker)(service, SERVICE_MARKER, block);
+    fs_extra_1.default.writeFileSync(servicePath, service);
+}
 function assertNotDuplicate(content, needle, what) {
     if (content.includes(needle)) {
         throw new Error(`${what} already exists — pick a different method name`);
@@ -39,6 +102,16 @@ function assertNotDuplicate(content, needle, what) {
 function routeCall(type) {
     return { get: "GET", post: "POST", put: "PUT", patch: "PATCH", delete: "DELETE" }[type];
 }
+function insertBeforeMethodMarker(content, standard, auth, block) {
+    const marker = (0, marker_patch_1.hasMarker)(content, standard) ? standard : (0, marker_patch_1.hasMarker)(content, auth) ? auth : standard;
+    return (0, marker_patch_1.insertBeforeMarker)(content, marker, block);
+}
+function hasMethodMarker(content, standard, auth) {
+    return (0, marker_patch_1.hasMarker)(content, standard) || (0, marker_patch_1.hasMarker)(content, auth);
+}
+function handlerRouteReceiver(content) {
+    return (0, marker_patch_1.hasMarker)(content, AUTH_HANDLER_ROUTES_MARKER) ? "usersGroup" : "g";
+}
 // assertMethodAbsent is the same check patchMethod runs, exported so callers
 // can reach it before their own pre-flight checks. A name that already exists
 // is the cause the caller needs to hear about, so it has to be reported ahead
@@ -67,14 +140,27 @@ function patchMethod(paths, naming, method, opts, goModule) {
         patchPost(paths, naming, method, goModule);
     }
     else if (opts.type === "put" || opts.type === "patch") {
-        patchResourceAction(paths, naming, method, opts.type, goModule);
+        patchResourceAction(paths, method, opts.type, goModule, naming.pkg);
     }
     else {
-        patchDelete(paths, method, goModule);
+        patchDelete(paths, method, goModule, naming.pkg);
     }
-    patchHandlerServiceInterface(paths.handlerPath, naming, method, opts, goModule);
+    ensureNonCqrsServiceImports(paths, goModule);
+    patchHandlerServiceInterface(paths, naming, method, opts, goModule);
 }
-function patchHandlerServiceInterface(handlerPath, naming, method, opts, goModule) {
+// Auth keeps service.go intentionally small, so it does not carry the
+// apperror import that ordinary generated CRUD services use. A later
+// `generate method user ...` still inserts the same error-returning method
+// shape; make that extension compile without reintroducing the import into
+// every auth-only project.
+function ensureNonCqrsServiceImports(paths, goModule) {
+    if (isCqrs(paths))
+        return;
+    let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
+    service = (0, marker_patch_1.ensureImport)(service, `${goModule}/internal/shared/apperror`);
+    fs_extra_1.default.writeFileSync(paths.servicePath, service);
+}
+function patchHandlerServiceInterface(paths, naming, method, opts, goModule) {
     let signature;
     let needsModel = true;
     let needsUUID = false;
@@ -88,7 +174,8 @@ function patchHandlerServiceInterface(handlerPath, naming, method, opts, goModul
         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)`;
+        signature = `${method.pascalName}(context.Context, uuid.UUID) error`;
+        needsModel = false;
         needsUUID = true;
     }
     else {
@@ -96,7 +183,7 @@ function patchHandlerServiceInterface(handlerPath, naming, method, opts, goModul
         needsModel = false;
         needsUUID = true;
     }
-    let handler = fs_extra_1.default.readFileSync(handlerPath, "utf8");
+    let handler = fs_extra_1.default.readFileSync(paths.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
@@ -113,15 +200,22 @@ function patchHandlerServiceInterface(handlerPath, naming, method, opts, goModul
     if (needsUUID) {
         handler = (0, marker_patch_1.ensureImport)(handler, "github.com/google/uuid");
     }
-    fs_extra_1.default.writeFileSync(handlerPath, handler);
+    fs_extra_1.default.writeFileSync(paths.handlerPath, handler);
+    const target = cqrsTarget(paths, opts.type);
+    if (target) {
+        let application = fs_extra_1.default.readFileSync(target.path, "utf8");
+        application = (0, marker_patch_1.insertBeforeMarker)(application, target.interfaceMarker, signature);
+        fs_extra_1.default.writeFileSync(target.path, application);
+    }
 }
 function patchGetAll(paths, naming, method, goModule) {
     let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_ROUTES_MARKER, `g.GET("/${method.pathSegment}", h.${method.handlerName})`);
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_FUNCS_MARKER, [
+    const routeReceiver = handlerRouteReceiver(handler);
+    handler = insertBeforeMethodMarker(handler, HANDLER_ROUTES_MARKER, AUTH_HANDLER_ROUTES_MARKER, `${routeReceiver}.GET("/${method.pathSegment}", h.${method.handlerName})`);
+    handler = insertBeforeMethodMarker(handler, HANDLER_FUNCS_MARKER, AUTH_HANDLER_FUNCS_MARKER, [
         `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
         `\tp := pagination.Parse(c)`,
-        `\titems, err := h.svc.${method.pascalName}(c.Request.Context(), p.Limit, p.Offset)`,
+        `\titems, err := ${isCqrs(paths) ? `h.queries.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), p.Limit, p.Offset)`,
         `\tif err != nil {`,
         `\t\tc.Error(err)`,
         `\t\treturn`,
@@ -135,19 +229,32 @@ function patchGetAll(paths, naming, method, goModule) {
         ``,
     ].join("\n"));
     writeHandler(paths.handlerPath, handler, goModule, ["net/http", "pagination"]);
-    let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
-    service = (0, marker_patch_1.insertBeforeMarker)(service, SERVICE_MARKER, [
-        `func (s *Service) ${method.pascalName}(ctx context.Context, limit, offset int) ([]model.${naming.pascalName}, error) {`,
+    const queryMethod = [
+        `func (h *QueryHandler) ${method.pascalName}(ctx context.Context, limit, offset int) ([]model.${naming.pascalName}, error) {`,
         `\t// TODO: add real filtering for "${method.name}" — currently reuses FindAll`,
-        `\titems, err := s.repo.FindAll(ctx, limit, offset)`,
+        `\titems, err := h.repo.FindAll(ctx, limit, offset)`,
         `\tif err != nil {`,
-        `\t\treturn nil, apperror.NewInternal()`,
+        `\t\treturn nil, apperror.NewInternal(err)`,
         `\t}`,
         `\treturn items, nil`,
         `}`,
         ``,
-    ].join("\n"));
-    fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    ].join("\n");
+    const serviceFacade = [
+        `func (s *Service) ${method.pascalName}(ctx context.Context, limit, offset int) ([]model.${naming.pascalName}, error) {`,
+        `\treturn s.queries.${method.pascalName}(ctx, limit, offset)`,
+        `}`,
+        ``,
+    ].join("\n");
+    if (isCqrs(paths)) {
+        insertCqrsImplementation(paths, "get", queryMethod, goModule);
+        insertCqrsFacade(paths.servicePath, serviceFacade, goModule, naming.pkg);
+    }
+    else {
+        let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
+        service = insertBeforeMethodMarker(service, SERVICE_MARKER, AUTH_SERVICE_MARKER, queryMethod.replace("(h *QueryHandler)", "(s *Service)").replace("h.repo", "s.repo"));
+        fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    }
 }
 function patchGetOne(paths, naming, method, rawField, goModule) {
     const fieldParam = (0, naming_1.toCamelCase)(rawField);
@@ -155,7 +262,7 @@ function patchGetOne(paths, naming, method, rawField, goModule) {
     const fieldColumn = (0, naming_1.toDbName)(rawField);
     let repo = fs_extra_1.default.readFileSync(paths.repositoryPath, "utf8");
     assertNotDuplicate(repo, `FindBy${fieldPascal}(`, `repository method "FindBy${fieldPascal}"`);
-    repo = (0, marker_patch_1.insertBeforeMarker)(repo, REPO_IMPL_MARKER, [
+    repo = insertBeforeMethodMarker(repo, REPO_IMPL_MARKER, AUTH_REPO_IMPL_MARKER, [
         `func (r *Repository) FindBy${fieldPascal}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error) {`,
         `\tvar m model.${naming.pascalName}`,
         `\t// TODO: add the "${fieldColumn}" column and an index on it — this query`,
@@ -173,7 +280,14 @@ function patchGetOne(paths, naming, method, rawField, goModule) {
     ].join("\n"));
     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)`);
+    if (isCqrs(paths)) {
+        let query = fs_extra_1.default.readFileSync(paths.queryPath, "utf8");
+        query = (0, marker_patch_1.insertBeforeMarker)(query, QUERY_REPO_INTERFACE_MARKER, `FindBy${fieldPascal}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error)`);
+        fs_extra_1.default.writeFileSync(paths.queryPath, query);
+    }
+    else {
+        service = insertBeforeMethodMarker(service, REPO_INTERFACE_MARKER, AUTH_REPO_INTERFACE_MARKER, `FindBy${fieldPascal}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error)`);
+    }
     // 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
@@ -193,6 +307,15 @@ function patchGetOne(paths, naming, method, rawField, goModule) {
             ``,
         ].join("\n"));
     }
+    else if ((0, marker_patch_1.hasMarker)(serviceTest, AUTH_FAKE_REPO_METHODS_MARKER)) {
+        serviceTest = (0, marker_patch_1.insertBeforeMarker)(serviceTest, AUTH_FAKE_REPO_METHODS_MARKER, [
+            `//nolint:unused`,
+            `func (f *fakeRepo) FindBy${fieldPascal}(context.Context, string) (*model.${naming.pascalName}, error) {`,
+            `	return nil, gorm.ErrRecordNotFound`,
+            `}`,
+            ``,
+        ].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`,
@@ -209,23 +332,37 @@ function patchGetOne(paths, naming, method, rawField, goModule) {
         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) {`,
-        `\tm, err := s.repo.FindBy${fieldPascal}(ctx, ${fieldParam})`,
+    const queryMethod = [
+        `func (h *QueryHandler) ${method.pascalName}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error) {`,
+        `\tm, err := h.repo.FindBy${fieldPascal}(ctx, ${fieldParam})`,
         `\tif err != nil {`,
         `\t\treturn nil, wrapFindErr(err)`,
         `\t}`,
         `\treturn m, nil`,
         `}`,
         ``,
-    ].join("\n"));
-    fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    ].join("\n");
+    const serviceFacade = [
+        `func (s *Service) ${method.pascalName}(ctx context.Context, ${fieldParam} string) (*model.${naming.pascalName}, error) {`,
+        `\treturn s.queries.${method.pascalName}(ctx, ${fieldParam})`,
+        `}`,
+        ``,
+    ].join("\n");
+    if (isCqrs(paths)) {
+        insertCqrsImplementation(paths, "get", queryMethod, goModule);
+        insertCqrsFacade(paths.servicePath, serviceFacade, goModule, naming.pkg);
+    }
+    else {
+        service = insertBeforeMethodMarker(service, SERVICE_MARKER, AUTH_SERVICE_MARKER, queryMethod.replace("(h *QueryHandler)", "(s *Service)").replace("h.repo", "s.repo"));
+        fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    }
     let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_ROUTES_MARKER, `g.GET("/${fieldColumn}/:${fieldParam}", h.${method.handlerName})`);
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_FUNCS_MARKER, [
+    const routeReceiver = handlerRouteReceiver(handler);
+    handler = insertBeforeMethodMarker(handler, HANDLER_ROUTES_MARKER, AUTH_HANDLER_ROUTES_MARKER, `${routeReceiver}.GET("/${fieldColumn}/:${fieldParam}", h.${method.handlerName})`);
+    handler = insertBeforeMethodMarker(handler, HANDLER_FUNCS_MARKER, AUTH_HANDLER_FUNCS_MARKER, [
         `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
         `\t${fieldParam} := c.Param("${fieldParam}")`,
-        `\tm, err := h.svc.${method.pascalName}(c.Request.Context(), ${fieldParam})`,
+        `\tm, err := ${isCqrs(paths) ? `h.queries.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), ${fieldParam})`,
         `\tif err != nil {`,
         `\t\tc.Error(err)`,
         `\t\treturn`,
@@ -240,18 +377,19 @@ function patchPost(paths, naming, method, goModule) {
     const inputName = `${method.pascalName}Input`;
     let dto = fs_extra_1.default.readFileSync(paths.dtoPath, "utf8");
     assertNotDuplicate(dto, `type ${inputName} struct`, `DTO "${inputName}"`);
-    dto = (0, marker_patch_1.insertBeforeMarker)(dto, DTO_MARKER, [`type ${inputName} struct {`, `\t// TODO: add request fields`, `}`, ``].join("\n"));
+    dto = insertBeforeMethodMarker(dto, DTO_MARKER, AUTH_DTO_MARKER, [`type ${inputName} struct {`, `\t// TODO: add request fields`, `}`, ``].join("\n"));
     fs_extra_1.default.writeFileSync(paths.dtoPath, dto);
     let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_ROUTES_MARKER, `g.POST("/${method.pathSegment}", h.${method.handlerName})`);
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_FUNCS_MARKER, [
+    const routeReceiver = handlerRouteReceiver(handler);
+    handler = insertBeforeMethodMarker(handler, HANDLER_ROUTES_MARKER, AUTH_HANDLER_ROUTES_MARKER, `${routeReceiver}.POST("/${method.pathSegment}", h.${method.handlerName})`);
+    handler = insertBeforeMethodMarker(handler, HANDLER_FUNCS_MARKER, AUTH_HANDLER_FUNCS_MARKER, [
         `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
         `\tvar in ${inputName}`,
         `\tif err := c.ShouldBindJSON(&in); err != nil {`,
         `\t\tc.Error(httpx.BindErr(err))`,
         `\t\treturn`,
         `\t}`,
-        `\tm, err := h.svc.${method.pascalName}(c.Request.Context(), in)`,
+        `\tm, err := ${isCqrs(paths) ? `h.commands.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), in)`,
         `\tif err != nil {`,
         `\t\tc.Error(err)`,
         `\t\treturn`,
@@ -261,73 +399,84 @@ function patchPost(paths, naming, method, goModule) {
         ``,
     ].join("\n"));
     writeHandler(paths.handlerPath, handler, goModule, ["net/http", "httpx"]);
-    let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
-    service = (0, marker_patch_1.insertBeforeMarker)(service, SERVICE_MARKER, [
-        `func (s *Service) ${method.pascalName}(ctx context.Context, in ${inputName}) (*model.${naming.pascalName}, error) {`,
+    const commandMethod = [
+        `func (h *CommandHandler) ${method.pascalName}(ctx context.Context, in ${inputName}) (*model.${naming.pascalName}, error) {`,
         `\t// TODO: implement "${method.name}" — this stub does nothing yet`,
         `\t_ = in`,
         `\treturn nil, apperror.NewInternal()`,
         `}`,
         ``,
-    ].join("\n"));
-    fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    ].join("\n");
+    const serviceFacade = [
+        `func (s *Service) ${method.pascalName}(ctx context.Context, in ${inputName}) (*model.${naming.pascalName}, error) {`,
+        `\treturn s.commands.${method.pascalName}(ctx, in)`,
+        `}`,
+        ``,
+    ].join("\n");
+    if (isCqrs(paths)) {
+        insertCqrsImplementation(paths, "post", commandMethod, goModule);
+        insertCqrsFacade(paths.servicePath, serviceFacade, goModule, naming.pkg);
+    }
+    else {
+        let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
+        service = insertBeforeMethodMarker(service, SERVICE_MARKER, AUTH_SERVICE_MARKER, commandMethod.replace("(h *CommandHandler)", "(s *Service)").replace("h.repo", "s.repo"));
+        fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    }
 }
-function patchResourceAction(paths, naming, method, type, goModule) {
+function patchResourceAction(paths, method, type, goModule, modulePath) {
     let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_ROUTES_MARKER, `g.${routeCall(type)}("/:id/${method.pathSegment}", h.${method.handlerName})`);
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_FUNCS_MARKER, [
+    const routeReceiver = handlerRouteReceiver(handler);
+    handler = insertBeforeMethodMarker(handler, HANDLER_ROUTES_MARKER, AUTH_HANDLER_ROUTES_MARKER, `${routeReceiver}.${routeCall(type)}("/:id/${method.pathSegment}", h.${method.handlerName})`);
+    handler = insertBeforeMethodMarker(handler, HANDLER_FUNCS_MARKER, AUTH_HANDLER_FUNCS_MARKER, [
         `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
         `\tid, ok := httpx.ParseID(c)`,
         `\tif !ok {`,
         `\t\treturn`,
         `\t}`,
-        `\tm, err := h.svc.${method.pascalName}(c.Request.Context(), id)`,
-        `\tif err != nil {`,
+        `\tif err := ${isCqrs(paths) ? `h.commands.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), id); err != nil {`,
         `\t\tc.Error(err)`,
         `\t\treturn`,
         `\t}`,
-        `\tc.JSON(http.StatusOK, toResponse(m))`,
+        `\tc.Status(http.StatusNotImplemented)`,
         `}`,
         ``,
     ].join("\n"));
     writeHandler(paths.handlerPath, handler, goModule, ["net/http", "httpx"]);
-    let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
-    service = (0, marker_patch_1.insertBeforeMarker)(service, SERVICE_MARKER, [
-        `func (s *Service) ${method.pascalName}(ctx context.Context, id uuid.UUID) (*model.${naming.pascalName}, error) {`,
-        `\tm, err := s.repo.FindByID(ctx, id)`,
-        `\tif err != nil {`,
-        `\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`,
+    const commandMethod = [
+        `func (h *CommandHandler) ${method.pascalName}(ctx context.Context, id uuid.UUID) error {`,
+        `\t_ = ctx`,
+        `\t_ = id`,
+        `\treturn apperror.NewNotImplemented()`,
         `}`,
         ``,
-    ].join("\n"));
-    fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    ].join("\n");
+    const serviceFacade = [
+        `func (s *Service) ${method.pascalName}(ctx context.Context, id uuid.UUID) error {`,
+        `\treturn s.commands.${method.pascalName}(ctx, id)`,
+        `}`,
+        ``,
+    ].join("\n");
+    if (isCqrs(paths)) {
+        insertCqrsImplementation(paths, type, commandMethod, goModule);
+        insertCqrsFacade(paths.servicePath, serviceFacade, goModule, modulePath);
+    }
+    else {
+        let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
+        service = insertBeforeMethodMarker(service, SERVICE_MARKER, AUTH_SERVICE_MARKER, commandMethod.replace("(h *CommandHandler)", "(s *Service)"));
+        fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    }
 }
-function patchDelete(paths, method, goModule) {
+function patchDelete(paths, method, goModule, modulePath) {
     let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_ROUTES_MARKER, `g.DELETE("/:id/${method.pathSegment}", h.${method.handlerName})`);
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, HANDLER_FUNCS_MARKER, [
+    const routeReceiver = handlerRouteReceiver(handler);
+    handler = insertBeforeMethodMarker(handler, HANDLER_ROUTES_MARKER, AUTH_HANDLER_ROUTES_MARKER, `${routeReceiver}.DELETE("/:id/${method.pathSegment}", h.${method.handlerName})`);
+    handler = insertBeforeMethodMarker(handler, HANDLER_FUNCS_MARKER, AUTH_HANDLER_FUNCS_MARKER, [
         `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
         `\tid, ok := httpx.ParseID(c)`,
         `\tif !ok {`,
         `\t\treturn`,
         `\t}`,
-        `\tif err := h.svc.${method.pascalName}(c.Request.Context(), id); err != nil {`,
+        `\tif err := ${isCqrs(paths) ? `h.commands.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), id); err != nil {`,
         `\t\tc.Error(err)`,
         `\t\treturn`,
         `\t}`,
@@ -336,22 +485,53 @@ function patchDelete(paths, method, goModule) {
         ``,
     ].join("\n"));
     writeHandler(paths.handlerPath, handler, goModule, ["net/http", "httpx"]);
-    let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
-    service = (0, marker_patch_1.insertBeforeMarker)(service, SERVICE_MARKER, [
-        `func (s *Service) ${method.pascalName}(ctx context.Context, id uuid.UUID) error {`,
+    const commandMethod = [
+        `func (h *CommandHandler) ${method.pascalName}(ctx context.Context, id uuid.UUID) error {`,
         `\t// TODO: implement "${method.name}" — this stub does nothing yet`,
         `\treturn apperror.NewInternal()`,
         `}`,
         ``,
-    ].join("\n"));
-    fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    ].join("\n");
+    const serviceFacade = [
+        `func (s *Service) ${method.pascalName}(ctx context.Context, id uuid.UUID) error {`,
+        `\treturn s.commands.${method.pascalName}(ctx, id)`,
+        `}`,
+        ``,
+    ].join("\n");
+    if (isCqrs(paths)) {
+        insertCqrsImplementation(paths, "delete", commandMethod, goModule);
+        insertCqrsFacade(paths.servicePath, serviceFacade, goModule, modulePath);
+    }
+    else {
+        let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
+        service = insertBeforeMethodMarker(service, SERVICE_MARKER, AUTH_SERVICE_MARKER, commandMethod.replace("(h *CommandHandler)", "(s *Service)"));
+        fs_extra_1.default.writeFileSync(paths.servicePath, service);
+    }
 }
 function markersPresent(handlerPath, servicePath) {
-    const handler = fs_extra_1.default.readFileSync(handlerPath, "utf8");
-    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) &&
+    return markersPresentForPaths({ handlerPath, servicePath });
+}
+function markersPresentForPaths(paths) {
+    const handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
+    const service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
+    const baseMarkers = hasMethodMarker(handler, HANDLER_ROUTES_MARKER, AUTH_HANDLER_ROUTES_MARKER) &&
+        hasMethodMarker(handler, HANDLER_FUNCS_MARKER, AUTH_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));
+        hasMethodMarker(service, SERVICE_MARKER, AUTH_SERVICE_MARKER) &&
+        hasMethodMarker(service, REPO_INTERFACE_MARKER, AUTH_REPO_INTERFACE_MARKER);
+    const hasCommand = Boolean(paths.commandPath && fs_extra_1.default.existsSync(paths.commandPath));
+    const hasQuery = Boolean(paths.queryPath && fs_extra_1.default.existsSync(paths.queryPath));
+    if (!hasCommand && !hasQuery)
+        return baseMarkers;
+    if (!hasCommand || !hasQuery)
+        return false;
+    const commands = fs_extra_1.default.readFileSync(paths.commandPath, "utf8");
+    const queries = fs_extra_1.default.readFileSync(paths.queryPath, "utf8");
+    return (baseMarkers &&
+        (0, marker_patch_1.hasMarker)(commands, COMMAND_MARKER) &&
+        (0, marker_patch_1.hasMarker)(commands, COMMAND_INTERFACE_MARKER) &&
+        (0, marker_patch_1.hasMarker)(commands, COMMAND_REPO_INTERFACE_MARKER) &&
+        (0, marker_patch_1.hasMarker)(queries, QUERY_MARKER) &&
+        (0, marker_patch_1.hasMarker)(queries, QUERY_INTERFACE_MARKER) &&
+        (0, marker_patch_1.hasMarker)(queries, QUERY_REPO_INTERFACE_MARKER));
 }

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)";
+}

package/dist/utils/observability-patcher.js

@@ -49,8 +49,8 @@ function patchMainGoForObservability(mainGoPath, goModule, projectName) {
     }
     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
+    // Unlike docs/, which is never served at all: 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()))';

package/dist/utils/platform-patcher.js

@@ -17,7 +17,6 @@ const CONFIG_FIELDS_MARKER = "// go-scaffold:config-fields";
 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";
 // 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
@@ -55,8 +54,7 @@ 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;
+    const hasRedisService = /^\s{6}redis:/m.test(content);
     // `steps:` sits one level under the job, so it's the first line that ends
     // the `services:` block — insert the service just above it.
     //
@@ -65,7 +63,7 @@ function patchCiForRedis(ciPath) {
     // means CI runs without Redis and fails on a connection error that says
     // nothing about this — so say it here instead.
     const stepsLine = content.split("\n").find((l) => l.trimEnd() === "    steps:");
-    if (!stepsLine) {
+    if (!hasRedisService && !stepsLine) {
         console.error(picocolors_1.default.yellow(`skipped adding the Redis service to ${ciPath} — no \`steps:\` line at the expected indentation to anchor it to.\n` +
             `Add a redis service to the workflow's \`services:\` block by hand, or CI will run without one.`));
         return;
@@ -82,7 +80,25 @@ function patchCiForRedis(ciPath) {
         "          --health-retries 5",
         "",
     ].join("\n");
-    fs_extra_1.default.writeFileSync(ciPath, content.replace(stepsLine, () => `${service}\n${stepsLine}`));
+    let patched = hasRedisService ? content : content.replace(stepsLine, () => `${service}\n${stepsLine}`);
+    // The service alone is not enough: token-store tests deliberately skip when
+    // TEST_REDIS_URL is absent, so a generated workflow could report green while
+    // never exercising Redis. Add the required test variables alongside the
+    // existing PostgreSQL test variables, anchored on the actual go test line so
+    // we do not accidentally put them in the Postgres container's env block.
+    const testRunLine = "        run: go test ./...";
+    if (!patched.includes("REQUIRE_TEST_REDIS")) {
+        if (!patched.includes(testRunLine)) {
+            console.error(picocolors_1.default.yellow(`skipped requiring Redis integration tests in ${ciPath} — no \`run: go test ./...\` line to anchor the test environment to.\n` +
+                `Add TEST_REDIS_URL and REQUIRE_TEST_REDIS=true to the workflow's test step by hand.`));
+        }
+        else {
+            patched = patched.replace(testRunLine, '          TEST_REDIS_URL: redis://127.0.0.1:6379/0\n' +
+                '          REQUIRE_TEST_REDIS: "true"\n' +
+                testRunLine);
+        }
+    }
+    fs_extra_1.default.writeFileSync(ciPath, patched);
 }
 // 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
@@ -141,6 +157,14 @@ function patchMainGoForWorker(mainGoPath, goModule) {
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, IMPORT_MARKER, cacheImport, cacheImport);
     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 cleanupBlock = [
+        "defer func() {",
+        '\tif err := rdb.Close(); err != nil {',
+        '\t\tlogger.Error("close redis", "error", err)',
+        "\t}",
+        "}()",
+    ].join("\n");
+    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, PLATFORM_INIT_MARKER, cleanupBlock, "defer func() {\n\tif err := rdb.Close()");
     const readyzBlock = [
         "if err := rdb.Ping(c.Request.Context()).Err(); err != nil {",
         '\tc.JSON(http.StatusServiceUnavailable, gin.H{"status": "unavailable"})',
@@ -148,7 +172,5 @@ function patchMainGoForWorker(mainGoPath, goModule) {
         "}",
     ].join("\n");
     content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, READYZ_MARKER, readyzBlock, "if err := rdb.Ping(");
-    const shutdownBlock = ["if err := rdb.Close(); err != nil {", '\tlogger.Error("close redis", "error", err)', "}"].join("\n");
-    content = (0, marker_patch_1.insertBeforeMarkerOnce)(content, SHUTDOWN_MARKER, shutdownBlock, "if err := rdb.Close()");
     fs_extra_1.default.writeFileSync(mainGoPath, content);
 }