The resource, and why it is the unit of generation

This is the idea the framework rests on. If you disagree with it, the rest of part four is wrong, so it gets a chapter of its own.

The claim

*A resource is the only thing that spans the whole stack, so it is the thing worth generating.* Not a file. Not a layer. The invoice, from the database column to the form field.

Consider what "add invoices to this application" actually requires:

• Database
• a table, columns, indexes, a foreign key
• Go
• a model, a service with the rules, a handler, routes
• Contract
• a validation schema, a TypeScript type
• Frontend
• a data hook, a list page, a form, a detail view

Thirteen or so files. A scaffolder that generates a model has automated the easy part, because the model was never the expensive bit. The expense is that one concept, "invoice", has to be spelled correctly in thirteen places, and kept correct as it changes.

One command

grit generate resource Invoice \
  --fields "number:string, total:money, due:date, client:belongs_to"

Four field types. One of them is a relationship. That is the entire input.

What it writes, by name:

apps/api/internal/models/invoice.go
apps/api/internal/services/invoice.go
apps/api/internal/services/invoice_import.go
apps/api/internal/handlers/invoice.go
apps/api/internal/handlers/invoice_import.go
apps/api/internal/handlers/invoice_test.go
apps/api/internal/policies/invoice.go
apps/api/internal/factory/invoice.go
packages/shared/schemas/invoice.ts
packages/shared/types/invoice.ts
apps/admin/app/_dashboard/resources/invoice/index.tsx

Plus the routes registered, the model added to the migration list, and the resource added to the admin's navigation.

Why one description is the point

The thirteen files are not the achievement. The achievement is that they come from one description, so they cannot disagree.

Add a field later:

grit generate field Invoice paid_at:datetime

That reaches the model, the migration, the Zod schema, the TypeScript type, the admin table and the admin form in one step. There is no version of this where the backend has paid_at and the frontend does not, because there is no second place to update.

That is the real answer to D3. Not "less typing": no drift.

A field type is a decision made once

Thirty one field types ship. The important ones are not the obvious ones.

string  text  richtext  int  uint  float  bool  toggle  select  radio
check  datetime  date  money  slug  belongs_to  one_to_one  many_to_many
string_array  file  files  email  url  domain  tel  country  color
percent  rating  time  json

Take money. Writing total:money decides a column type, a Go type, a Zod rule, an input mask and how the number is formatted in a table cell. Sayfloat instead and you have shipped a rounding bug that will surface in a total months later, found by an accountant.

// What money generates: an integer, in minor units.
Total money.Amount    // stored as cents, never a float64

This is the lesson from chapter nineteen, where you implemented MarshalJSONfor exactly this. The difference is that here it is a type rather than advice, so the correct decision is the default rather than something you must remember.

Take belongs_to. One word, and you get:

• a ClientID foreign key column, with a constraint
• a Client field on the struct, preloaded on read
• a nested type in the generated TypeScript
• a searchable dropdown in the admin form that shows the client's name rather than a UUID

It is still your code afterwards

Open the generated service. It is a struct with a *gorm.DB and methods, with comments explaining why rather than what:

// ContactService owns every database read and write for contacts.
//
// The handler reads the request, calls one of these and writes the
// answer. A job, a command or a test calls the same methods with no
// request at all, so a rule enforced here is enforced everywhere.
type ContactService struct {
    DB *gorm.DB
}

One dependency, and it is GORM. You can edit any of it. The generated code is the starting point, not a sealed artifact.

What it does not generate

Worth saying plainly, because the demo makes it look like magic.

It generates the shape. It does not generate the rule that an invoice cannot be billed twice, the report the client asks for every month, or the pricing logic that is the reason they hired you. That is still yours, it is still the hard part, and it is still where the value is.

What has gone is the two weeks before you got to any of it.

grit generate resource Book \
  --fields "title:string, isbn:string, price:money, published:date"
grit migrate
grit seed Book --count 500
grit start

grit generate field Book pages:int
grit migrate

Assignment

Commit your work with the message Resources - Assignment One, exactly as written, so the leaderboard can score it.

grit generate resource Site --fields "name:string, code:slug"