Generate the application

Two ways in: the CLI, which is what you will use once you trust the model, and the browser designer, which is better the first time because it renders the ERD, validates as you type and keeps versions. Both call the same pipeline, so both produce the same application.

Path A — the command line

1. Check the model

   Optional, because the generator runs the checker itself, but it is instant and it tells you the truth before anything is written.

   shell

   bun language/checker.ts language/examples/crm.eml.mmd
   # crm.eml.mmd  0 errors · 0 warnings

2. Generate

   One command. --no-setup keeps it from installing and migrating straight away, which you want the first time so you can look at what it produced.

   shell

   bun packages/generator/src/cli/generate.ts generate \
     --input language/examples/crm.eml.mmd \
     --output generated-projects/crm \
     --name crm \
     --port 4001 --frontend-port 4000 \
     --records-per-entity 25 \
     --force --no-setup

   It prints what it found as it goes: entities and their attribute counts, then the rules, hooks, sagas, state machines and categories it compiled. Read that list — it is the fastest way to notice a directive that did not parse.

3. Point it at a database

   shell

   cd generated-projects/crm
   cp backend/.env.example backend/.env
   # edit backend/.env:
   # DATABASE_URL=postgresql://postgres:postgres@127.0.0.1:5432/crm

   The generated .env.example guesses a local socket connection for your machine. It is a guess; the URL is the one line worth checking by hand.

4. Install, migrate, seed

   shell

   bun install
   bun run db:setup   # migrations, then every seed in order

   The seeds run in a deliberate order: users and roles, then reference types and your model's enums, then the dictionary (tables, columns, windows, tabs, fields), then categories, then sample business data, then rule definitions, then workflow definitions. The last two are the model's rules and workflows arriving in the database.

5. Run it

   shell

   bun run dev   # backend :4001, frontend :4000

   Sign in with the admin user the backend creates on first start — ADMIN_EMAIL and ADMIN_PASSWORD in backend/.env, admin@admin.com / admin by default.

Path B — the browser

The generator ships as an application in its own right. Run bun run dev at the repository root and open localhost:3000. It walks a project through six steps: define, discover, logic, generate, enhance, deploy.

Validate renders the diagram through the same normalizer the preview uses and reports the result: the entity count when it parses, and Mermaid's own error with a line number and caret when it does not.

What lands on disk

crm/
├── backend/                 # NestJS + Fastify + Kysely
│   ├── migrations/          # bus_ tables, sys_ dictionary, indexes
│   ├── seeds/               # users, references + your enums, dictionary,
│   │                        #   categories, sample data, rules, workflows
│   └── src/modules/
│       ├── bus/             # generic CRUD over every business entity
│       ├── sys/             # the Application Dictionary API
│       ├── rules/           # GoRules evaluation
│       ├── workflow/        # the step executor
│       ├── hooks/handlers/  # ⭐ your hook bodies live here, never overwritten
│       ├── audit/           # append-only change log
│       └── auth/            # sessions, roles, permissions
├── frontend/                # TanStack Start + React 19 (198 files)
│   └── src/
│       ├── routes/          # one screen per entity, plus /admin/*
│       ├── components/      # dynamic table, dynamic form, admin shells
│       └── hooks/           # entity, field and lookup queries
├── tests/                   # generated bun:test end-to-end suite (77 files)
├── model/                   # the .mmd this was generated from, shipped along
├── docker/ · Dockerfile · docker-compose.yml
└── .github/workflows/       # CI for both halves

Regenerating safely

You will regenerate constantly — the model changes, the application follows. The rules about what survives are simple and worth knowing before you start editing generated code.