Code Generators

The velox make command scaffolds common code patterns for a single model at a time.

Multiple models? Use velox sync

If you have multiple Prisma models and want schemas + procedures for all of them at once, use velox sync instead. velox make is best for adding a single new model to an existing project.

Available Generators

Generator	Alias	Description
namespace	ns	Schema + procedures from existing Prisma model
resource	r, res	Full resource stack (Prisma model + schema + procedures + tests)
procedure	p, proc	Procedure files
schema	s, zod	Zod schemas
migration	mig	Prisma migrations
model	m	Full model setup
test	t, spec	Test files

Namespace (Single Model)

The fastest way to scaffold procedures for a single existing Prisma model:

1. Define your Prisma model
2. Run velox make namespace

The generator reads your Prisma schema, detects relations, and scaffolds type-safe procedures with the correct include clauses automatically.

Step 1: Define the Prisma Model

prisma/schema.prisma

model Order {
  id        String   @id @default(uuid())
  total     Float
  status    String   @default("pending")
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  customer  Customer @relation(fields: [customerId], references: [id])
  customerId String
  items     OrderItem[]

  @@map("orders")
}

Push the schema to your database:

pnpm db:push

Step 2: Generate the Namespace

velox make namespace Order --example

This creates three files and auto-registers the procedures in your router:

Created:
  src/schemas/order.ts           # Zod schemas (Create, Update, base)
  src/procedures/orders.ts       # CRUD procedures with Prisma queries
  src/procedures/__tests__/orders.test.ts

Modified:
  src/index.ts                   # Auto-registered orderProcedures

Because the generator detected the customer (belongsTo) and items (hasMany) relations in your Prisma schema, the generated queries include them automatically:

// Generated procedures include detected relations
getOrder: procedure()
  .input(z.object({ id: z.string().uuid() }))
  .query(async ({ input, ctx }) => {
    return ctx.db.order.findUnique({
      where: { id: input.id },
      include: { customer: true, items: true },
    });
  }),

Options

Option	Short	Description
--example	-e	Include example CRUD procedures (recommended)
--with-tests	-t	Generate test file (default: true)
--skip-registration	-S	Skip auto-registering in router.ts

Without --example

Running without --example creates a minimal scaffold with commented-out procedure examples, ready for you to fill in:

velox make namespace Order

namespace vs resource

Use namespace when you already have a Prisma model and need procedures for it. Use resource when starting from scratch — it creates the Prisma model, schema, procedures, and tests all at once.

Resource (Full Stack)

Creates everything from scratch: Prisma model, Zod schema, procedures, and tests.

velox make resource Product

Creates: model, schema, procedures, and tests.

Procedure

velox make procedure users
velox make procedure posts --crud

Schema

velox make schema User
velox make schema Post --crud

Migration

velox make migration create_users_table
velox make migration add_email_to_users

Common Options

Option	Description
--crud	Include CRUD operations
--soft-delete	Add deletedAt field
--pagination	Add paginated list
--dry-run	Preview without writing
--json	Machine-readable output

Output

velox make procedure users --crud

Created: src/procedures/users.ts
  - listUsers (GET /api/users)
  - getUser (GET /api/users/:id)
  - createUser (POST /api/users)
  - updateUser (PUT /api/users/:id)
  - deleteUser (DELETE /api/users/:id)

Related Content

• Database Commands - Migrations
• Procedures - Procedure API
• Nested Relations - Auto-detected relation projection