@paljs/generator

For Learning & Prototyping Only

This generator is designed for learning, prototyping, and example projects. It exposes full Prisma operations through GraphQL without built-in authorization or input validation.

For production applications, use the @paljs/plugins package with PrismaSelect instead — it gives you optimized queries while you maintain full control over your API.

Introduction

A native Prisma generator that creates GraphQL schemas (Nexus), client-side .graphql files, typed helpers for PrismaSelect, and admin UI pages — all from a single prisma generate command.

Best for:

Learning how Prisma + GraphQL work together
Building proof-of-concept applications
Creating demo or example projects
Quickly scaffolding admin interfaces

Installation

Setup

1. Add the Generator to Your Schema

Add the paljs generator block to your schema.prisma:

prisma

generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}
 
generator paljs {
  provider = "paljs-generator"
  output   = "./generated/paljs"
}

2. Create a Configuration File

Create paljs.config.ts in the same directory as your schema.prisma:

typescript

import { defineConfig } from '@paljs/generator/config';
 
export default defineConfig({
  generateGraphQL: true,
  generateTypes: true,
  generateAdmin: {
    enabled: true,
    output: './admin',
    routerType: 'app',
  },
});

3. Run Generation

Generated Output

The generator produces the following directory structure inside your configured output path:

code

generated/paljs/
├── dmmf/
│   ├── dmmf.json          # Raw DMMF data
│   └── index.ts           # TypeScript export of DMMF
├── types/
│   └── index.ts           # ModelsObject type for PrismaSelect
├── nexus/
│   ├── User/
│   │   ├── type.ts        # Nexus objectType
│   │   ├── queries.ts     # findUnique, findFirst, findMany, findCount, aggregate
│   │   └── mutations.ts   # createOne, updateOne, upsertOne, deleteOne, updateMany, deleteMany
│   ├── Post/
│   │   └── ...
│   └── index.ts           # Combined exports
├── graphql/
│   ├── User/
│   │   ├── queries.graphql
│   │   └── mutations.graphql
│   └── Post/
│       └── ...
└── admin/
    ├── schema.json        # Admin schema definition
    └── pages/             # Generated admin pages

DMMF Writer

Outputs the Prisma DMMF (Data Model Meta Format) captured during generation. Useful for custom tooling or passing to PrismaSelect in Prisma 7 where Prisma.dmmf is no longer available.

typescript

import dmmf from './generated/paljs/dmmf';

Types Writer

Generates a ModelsObject type that provides full type safety for PrismaSelect:

typescript

import { PrismaSelect } from '@paljs/plugins';
import type { ModelsObject } from './generated/paljs/types';
 
// Fully typed — no more `any`
const select = new PrismaSelect<'User', ModelsObject>(info);
const users = await prisma.user.findMany(select.value);

Nexus Writer

Generates Nexus type definitions, queries, and mutations for each model:

typescript

import { makeSchema } from 'nexus';
import * as types from './generated/paljs/nexus';
 
const schema = makeSchema({
  types,
  outputs: {
    typegen: './generated/nexus-typegen.ts',
    schema: './generated/schema.graphql',
  },
});

GraphQL Client Writer

Generates .graphql files with fragments, queries, and mutations for client-side usage with Apollo Client or similar:

graphql

# generated/paljs/graphql/User/queries.graphql
fragment UserFields on User {
  id
  email
  name
  createdAt
}
 
query findUniqueUser($where: UserWhereUniqueInput!) {
  findUniqueUser(where: $where) {
    ...UserFields
  }
}
 
query findManyUser(
  $where: UserWhereInput
  $orderBy: [UserOrderByWithRelationInput!]
  $take: Int
  $skip: Int
) {
  findManyUser(where: $where, orderBy: $orderBy, take: $take, skip: $skip) {
    ...UserFields
  }
}

Admin Writer

Generates the admin schema and page files for use with @paljs/admin:

typescript

// Generated admin schema defines field visibility, ordering, and edit behavior
// Used by PrismaTable component for dynamic CRUD UI
import { PrismaTable } from '@paljs/admin';
 
export default function UsersPage() {
  return <PrismaTable model="User" />;
}

Configuration

See the full Configuration Reference for all options.

Minimal Config

typescript

import { defineConfig } from '@paljs/generator/config';
 
export default defineConfig({
  generateGraphQL: true,
});

Full Config Example

typescript

import { defineConfig } from '@paljs/generator/config';
 
export default defineConfig({
  // Generate Nexus types + client .graphql files
  generateGraphQL: {
    nexus: true,
    nexusOutput: './nexus',
    client: true,
    clientOutput: './graphql',
  },
 
  // Generate typed helpers for PrismaSelect
  generateTypes: true,
 
  // Generate admin UI
  generateAdmin: {
    enabled: true,
    output: './admin',
    routerType: 'app',
  },
 
  // Prisma client instance name in your code
  prismaName: 'prisma',
 
  // Global exclusions
  excludeFields: ['password'],
  excludeInputFields: ['createdAt', 'updatedAt'],
  excludeQueriesAndMutations: ['deleteMany', 'updateMany'],
 
  // Per-model configuration
  models: {
    AuditLog: { exclude: true },
    User: {
      excludeFields: ['internalNotes'],
      excludeQueriesAndMutations: ['deleteOne'],
    },
    Tag: { disableMutations: true },
  },
});

Boolean Shorthand

Both generateGraphQL and generateAdmin accept true as shorthand:

typescript

// These are equivalent:
defineConfig({ generateGraphQL: true })
defineConfig({ generateGraphQL: { nexus: true, nexusOutput: './nexus', client: false, clientOutput: './graphql' } })
 
// These are equivalent:
defineConfig({ generateAdmin: true })
defineConfig({ generateAdmin: { enabled: true, output: './admin', routerType: 'app' } })

Available Queries and Mutations

For each model, the generator creates:

Queries:

findUnique{Model} — Find a single record by unique field
findFirst{Model} — Find the first matching record
findMany{Model} — Find multiple records with filtering, sorting, pagination
findCount{Model} — Count matching records
aggregate{Model} — Aggregate operations (sum, avg, min, max)

Mutations:

createOne{Model} — Create a new record
updateOne{Model} — Update an existing record
upsertOne{Model} — Create or update a record
deleteOne{Model} — Delete a single record
updateMany{Model} — Update multiple records
deleteMany{Model} — Delete multiple records

Use excludeQueriesAndMutations to remove specific operations globally or per-model.

Upgrading from v8

If you're migrating from @paljs/generator v8 or @paljs/cli, see the Upgrade Guide.

Command Palette