prisma-trpc-generator

When authentication is enabled, the generator provides three types of procedures in your routers:

1. publicProcedure: No authentication required.
2. protectedProcedure: Requires a valid user session (ctx.user must be populated).
3. roleProcedure(['role_name']): Requires the user to have a specific role.

You can customize which field on the user object is checked for roles using the rolesField configuration key (defaults to "role").

Generated Files:

• routers/helpers/auth.ts: Contains ensureAuth(ctx) and ensureRole(ctx, roles).
• routers/helpers/auth-strategy.ts: Contains the strategy implementation (or stubs if paths are not provided).
• routers/helpers/createRouter.ts: Automatically wires the authMiddleware to populate ctx.user.

Enable authentication by setting the auth key in your configuration.

Supported Strategies:

• session
• jwt
• custom

Configuration Object Shape:

"auth": {
  "strategy": "jwt",
  "rolesField": "role",
  "jwt": { "secret": "..." },
  "session": { "..." },
  "custom": { "..." }
}

Generated Files:

• routers/helpers/auth-strategy.ts: Contains stubs and a default HS256 JWT verifier.
• routers/helpers/auth.ts: Provides ensureAuth and ensureRole helpers.
• createRouter.ts: Automatically wires authMiddleware, publicProcedure, protectedProcedure, and roleProcedure(roles).

To perform a minimal setup, add the generator block to your Prisma schema and point it to a JSON configuration file. Note that both output and config paths are resolved relative to the schema file.

1. Add the generator to schema.prisma.
2. Create a trpc.config.json file.
3. Enable "strict": true in your tsconfig.json.
4. Run npx prisma generate.

generator trpc {
  provider = "prisma-trpc-generator"
  output   = "./generated"
  config   = "./trpc.config.json"
}

To prevent the generator from creating routers or schemas for specific models (e.g., internal logs or metadata tables), use the @@Gen.model(hide: true) attribute in your schema.prisma file.

/// @@Gen.model(hide: true)
model InternalLog {
  id        Int      @id @default(autoincrement())
  message   String
  createdAt DateTime @default(now())
}

Install the generator using your preferred package manager.

# npm
npm install prisma-trpc-generator

# yarn
yarn add prisma-trpc-generator

# pnpm
pnpm add prisma-trpc-generator

To use the generator with Prisma 7, follow these steps:

1. Create prisma.config.ts at your repository root to define your schema, migrations, and datasource.
2. Update your generator client block in schema.prisma to ensure the client is outputted to the correct location.
3. Set DATABASE_URL in your .env file and ensure your PrismaClient is instantiated with the appropriate database adapter (e.g., @prisma/adapter-pg for Postgres).

// prisma.config.ts
import 'dotenv/config';
import { defineConfig, env } from 'prisma/config';

export default defineConfig({
  schema: 'prisma/schema.prisma',
  migrations: {
    path: 'prisma/migrations',
    seed: 'tsx prisma/seed.ts',
  },
  datasource: {
    url: env('DATABASE_URL'),
  },
});

// schema.prisma
generator client {
  provider = "prisma-client"
  output   = "../node_modules/.prisma/client"
}

To enable authentication, add the auth key to your JSON configuration.

Setting "auth": true enables protectedProcedure and roleProcedure using the default session strategy.

For more control, provide an object specifying the strategy ("session", "jwt", or "custom") and an optional rolesField to define which field on the user object is used for role-based access control.

{
  "auth": {
    "strategy": "session",
    "rolesField": "role"
  }
}

The generator supports advanced patterns for type safety and business logic delegation:

Zod Schema Integration

If config.withZod is enabled, the generator looks for existing .schema.ts files in the schemas directory (e.g., User.schema.ts). It will only generate tRPC procedures for operations where a corresponding schema file is found. This ensures that every generated procedure has a valid Zod input validator.

Service Delegation

If config.withServices is enabled, the generator assumes you are using a service layer. It will automatically add an import for makeServices in your generated router files, allowing the router to delegate business logic to your service implementations.

The ServiceStyle type determines the architectural pattern used for the generated service layer. You can choose between three styles:

• 'class': Generates services as standard TypeScript classes.
• 'factory': Generates services using a factory function pattern.
• 'plain': Generates services as plain objects.

This setting is configured within the ServicesConfig object.

export type ServiceStyle = 'class' | 'factory' | 'plain';