Code Generator Mastery

What is Code Generation?

Every feature in a web app needs the same set of files: a database model to store data, a service for business logic, a handler for HTTP endpoints, validation schemas, TypeScript types, and React pages for the admin panel.

Instead of manually creating all of these files for every feature — which is tedious and error-prone — the Grit code generator creates all of them from one command. You describe your data (a "Book" with a title, author, and page count), and Grit writes every file, wires up every route, and registers everything in the admin panel automatically.

Your First Resource

Let's generate a Book resource. Open your terminal in the project root and run:

grit generate resource Book --fields "title:string,author:string,pages:int,published:bool"

Let's break down each part of this command:

• • grit generate resource — the command that triggers the code generator
• • Book — the resource name, always in PascalCase and singular (Book, not Books)
• • --fields — inline field definitions, a comma-separated list
• • title:string — a field definition: field name : field type

Generated Files

That single command creates all of these files:

apps/api/internal/models/book.go          # Go model (database table)
apps/api/internal/services/book_service.go # Business logic (CRUD operations)
apps/api/internal/handlers/book_handler.go # HTTP endpoints (REST API)
packages/shared/schemas/book.ts            # Zod validation schema
packages/shared/types/book.ts              # TypeScript type definitions
apps/admin/app/(dashboard)/books/page.tsx  # Admin page with DataTable

It also injects code into existing files:

• • routes.go — registers all Book API routes (/api/books, /api/books/:id)
• • database.go — adds Book to the auto-migration list
• • main.go — initializes the Book service and handler

Understanding the Generated Go Model

Open apps/api/internal/models/book.go. You will see something like this:

package models

import "gorm.io/gorm"

type Book struct {
    gorm.Model
    Title     string `gorm:"not null" json:"title"`
    Author    string `gorm:"not null" json:"author"`
    Pages     int    `gorm:"not null" json:"pages"`
    Published bool   `gorm:"default:false" json:"published"`
}

Explained

• • gorm.Model gives you four fields for free: ID (primary key), CreatedAt, UpdatedAt, and DeletedAt (for soft deletes)
• • gorm:"not null" means the database requires this field — it cannot be empty
• • json:"title" controls how the field appears in API responses (lowercase, matching JavaScript conventions)
• • The struct name Book becomes the database table books (GORM automatically pluralizes and lowercases it)
• • gorm:"default:false" on the Published field means new books are unpublished by default

Field Types

Grit supports 13 field types. Each type maps to a Go type, a TypeScript type, and a database column type. Here is the complete reference:

Generate with Different Fields

Let's see progressively more complex examples to build your intuition.

Example 1: Simple Blog Post

grit generate resource Post --fields "title:string,content:richtext,published:bool"

This generates a Post with a short title, a rich text editor for the content (with bold, italic, headings, links, etc.), and a boolean toggle for published/draft status.

Example 2: Product with Price

grit generate resource Product --fields "name:string,description:text,price:float,stock:int,active:bool"

Notice how description uses text (plain long text) instead of richtext — product descriptions usually don't need a rich text editor. The price uses float for decimal values, and stock uses int for whole numbers.

Example 3: Event with Dates

grit generate resource Event --fields "name:string,description:text,start_date:datetime,end_date:datetime,capacity:int"

Events use datetime for start and end times. The admin form will show a date-time picker for these fields. The capacity field uses int for the maximum number of attendees.

Field Modifiers

Modifiers let you customize how a field behaves. You add them after the field type, separated by a colon.

:unique — No Duplicates

Adding :unique creates a unique index on the database column, so no two records can have the same value for that field.

grit generate resource Category --fields "name:string:unique,description:text:optional"

With name:string:unique, if you try to create two categories both named "Technology", the database will reject the second one with a unique constraint error.

:optional — Nullable Fields

By default, all fields are required (NOT NULL in the database). Adding :optional allows the field to be empty (NULL).

In the example above, description:text:optional means a category can be created without a description. The name field is still required — every category must have a name.

Slug Fields

A slug is a URL-friendly version of a string. The title "My First Blog Post" becomes the slug my-first-blog-post. Slugs are used in URLs so visitors see /articles/my-first-blog-post instead of /articles/42.

The format is slug:slug:source_field — the third part tells Grit which field to generate the slug from:

grit generate resource Article --fields "title:string,slug:slug:title,content:richtext"

Here, slug:slug:title means: create a field called "slug", of type "slug", derived from the "title" field. When you create an Article with the title "Hello World", the slug is automatically set to hello-world.

If two articles have the same title, Grit appends a random suffix to keep the slug unique (e.g., hello-world-a3f2). Slugs always have a unique index in the database.

Relationships: belongs_to

Real apps have related data. A blog post belongs to a category. An order belongs to a customer. The belongs_to type creates a foreign key relationship between two resources.

The format is field_name:belongs_to:ParentModel:

# First, generate the parent resource
grit generate resource Category --fields "name:string:unique"

# Then generate the child with a belongs_to relationship
grit generate resource Post --fields "title:string,content:richtext,category_id:belongs_to:Category"

This creates:

• • A CategoryID uint field on the Post model
• • A foreign key index in the database
• • A dropdown select in the admin form to pick a category
• • The API automatically returns the related category data when fetching posts

Relationships: many_to_many

Sometimes, a single belongs_to is not enough. A blog post can have many tags, and a tag can belong to many posts. This is a many-to-many relationship.

The format is field_name:many_to_many:OtherModel:

# Generate the related resource first
grit generate resource Tag --fields "name:string:unique"

# Then generate with many_to_many
grit generate resource Post --fields "title:string,content:richtext,tag_ids:many_to_many:Tag"

In the admin form, the tag_ids field renders as a multi-select — you can pick multiple tags for a single post. Behind the scenes, GORM manages the junction table automatically.

Interactive Mode

Typing all fields on one long command line can be tedious, especially for resources with many fields. Grit offers two alternatives.

Interactive Prompts (-i)

Use the -i flag for a step-by-step interactive experience:

grit generate resource Product -i

Grit will prompt you to add fields one at a time, asking for the field name, type, and any modifiers. Type "done" when you have added all your fields.

YAML Definition (--from)

For complex resources, you can define fields in a YAML file:

name: Product
fields:
  - name: string
  - description: text:optional
  - price: float
  - active: bool

grit generate resource Product --from product.yaml

YAML files are great for resources you plan to regenerate or share with your team.

Removing a Resource

Made a mistake? Want to start over? The grit remove resource command cleanly removes everything:

grit remove resource Book

This deletes all generated files (model, service, handler, schemas, types, admin page) AND reverses all code injections (imports, route registrations, database migrations, admin entries).

Your project returns to exactly how it was before you ran grit generate resource Book.

Type Sync

Sometimes you need to manually edit a Go model — add a field, change a type, tweak a tag. When you do, the TypeScript types and Zod schemas become out of date. That's where grit sync comes in.

grit sync

This command reads all your Go models, parses their struct fields and tags, and regenerates the matching TypeScript interfaces and Zod validation schemas. Your frontend types stay perfectly in sync with your backend models.

Code Markers

You might wonder: how does Grit know where to inject code into existing files? The answer is code markers — special comments placed in your scaffolded files.

// ... existing routes ...

bookGroup := api.Group("/books")
bookGroup.GET("", handler.BookHandler.GetAll)
bookGroup.POST("", handler.BookHandler.Create)
// grit:routes

The markers look like // grit:routes, // grit:models, and // grit:imports. When you generate a resource, Grit finds these markers and inserts code right before them. When you remove a resource, Grit deletes those injected lines.

The markers are invisible to your app (they're just comments), but they are essential for the code generator to work correctly.

Summary

You now have a complete understanding of Grit's code generator. Here's what you learned:

• Code generation basics — one command creates model, service, handler, schemas, types, and admin page
• Go model structure — gorm.Model, struct tags, field types, and how they map to database columns
• All 13 field types — string, text, richtext, int, uint, float, bool, datetime, date, slug, belongs_to, many_to_many, string_array
• Field modifiers — :unique for no duplicates, :optional for nullable fields
• Slug fields — auto-generated URL-friendly strings from a source field
• belongs_to relationships — foreign keys with dropdown selects in the admin
• many_to_many relationships — junction tables with multi-select in the admin
• Interactive mode and YAML — alternative ways to define fields
• Removing resources — clean removal of all generated files and injections
• Type sync — keeping Go and TypeScript types in sync with grit sync
• Code markers — how Grit knows where to inject and remove code