gofasta g rename

Cross-file rename of a single field on a resource. Patches:

app/models/<snake>.model.go — struct field + GORM column tag
app/dtos/<snake>.dtos.go — every DTO that uses the field
app/services/<snake>.service.go — receiver-method field references
app/services/<snake>.service_test.go — same
app/repositories/<snake>.repository.go — same
db/migrations/NNNNNN_rename_<old>_to_<new>_on_<plural>.up.sql / .down.sql

Runs in preview mode by default. Every changed file is recorded as a planned patch and nothing is written to disk — pass --apply to commit. This is on purpose: cross-file string surgery is inherently riskier than a single-file patch, and the user should see exactly what’s about to land before it does.

Usage


gofasta g rename <Resource>.<OldField> <NewField> [--apply]

The first argument carries the resource + old field separated by .. The second is the new field name (PascalCase).

Flags

Flag	Default	Description
`--apply`	`false`	Actually write the rename to disk. Without this flag the command runs in preview mode and emits a `{actions: [...]}` plan via stdout (or the planner’s JSON envelope under `--json`).

Examples

Preview (default)


gofasta g rename Order.Total AmountCents

Output:


plan:
  patch  app/models/order.model.go               — rename Order.Total → AmountCents
  patch  app/dtos/order.dtos.go                  — rename Order.Total → AmountCents
  patch  app/services/order.service.go           — rename Order.Total → AmountCents
  patch  app/services/order.service_test.go      — rename Order.Total → AmountCents
  patch  app/repositories/order.repository.go    — rename Order.Total → AmountCents
  create db/migrations/000007_rename_total_to_amount_cents_on_orders.up.sql
  create db/migrations/000007_rename_total_to_amount_cents_on_orders.down.sql

No files written. Re-run with --apply to commit.

Apply


gofasta g rename Order.Total AmountCents --apply

Same actions, this time the patches and creates land on disk.

JSON plan


gofasta g rename Order.Total AmountCents --json

Emits the planner’s structured envelope:


{
  "actions": [
    {"kind": "patch", "path": "app/models/order.model.go", "detail": "rename Order.Total → AmountCents"},
    {"kind": "create", "path": "db/migrations/000007_rename_total_to_amount_cents_on_orders.up.sql"}
  ]
}

Substitution rules

The rewrite is token-aware (regex with word boundaries) so Total inside TotalCount won’t be accidentally rewritten. Per file, four substitutions run in order:

Pattern	Replacement	Example
`\bOldField\b`	`NewField`	`order.Total` → `order.AmountCents`
`column:OldSnake\b` (GORM tag)	`column:NewSnake`	`column:total` → `column:amount_cents`
`json:"OldCamel"`	`json:"NewCamel"`	`json:"total"` → `json:"amountCents"`
`json:"OldSnake"`	`json:"NewSnake"`	`json:"total"` → `json:"amount_cents"`

The two json: rules are independent — whichever case style your DTOs use (snake or camel), the rename catches it. Other phrasings (Total inside a comment, in a SQL string, in an unrelated identifier like Subtotal) are left alone.

Migration emitted

For both modes:


-- db/migrations/NNNNNN_rename_total_to_amount_cents_on_orders.up.sql
ALTER TABLE orders RENAME COLUMN total TO amount_cents;


-- db/migrations/NNNNNN_rename_total_to_amount_cents_on_orders.down.sql
ALTER TABLE orders RENAME COLUMN amount_cents TO total;

NNNNNN is the next available 6-digit version.

Caveats

The substitution is text-based, not type-aware. A reference to Total in a different package’s struct of the same name would also be matched if that file lived under the resource’s expected paths — unlikely, but worth knowing. The token-boundary rule keeps false positives low.
No revert built in. If you apply a rename and then want to undo it, run the rename in reverse (gofasta g rename Order.AmountCents Total --apply) or git checkout the changed files.
Tests adjust automatically. The _test.go file is in the targets list, so any order.Total in tests is rewritten alongside the impl.

Error codes

Code	When
`INVALID_NAME`	First arg doesn’t match `Resource.OldField`, or old + new are the same, or any of the three is empty.
`FILE_IO`	A write failed in `--apply` mode (e.g. the file is read-only).

gofasta g scaffold
Generate a complete CRUD resource with all layers including model, repository, service, controller, routes, DTOs, migration, and DI provider.
gofasta g model
Generate a GORM database model with typed fields and a corresponding migration pair.
gofasta g repository
Generate a model, migration, repository interface, and repository implementation for database access.
gofasta g service
Generate a service interface and implementation containing business logic, plus every prerequisite layer (model, migration, repository, DTOs, Wire provider).
gofasta g controller
Generate a REST controller (with CRUD handlers) plus every prerequisite layer — model, migration, repository, service, DTOs, Wire provider, and routes.
gofasta g dto
Generate request and response Data Transfer Objects (DTOs) for a resource.
gofasta g migration
Generate a `.up.sql` / `.down.sql` migration pair under `db/migrations/` for a database table — with per-driver SQL flavor (postgres,...
gofasta g route
Generate a per-resource chi routes file under `app/rest/routes/` — the registration function (`<Resource>Routes(r chi.Router)`) that the index router mounts.
gofasta g resolver
Patch the GraphQL resolver root to add a service dependency for an existing resource — appends the service field, regenerates Wire...
gofasta g provider
Generate a Google Wire dependency-injection provider set for a resource — the small `wire.NewSet(...)` glue that ties the service,...
gofasta g method
Add a new method to an existing service interface + impl.
gofasta g repo-method
Add a method to an existing repository — the repository-layer twin of `g method`.
gofasta g field
Add a column to an existing resource.
gofasta g endpoint
Add a single REST endpoint to an existing resource — patches the controller (handler stub), routes file (chi registration), and...
gofasta g middleware
Wrap an existing chi route's handler with a middleware.
gofasta g relation
Add a GORM association between two resources — belongs_to, has_many, or has_one.
gofasta g job
Generate a scheduled background job that implements the scheduler.Job interface.
gofasta g task
Generate an asynq-backed async task — emits a `Task<Name>` constant, a `<Name>Payload` struct, a `Handle<Name>` handler, and an `Enqueue<Name>` helper.
gofasta g email-template
Generate an HTML email template with a matching Go template file under app/emails/templates/ and a registration entry so the pkg/mailer renderer can find it by name.
gofasta g mock
Generate a testify/mock implementation that satisfies a Go interface.
`gofasta xrefs`