@nakedev/go-scaffold 0.4.3 → 0.5.0

package/dist/utils/method-patcher.js

@@ -1,537 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-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
-// `_ = g` placeholder once a real route makes it unnecessary — a no-op on a
-// full module, which already imports everything and never has that line.
-function writeHandler(handlerPath, content, goModule, needs) {
-    for (const pkg of needs) {
-        const importPath = pkg.startsWith("net/") ? pkg : `${goModule}/internal/shared/${pkg}`;
-        content = (0, marker_patch_1.ensureImport)(content, importPath);
-    }
-    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`);
-    }
-}
-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
-// of anything downstream of it (the OpenAPI document that name would collide
-// with, for one) rather than after.
-function assertMethodAbsent(paths, method) {
-    const handlerSig = `func (h *Handler) ${method.handlerName}(`;
-    const serviceSig = `func (s *Service) ${method.pascalName}(`;
-    assertNotDuplicate(fs_extra_1.default.readFileSync(paths.handlerPath, "utf8"), handlerSig, `handler method "${method.handlerName}"`);
-    assertNotDuplicate(fs_extra_1.default.readFileSync(paths.servicePath, "utf8"), serviceSig, `service method "${method.pascalName}"`);
-}
-function patchMethod(paths, naming, method, opts, goModule) {
-    assertMethodAbsent(paths, method);
-    if (opts.type === "get" && opts.getMode === "all") {
-        patchGetAll(paths, naming, method, goModule);
-    }
-    else if (opts.type === "get") {
-        if (!opts.field)
-            throw new Error("--field is required for --type get --get-mode one");
-        if (opts.field.toLowerCase() === "id") {
-            throw new Error('--field cannot be "id" — GET /:id already exists as the default lookup');
-        }
-        patchGetOne(paths, naming, method, opts.field, goModule);
-    }
-    else if (opts.type === "post") {
-        patchPost(paths, naming, method, goModule);
-    }
-    else if (opts.type === "put" || opts.type === "patch") {
-        patchResourceAction(paths, method, opts.type, goModule, naming.pkg);
-    }
-    else {
-        patchDelete(paths, method, goModule, naming.pkg);
-    }
-    ensureNonCqrsServiceImports(paths, goModule);
-    patchHandlerServiceInterface(paths, 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;
-    if (opts.type === "get" && opts.getMode === "all") {
-        signature = `${method.pascalName}(context.Context, int, int) ([]model.${naming.pascalName}, error)`;
-    }
-    else if (opts.type === "get") {
-        signature = `${method.pascalName}(context.Context, string) (*model.${naming.pascalName}, error)`;
-    }
-    else if (opts.type === "post") {
-        signature = `${method.pascalName}(context.Context, ${method.pascalName}Input) (*model.${naming.pascalName}, error)`;
-    }
-    else if (opts.type === "put" || opts.type === "patch") {
-        signature = `${method.pascalName}(context.Context, uuid.UUID) error`;
-        needsModel = false;
-        needsUUID = true;
-    }
-    else {
-        signature = `${method.pascalName}(context.Context, uuid.UUID) error`;
-        needsModel = false;
-        needsUUID = true;
-    }
-    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
-        // is no interface declaration to patch and no migration is required.
-        if (handler.includes("svc *Service"))
-            return;
-        throw new Error(`marker "${SERVICE_INTERFACE_MARKER}" not found and Handler does not use legacy *Service wiring`);
-    }
-    handler = (0, marker_patch_1.insertBeforeMarker)(handler, SERVICE_INTERFACE_MARKER, signature);
-    handler = (0, marker_patch_1.ensureImport)(handler, "context");
-    if (needsModel) {
-        handler = (0, marker_patch_1.ensureImport)(handler, `${goModule}/internal/app/${naming.pkg}/model`);
-    }
-    if (needsUUID) {
-        handler = (0, marker_patch_1.ensureImport)(handler, "github.com/google/uuid");
-    }
-    fs_extra_1.default.writeFileSync(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");
-    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 := ${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`,
-        `\t}`,
-        `\tout := make([]response, len(items))`,
-        `\tfor i := range items {`,
-        `\t\tout[i] = toResponse(&items[i])`,
-        `\t}`,
-        `\tc.JSON(http.StatusOK, p.Response(out))`,
-        `}`,
-        ``,
-    ].join("\n"));
-    writeHandler(paths.handlerPath, handler, goModule, ["net/http", "pagination"]);
-    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 := h.repo.FindAll(ctx, limit, offset)`,
-        `\tif err != nil {`,
-        `\t\treturn nil, apperror.NewInternal(err)`,
-        `\t}`,
-        `\treturn items, nil`,
-        `}`,
-        ``,
-    ].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);
-    const fieldPascal = (0, naming_1.toPascalCase)(rawField);
-    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 = 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`,
-        `\t// compiles against any table and only fails when it runs.`,
-        `\t//`,
-        `\t// tx.From, like every other method here: a lookup that reached for r.db`,
-        `\t// directly would read outside a transaction its caller had opened, and`,
-        `\t// so miss that transaction's own uncommitted writes.`,
-        `\tif err := tx.From(ctx, r.db).WithContext(ctx).First(&m, "${fieldColumn} = ?", ${fieldParam}).Error; err != nil {`,
-        `\t\treturn nil, err`,
-        `\t}`,
-        `\treturn &m, nil`,
-        `}`,
-        ``,
-    ].join("\n"));
-    fs_extra_1.default.writeFileSync(paths.repositoryPath, repo);
-    let service = fs_extra_1.default.readFileSync(paths.servicePath, "utf8");
-    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
-    // old fakeRepo marker and error behavior.
-    let serviceTest = fs_extra_1.default.readFileSync(paths.serviceTestPath, "utf8");
-    if ((0, marker_patch_1.hasMarker)(serviceTest, REPOSITORY_STUB_FIELDS_MARKER) &&
-        (0, marker_patch_1.hasMarker)(serviceTest, REPOSITORY_STUB_METHODS_MARKER)) {
-        serviceTest = (0, marker_patch_1.insertBeforeMarker)(serviceTest, REPOSITORY_STUB_FIELDS_MARKER, `findBy${fieldPascal}Fn func(context.Context, string) (*model.${naming.pascalName}, error)`);
-        serviceTest = (0, marker_patch_1.insertBeforeMarker)(serviceTest, REPOSITORY_STUB_METHODS_MARKER, [
-            `//nolint:unused`,
-            `func (s *repositoryStub) FindBy${fieldPascal}(ctx context.Context, value string) (*model.${naming.pascalName}, error) {`,
-            `\tif s.findBy${fieldPascal}Fn == nil {`,
-            `\t\tpanic("unexpected repository.FindBy${fieldPascal} call")`,
-            `\t}`,
-            `\treturn s.findBy${fieldPascal}Fn(ctx, value)`,
-            `}`,
-            ``,
-        ].join("\n"));
-    }
-    else if ((0, marker_patch_1.hasMarker)(serviceTest, 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`,
-            `func (f *fakeRepo) FindBy${fieldPascal}(context.Context, string) (*model.${naming.pascalName}, error) {`,
-            `\tif f.err != nil {`,
-            `\t\treturn nil, f.err`,
-            `\t}`,
-            `\treturn f.m, nil`,
-            `}`,
-            ``,
-        ].join("\n"));
-    }
-    else {
-        throw new Error(`neither current repository stub markers nor legacy "${LEGACY_FAKE_REPO_METHODS_MARKER}" found in ${paths.serviceTestPath}`);
-    }
-    fs_extra_1.default.writeFileSync(paths.serviceTestPath, serviceTest);
-    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");
-    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");
-    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 := ${isCqrs(paths) ? `h.queries.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), ${fieldParam})`,
-        `\tif err != nil {`,
-        `\t\tc.Error(err)`,
-        `\t\treturn`,
-        `\t}`,
-        `\tc.JSON(http.StatusOK, toResponse(m))`,
-        `}`,
-        ``,
-    ].join("\n"));
-    writeHandler(paths.handlerPath, handler, goModule, ["net/http"]);
-}
-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 = 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");
-    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 := ${isCqrs(paths) ? `h.commands.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), in)`,
-        `\tif err != nil {`,
-        `\t\tc.Error(err)`,
-        `\t\treturn`,
-        `\t}`,
-        `\tc.JSON(http.StatusCreated, toResponse(m))`,
-        `}`,
-        ``,
-    ].join("\n"));
-    writeHandler(paths.handlerPath, handler, goModule, ["net/http", "httpx"]);
-    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");
-    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, method, type, goModule, modulePath) {
-    let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
-    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}`,
-        `\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.Status(http.StatusNotImplemented)`,
-        `}`,
-        ``,
-    ].join("\n"));
-    writeHandler(paths.handlerPath, handler, goModule, ["net/http", "httpx"]);
-    const commandMethod = [
-        `func (h *CommandHandler) ${method.pascalName}(ctx context.Context, id uuid.UUID) error {`,
-        `\t_ = ctx`,
-        `\t_ = id`,
-        `\treturn apperror.NewNotImplemented()`,
-        `}`,
-        ``,
-    ].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, modulePath) {
-    let handler = fs_extra_1.default.readFileSync(paths.handlerPath, "utf8");
-    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 := ${isCqrs(paths) ? `h.commands.${method.pascalName}` : `h.svc.${method.pascalName}`}(c.Request.Context(), id); err != nil {`,
-        `\t\tc.Error(err)`,
-        `\t\treturn`,
-        `\t}`,
-        `\tc.Status(http.StatusNoContent)`,
-        `}`,
-        ``,
-    ].join("\n"));
-    writeHandler(paths.handlerPath, handler, goModule, ["net/http", "httpx"]);
-    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");
-    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) {
-    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")) &&
-        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/templates/add/auth/internal/app/user/contracts.go.hbs

@@ -1,88 +0,0 @@
-package user
-
-import (
-	"context"
-	"time"
-
-	"{{goModule}}/internal/app/user/application"
-
-	"github.com/google/uuid"
-)
-
-// Dependencies is the explicit composition contract for the auth application.
-// Each port represents one lifecycle or capability, so a new adapter does not
-// have to implement unrelated token operations just to be wired in.
-type Dependencies struct {
-	Repository        UserRepository
-	RefreshTokens     RefreshTokenStore
-	OAuthTransactions OAuthTransactionStore
-	RecoveryTokens    RecoveryTokenStore
-	MFA               MFAStore
-	Mailer            AuthMailer
-	Providers         ProviderRegistry
-	Roles             RoleChecker
-	Clock             func() time.Time
-}
-
-// MFASettings is the operator-side MFA policy. Enabled is a capability
-// switch; each user's enrollment is still disabled until that user confirms a
-// TOTP code. Keeping both switches lets an operator turn the feature off
-// without deleting user enrollments.
-type MFASettings struct {
-	Enabled           bool
-	Issuer            string
-	EncryptionKey     string
-	ChallengeTTL      time.Duration
-	TOTPWindow        int
-	RecoveryCodeCount int
-}
-
-// AuthConfig contains only auth policy. The application layer intentionally
-// does not depend on the generated project's shared config package.
-type AuthConfig struct {
-	JWTSecret         string
-	JWTAccessTTL      time.Duration
-	JWTRefreshTTL     time.Duration
-	JWTRefreshMaxTTL  time.Duration
-	OAuthStateTTL     time.Duration
-	PasswordResetTTL  time.Duration
-	PasswordResetURL  string
-	EmailVerifyTTL    time.Duration
-	EmailVerifyURL    string
-	MFA               MFASettings
-}
-
-// ProviderRegistry is the application-facing lookup port for external login
-// providers. The concrete registry lives in the application package; callers
-// may supply a test double or another registry without coupling Service to
-// that implementation.
-type ProviderRegistry interface {
-	Lookup(name string) (application.LoginProvider, bool)
-}
-
-// MFAEnrollment is the storage-neutral representation returned by MFAStore.
-// The secret is always encrypted at rest; it is never serialized by an API
-// response.
-type MFAEnrollment struct {
-	EncryptedSecret string
-	Enabled         bool
-}
-
-// MFAChallenge is a short-lived, one-use pre-session challenge. The raw
-// challenge is returned only to the client; stores receive its hash.
-type MFAChallenge struct {
-	UserID    uuid.UUID
-	ExpiresAt time.Time
-}
-
-// MFAStore owns durable MFA state. Implementations must make challenge and
-// recovery-code consumption atomic so concurrent requests cannot reuse them.
-type MFAStore interface {
-	GetEnrollment(ctx context.Context, userID uuid.UUID) (MFAEnrollment, bool, error)
-	PutPendingEnrollment(ctx context.Context, userID uuid.UUID, encryptedSecret string) error
-	ConfirmEnrollment(ctx context.Context, userID uuid.UUID, encryptedSecret string, recoveryCodeHashes []string) error
-	Disable(ctx context.Context, userID uuid.UUID) error
-	CreateChallenge(ctx context.Context, hash string, challenge MFAChallenge) error
-	ConsumeChallenge(ctx context.Context, hash string) (MFAChallenge, bool, error)
-	ConsumeRecoveryCode(ctx context.Context, userID uuid.UUID, hash string) (bool, error)
-}