@nakedev/go-scaffold 0.4.0 → 0.5.0

package/templates/generate/module/hexagonal/application/service.go.hbs

@@ -0,0 +1,29 @@
+package application
+
+import (
+	"context"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+	"{{goModule}}/internal/app/{{modulePath}}/ports"
+)
+
+// ServicePort is the inbound application port used by the HTTP adapter.
+type ServicePort interface {
+	// go-scaffold:service-interface
+}
+
+// Service orchestrates {{pkg}} use cases and depends only on ports.
+type Service struct {
+	repo ports.Repository
+}
+
+func NewService(repo ports.Repository) *Service {
+	return &Service{repo: repo}
+}
+
+// Keep these imports and the port visible in a lean module before its first
+// method is generated. Methods are added to this file by `generate method`.
+var _ context.Context
+var _ *domain.{{pascalName}}
+
+// go-scaffold:service-methods

package/templates/generate/module/hexagonal/application/service_test.go.hbs

@@ -0,0 +1,62 @@
+package application
+
+import (
+	"context"
+	"testing"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+
+	"github.com/google/uuid"
+)
+
+// repositoryStub exposes one function per dependency operation. Focused
+// application tests can configure only the calls they expect; an unexpected
+// call panics instead of silently returning a zero value that hides broken
+// orchestration.
+type repositoryStub struct {
+	createFn   func(context.Context, *domain.{{pascalName}}) error
+	findAllFn  func(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	findByIDFn func(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	updateFn   func(context.Context, *domain.{{pascalName}}) error
+	deleteFn   func(context.Context, uuid.UUID) error
+	// go-scaffold:repository-stub-fields
+}
+
+func (s *repositoryStub) Create(ctx context.Context, m *domain.{{pascalName}}) error {
+	if s.createFn == nil {
+		panic("unexpected repository.Create call")
+	}
+	return s.createFn(ctx, m)
+}
+func (s *repositoryStub) FindAll(ctx context.Context, limit, offset int) ([]domain.{{pascalName}}, error) {
+	if s.findAllFn == nil {
+		panic("unexpected repository.FindAll call")
+	}
+	return s.findAllFn(ctx, limit, offset)
+}
+func (s *repositoryStub) FindByID(ctx context.Context, id uuid.UUID) (*domain.{{pascalName}}, error) {
+	if s.findByIDFn == nil {
+		panic("unexpected repository.FindByID call")
+	}
+	return s.findByIDFn(ctx, id)
+}
+func (s *repositoryStub) Update(ctx context.Context, m *domain.{{pascalName}}) error {
+	if s.updateFn == nil {
+		panic("unexpected repository.Update call")
+	}
+	return s.updateFn(ctx, m)
+}
+func (s *repositoryStub) Delete(ctx context.Context, id uuid.UUID) error {
+	if s.deleteFn == nil {
+		panic("unexpected repository.Delete call")
+	}
+	return s.deleteFn(ctx, id)
+}
+
+func TestService_ComposesWithRepositoryPort(t *testing.T) {
+	if NewService(&repositoryStub{}) == nil {
+		t.Fatal("expected service")
+	}
+}
+
+// go-scaffold:repository-stub-methods

package/templates/generate/module/hexagonal/composition.go.hbs

@@ -0,0 +1,27 @@
+package {{pkg}}
+
+import (
+	httpadapter "{{goModule}}/internal/app/{{modulePath}}/adapters/inbound/http"
+	"{{goModule}}/internal/app/{{modulePath}}/adapters/outbound/postgres"
+	"{{goModule}}/internal/app/{{modulePath}}/application"
+{{#unless cqrs}}
+	"{{goModule}}/internal/app/{{modulePath}}/ports"
+{{/unless}}
+	"gorm.io/gorm"
+{{#if permission}}	"{{goModule}}/internal/shared/middleware"
+{{/if}}
+)
+
+// NewHandlerFromDB is this module's composition root. The process root owns
+// the database handle; this package owns the feature's adapter graph.
+func NewHandlerFromDB(db *gorm.DB{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *httpadapter.Handler {
+	repo := postgres.NewRepository(db)
+{{#if cqrs}}
+	commands := application.NewCommandHandler(repo)
+	queries := application.NewQueryHandler(repo)
+	return httpadapter.NewHandler(commands, queries{{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}})
+{{else}}
+	var service ports.Repository = repo
+	return httpadapter.NewHandler(application.NewService(service){{#if auth}}, jwtSecret{{/if}}{{#if permission}}, authz{{/if}})
+{{/if}}
+}

package/templates/generate/module/hexagonal/domain/entity.go.hbs

@@ -0,0 +1,20 @@
+// Package domain contains {{pkg}}'s business state and invariants. It does
+// not import Gin, GORM, SQL drivers, or HTTP concerns.
+package domain
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// {{pascalName}} is the domain entity. Persistence and transport models are
+// deliberately separate so a database column or JSON field cannot silently
+// become part of the business API.
+type {{pascalName}} struct {
+	ID        uuid.UUID
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	Version   int
+	// TODO: add business fields and invariants here.
+}

package/templates/generate/module/hexagonal/domain/errors.go.hbs

@@ -0,0 +1,11 @@
+package domain
+
+import "errors"
+
+var (
+	ErrNotFound      = errors.New("{{pkg}} not found")
+	ErrConflict      = errors.New("{{pkg}} conflicts with an existing record")
+	ErrStaleVersion  = errors.New("{{pkg}} was modified by someone else")
+	ErrHasReferences = errors.New("{{pkg}} still has related records")
+	ErrNotImplemented = errors.New("{{pkg}} operation is not implemented")
+)

package/templates/generate/module/hexagonal/ports/repository.go.hbs

@@ -0,0 +1,38 @@
+// Package ports declares the dependencies owned by the {{pkg}} application.
+// Adapters implement these interfaces; application code never imports a
+// database driver.
+package ports
+
+import (
+	"context"
+
+	"{{goModule}}/internal/app/{{modulePath}}/domain"
+
+	"github.com/google/uuid"
+)
+
+// Repository is the complete persistence port for service-style modules.
+type Repository interface {
+	Create(context.Context, *domain.{{pascalName}}) error
+	FindAll(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	FindByID(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	Update(context.Context, *domain.{{pascalName}}) error
+	Delete(context.Context, uuid.UUID) error
+	// go-scaffold:repository-interface
+}
+
+// CommandRepository and QueryRepository keep CQRS handlers honest: a write
+// use case cannot grow a read dependency by accident, and vice versa.
+type CommandRepository interface {
+	Create(context.Context, *domain.{{pascalName}}) error
+	FindByID(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	Update(context.Context, *domain.{{pascalName}}) error
+	Delete(context.Context, uuid.UUID) error
+	// go-scaffold:command-repository-interface
+}
+
+type QueryRepository interface {
+	FindAll(context.Context, int, int) ([]domain.{{pascalName}}, error)
+	FindByID(context.Context, uuid.UUID) (*domain.{{pascalName}}, error)
+	// go-scaffold:query-repository-interface
+}

package/templates/generate/module/migration.up.sql.hbs

@@ -1,4 +1,4 @@
--- one schema per domain — see model.go's TableName for why
+-- one schema per domain — see adapters/outbound/postgres/model.go's TableName for why
 CREATE SCHEMA IF NOT EXISTS {{schemaName}};
 
 CREATE TABLE {{schemaName}}.{{tableName}} (

package/dist/utils/method-patcher.js

@@ -1,357 +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;
-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 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 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";
-const LEGACY_FAKE_REPO_METHODS_MARKER = "// go-scaffold: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 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];
-}
-// 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, naming, method, opts.type, goModule);
-    }
-    else {
-        patchDelete(paths, method, goModule);
-    }
-    patchHandlerServiceInterface(paths.handlerPath, naming, method, opts, goModule);
-}
-function patchHandlerServiceInterface(handlerPath, 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) (*model.${naming.pascalName}, error)`;
-        needsUUID = true;
-    }
-    else {
-        signature = `${method.pascalName}(context.Context, uuid.UUID) error`;
-        needsModel = false;
-        needsUUID = true;
-    }
-    let handler = fs_extra_1.default.readFileSync(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(handlerPath, handler);
-}
-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, [
-        `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)`,
-        `\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"]);
-    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) {`,
-        `\t// TODO: add real filtering for "${method.name}" — currently reuses FindAll`,
-        `\titems, err := s.repo.FindAll(ctx, limit, offset)`,
-        `\tif err != nil {`,
-        `\t\treturn nil, apperror.NewInternal()`,
-        `\t}`,
-        `\treturn items, nil`,
-        `}`,
-        ``,
-    ].join("\n"));
-    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 = (0, marker_patch_1.insertBeforeMarker)(repo, 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");
-    service = (0, marker_patch_1.insertBeforeMarker)(service, 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, 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);
-    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})`,
-        `\tif err != nil {`,
-        `\t\treturn nil, wrapFindErr(err)`,
-        `\t}`,
-        `\treturn m, nil`,
-        `}`,
-        ``,
-    ].join("\n"));
-    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, [
-        `func (h *Handler) ${method.handlerName}(c *gin.Context) {`,
-        `\t${fieldParam} := c.Param("${fieldParam}")`,
-        `\tm, err := 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 = (0, marker_patch_1.insertBeforeMarker)(dto, 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, [
-        `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)`,
-        `\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"]);
-    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) {`,
-        `\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);
-}
-function patchResourceAction(paths, naming, method, type, goModule) {
-    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, [
-        `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 {`,
-        `\t\tc.Error(err)`,
-        `\t\treturn`,
-        `\t}`,
-        `\tc.JSON(http.StatusOK, toResponse(m))`,
-        `}`,
-        ``,
-    ].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`,
-        `}`,
-        ``,
-    ].join("\n"));
-    fs_extra_1.default.writeFileSync(paths.servicePath, service);
-}
-function patchDelete(paths, method, goModule) {
-    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, [
-        `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 {`,
-        `\t\tc.Error(err)`,
-        `\t\treturn`,
-        `\t}`,
-        `\tc.Status(http.StatusNoContent)`,
-        `}`,
-        ``,
-    ].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 {`,
-        `\t// TODO: implement "${method.name}" — this stub does nothing yet`,
-        `\treturn apperror.NewInternal()`,
-        `}`,
-        ``,
-    ].join("\n"));
-    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) &&
-        ((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));
-}

package/templates/add/auth/docs/google-callback.yaml.hbs

@@ -1,22 +0,0 @@
-get:
-  summary: Google OAuth callback
-  description: Redirect target Google sends the browser back to after consent — not called directly by API clients.
-  operationId: googleCallback
-  tags: [auth]
-  security: []
-  parameters:
-    - name: code
-      in: query
-      required: true
-      schema: { type: string }
-    - name: state
-      in: query
-      required: true
-      schema: { type: string }
-  responses:
-    "200":
-      description: ok, refresh_token set as an httpOnly cookie
-      content:
-        application/json:
-          schema: { $ref: './schemas.yaml#/AuthResponse' }
-    "401": { $ref: '../common/responses.yaml#/UnauthorizedError' }

package/templates/add/auth/docs/google-login.yaml.hbs

@@ -1,7 +0,0 @@
-get:
-  summary: Start the Google OAuth login flow
-  operationId: googleLogin
-  tags: [auth]
-  security: []
-  responses:
-    "302": { description: redirect to Google's consent screen }

package/templates/add/auth/internal/app/user/dto.go.hbs

@@ -1,77 +0,0 @@
-package user
-
-import (
-	"time"
-
-	"{{goModule}}/internal/app/user/model"
-
-	"github.com/google/uuid"
-)
-
-type registerInput struct {
-	Email    string `json:"email" binding:"required,email"`
-	Password string `json:"password" binding:"required,min=8"`
-	Name     string `json:"name" binding:"required"`
-}
-
-type loginInput struct {
-	Email    string `json:"email" binding:"required,email"`
-	Password string `json:"password" binding:"required"`
-}
-
-type forgotPasswordInput struct {
-	Email string `json:"email" binding:"required,email"`
-}
-
-type resetPasswordInput struct {
-	Token       string `json:"token" binding:"required"`
-	NewPassword string `json:"new_password" binding:"required,min=8"`
-}
-
-type verifyEmailInput struct {
-	Token string `json:"token" binding:"required"`
-}
-
-// authResponse is what the service returns internally (both tokens); the
-// handler sends the refresh token as an httpOnly cookie instead of echoing
-// it in the body, so meResponse never carries it — see toCookieResponse.
-type authResponse struct {
-	AccessToken  string `json:"access_token"`
-	RefreshToken string `json:"-"`
-	TokenType    string `json:"token_type"`
-	ExpiresIn    int    `json:"expires_in"`
-}
-
-type authCookieResponse struct {
-	AccessToken string `json:"access_token"`
-	TokenType   string `json:"token_type"`
-	ExpiresIn   int    `json:"expires_in"`
-}
-
-func toCookieResponse(a *authResponse) authCookieResponse {
-	return authCookieResponse{AccessToken: a.AccessToken, TokenType: a.TokenType, ExpiresIn: a.ExpiresIn}
-}
-
-type meResponse struct {
-	ID            uuid.UUID `json:"id"`
-	Email         string    `json:"email"`
-	Name          string    `json:"name"`
-	AvatarURL     string    `json:"avatar_url"`
-	EmailVerified bool      `json:"email_verified"`
-	// go-scaffold:user-me-fields
-	CreatedAt time.Time `json:"created_at"`
-}
-
-func toMeResponse(u *model.User) meResponse {
-	return meResponse{
-		ID:            u.ID,
-		Email:         u.Email,
-		Name:          u.Name,
-		AvatarURL:     u.AvatarURL,
-		EmailVerified: u.EmailVerified,
-		CreatedAt:     u.CreatedAt,
-		// go-scaffold:user-me-values
-	}
-}
-
-// go-scaffold:user-dto