Getting started

Two ways to start with crouton: create a new project from scratch, or add crouton to an existing one.

@ghentcdh/create-crouton

Scaffold a complete crouton project — a NestJS backend with Prisma, pre-configured datasource, Docker Compose, and optionally an Nx monorepo layout with a Vue frontend.

npm create @ghentcdh/crouton my-app
# or
npx @ghentcdh/create-crouton my-app

Local development

To test a locally built version of the CLI:

# Build and link globally
pnpm nx build create-crouton
pnpm link ./packages/create-crouton --global

# Now use it anywhere
create-crouton my-test-app --prefix split

Or run directly without linking:

pnpm nx build create-crouton
node packages/create-crouton/dist/index.js my-test-app

Flags

Flag	Default	Description
--nx	prompt	Use Nx monorepo layout (backend + frontend + shared libs).
--no-frontend	—	Skip Vue frontend generation (Nx layout only).
--sample	—	Include a sample resource.
--pm <manager>	prompt	Package manager: pnpm, npm, yarn, or bun.
--no-install	—	Skip dependency installation.
--no-git	—	Skip git init.
--no-docker	—	Skip Docker files (Dockerfile, compose.yml).
--prefix <name>	prompt	Subfolder prefix for apps/config (e.g. split). Implies Nx layout.
--db-url <url>	prompt	Database connection URL.
-y, --yes	—	Accept all defaults (non-interactive).
--force	—	Overwrite existing files.

Layouts

Regular (single app)

A standalone NestJS backend — best for APIs, small projects, or when you already have a separate frontend.

my-app/
├── src/
│   ├── main.ts
│   ├── app.module.ts
│   ├── data-sources/default/
│   │   ├── data-source.json
│   │   └── index.ts
│   └── resources/          # generated by `crouton update resources`
├── prisma/default/
│   ├── schema.prisma
│   └── prisma.config.ts
├── crouton.json
├── crouton.enums.json
├── package.json
├── compose.yml
└── .env

Nx monorepo

A full-stack workspace with separate backend and frontend apps, shared generated types, and workspace-level tooling.

my-app/
├── apps/
│   ├── backend/
│   │   ├── src/
│   │   │   ├── main.ts
│   │   │   └── app/
│   │   │       ├── app.module.ts
│   │   │       ├── data-sources/default/
│   │   │       └── resources/
│   │   └── package.json
│   └── frontend/           # Vue + Vite (skipped with --no-frontend)
│       ├── src/
│       │   ├── main.ts
│       │   └── App.vue
│       └── package.json
├── generated/default/
│   ├── types/               # zod-prisma-types output
│   └── client/              # Prisma client output
├── prisma/default/
├── crouton.json
├── nx.json
├── pnpm-workspace.yaml
└── package.json

Nx monorepo with prefix

When using --prefix split, apps and generated code live under a subfolder. This is useful when the Nx workspace also contains non-crouton projects.

my-app/
├── split/
│   ├── apps/
│   │   ├── backend/
│   │   └── frontend/
│   ├── generated/default/
│   │   ├── types/
│   │   └── client/
│   ├── prisma/default/
│   └── crouton.json
├── nx.json
├── tsconfig.base.json
├── pnpm-workspace.yaml
└── package.json

What happens after scaffolding

The CLI runs these steps automatically (unless skipped via flags):

1. git init — initialises a repository with an initial commit.
2. <pm> install — installs all dependencies.
3. crouton update resources — introspects the database and generates resource CRUD (best-effort; warns on failure if DB is not running).

Then follow the printed next-steps:

docker compose up -d          # start postgres
pnpm prisma:migrate           # create initial migration
crouton update resources      # generate resource CRUD from your schema
pnpm dev                      # start dev server

When using a prefix, add the --prefix flag:

crouton update resources --prefix split

@ghentcdh/add-crouton

Add crouton to an existing NestJS project — regular or Nx. This command is additive: it never overwrites existing files.

npx @ghentcdh/add-crouton
# or from outside the project:
npx @ghentcdh/add-crouton --cwd /path/to/project

Flags

Flag	Default	Description
--cwd <dir>	.	Project directory.
--backend <app>	auto-detect	Backend app name (Nx only).
--frontend <app>	auto-detect	Frontend app name (Nx only).
--no-frontend	—	Skip frontend detection.
--pm <manager>	auto-detect	Package manager.
--no-install	—	Skip dependency installation.
--no-docker	—	Skip Docker file generation.
-y, --yes	—	Accept all defaults (non-interactive).

What it does

1. Detects project type — checks for ../../../nx.json to distinguish Nx workspaces from regular projects.
2. Discovers apps (Nx only) — scans apps/ subdirs, classifies them as backend (@nestjs/core in deps) or frontend (vue/vite in deps), and prompts which to use.
3. Detects package manager — from lockfile presence (pnpm-lock.yaml, package-lock.json, yarn.lock, bun.lockb).
4. Scans dependencies — reports missing backend deps (@ghentcdh/crouton-api, @ghentcdh/crouton-core, prisma, etc.).
5. Writes config files (if absent):
   • crouton.json — with detected resourcesDir and dataSourcesDir
   • crouton.enums.json — empty enum registry
   • data-sources/default/ — default datasource with Prisma schema and config
   • .env.example — with DATABASE_URL placeholder
6. Installs dependencies — runs <pm> install if missing deps were detected.

After running @ghentcdh/add-crouton, wire CroutonApiModule into your NestJS app module — see Backend setup.