For the following schema:

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        Int      @id @default(autoincrement())
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  title     String
  content   String?
  published Boolean  @default(false)
  viewCount Int      @default(0)
  author    User?    @relation(fields: [authorId], references: [id])
  authorId  Int?
}

The generator creates:

generated/
├── routers/
│   ├── index.ts              # Main app router combining all model routers
│   ├── helpers/
│   │   └── createRouter.ts   # Base router factory with middleware/shield setup
│   ├── User.router.ts        # User CRUD operations
│   └── Post.router.ts        # Post CRUD operations
└── schemas/                  # Zod validation schemas (if withZod: true)
    ├── objects/              # Input type schemas
    ├── findManyUser.schema.ts
    ├── createOneUser.schema.ts
    └── index.ts              # Barrel exports

Custom middleware

// src/middleware.ts
import { TRPCError } from '@trpc/server';
import { t } from './trpc';

export const authMiddleware = t.middleware(async ({ ctx, next }) => {
  if (!ctx.user) {
    throw new TRPCError({ code: 'UNAUTHORIZED' });
  }
  return next({
    ctx: {
      ...ctx,
      user: ctx.user,
    },
  });
});

export const loggingMiddleware = t.middleware(async ({ path, type, next }) => {
  console.log(`tRPC ${type} ${path}`);
  return next();
});

Integration with tRPC Shield

// src/permissions.ts
import { shield, rule, and } from 'trpc-shield';

const isAuthenticated = rule()(async (_parent, _args, ctx) => !!ctx.user);

const isOwner = rule()(async (_parent, args, ctx) => {
  if (!args.where?.id) return false;
  const post = await ctx.prisma.post.findUnique({
    where: { id: args.where.id },
    select: { authorId: true },
  });
  return post?.authorId === ctx.user?.id;
});

export const permissions = shield({
  query: {
    findManyPost: true, // Public
    findUniqueUser: isAuthenticated,
  },
  mutation: {
    createOnePost: isAuthenticated,
    updateOnePost: and(isAuthenticated, isOwner),
    deleteOnePost: and(isAuthenticated, isOwner),
  },
});

Custom tRPC options

// src/trpcOptions.ts
import { ZodError } from 'zod';
import superjson from 'superjson';

export default {
  transformer: superjson,
  errorFormatter({ shape, error }) {
    return {
      ...shape,
      data: {
        ...shape.data,
        zodError:
          error.code === 'BAD_REQUEST' && error.cause instanceof ZodError
            ? error.cause.flatten()
            : null,
      },
    };
  },
};

🎨 Customizations

Skipping models

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

Custom context

// src/context.ts
import 'dotenv/config';
import { PrismaClient } from '@prisma/client';
import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';

const adapter = new PrismaBetterSqlite3({
  url: process.env.DATABASE_URL as ':memory:' | (string & {}),
});
const prisma = new PrismaClient({ adapter });

export interface Context {
  prisma: PrismaClient;
  user?: { id: string; email: string; role: string };
}

export const createContext = async ({ req }): Promise<Context> => {
  const user = await getUserFromRequest(req);
  return { prisma, user };
};

📚 Examples

Basic CRUD with authentication

// src/server/routers/posts.ts
import { z } from 'zod';
import { createTRPCRouter, protectedProcedure, publicProcedure } from '../trpc';

export const postsRouter = createTRPCRouter({
  getAll: publicProcedure.query(({ ctx }) =>
    ctx.prisma.post.findMany({
      where: { published: true },
      include: { author: { select: { name: true } } },
    }),
  ),

  create: protectedProcedure
    .input(
      z.object({ title: z.string().min(1), content: z.string().optional() }),
    )
    .mutation(({ ctx, input }) =>
      ctx.prisma.post.create({ data: { ...input, authorId: ctx.user.id } }),
    ),

  update: protectedProcedure
    .input(
      z.object({
        id: z.number(),
        title: z.string().min(1).optional(),
        content: z.string().optional(),
      }),
    )
    .mutation(async ({ ctx, input }) => {
      const { id, ...data } = input;
      const post = await ctx.prisma.post.findFirst({
        where: { id, authorId: ctx.user.id },
      });
      if (!post) throw new TRPCError({ code: 'FORBIDDEN' });
      return ctx.prisma.post.update({ where: { id }, data });
    }),
});

Next.js App Router integration

// src/app/api/trpc/[trpc]/route.ts
import { fetchRequestHandler } from '@trpc/server/adapters/fetch';
import { appRouter } from '@/server/api/root';
import { createContext } from '@/server/api/context';

const handler = (req: Request) =>
  fetchRequestHandler({
    endpoint: '/api/trpc',
    req,
    router: appRouter,
    createContext,
  });

export { handler as GET, handler as POST };

Client-side usage

// src/lib/trpc.ts
import { createTRPCReact } from '@trpc/react-query';
import type { AppRouter } from '@/server/api/root';

export const trpc = createTRPCReact<AppRouter>();

const PostList = () => {
  const { data: posts, isLoading } = trpc.post.findMany.useQuery();
  const createPost = trpc.post.createOne.useMutation();
  if (isLoading) return <div>Loading...</div>;
  return (
    <div>
      {posts?.map((post) => (
        <div key={post.id}>{post.title}</div>
      ))}
    </div>
  );
};

Common issues

Error: Cannot find module '../context'

• Ensure your contextPath is correct relative to the output directory.
• Check that your context file exports a Context type.

TypeScript errors in generated routers

• Ensure dependencies are installed and up to date.
• Verify your tRPC context is properly typed.
• Ensure strict: true is enabled in tsconfig.json.

Generated routers not updating

• Run npx prisma generate after modifying your schema.
• Check that the generator is properly configured in schema.prisma.
• Clear your build cache and regenerate.

Zod validation errors

• Ensure Zod 4.0+ is installed.
• Check that input schemas match your Prisma model types.
• For DateTime validation errors with JSON APIs, set dateTimeStrategy: "coerce" to accept date strings.

Performance considerations

For large schemas (50+ models):

• Use selective generation with model hiding.
• Split routers into multiple files.
• Consider lazy loading routers.

Build times:

• Add generated files to .gitignore.
• Use parallel builds where possible.
• Cache dependencies in CI.

FAQ

Q: Can I customize the generated router validation rules? A: Routers are generated based on your Prisma schema constraints; change your Prisma model definitions to affect validation.

Q: Does this work with Prisma Edge Runtime? A: Yes.

Q: What databases are supported? A: All Prisma‑compatible databases.

Q: How are enums handled? A: Enums are converted to Zod enums and included in validation.

Q: Can I exclude fields from validation? A: Use Prisma's @ignore or @@Gen.model(hide: true).

Getting help

• 🐛 Bug reports: https://github.com/omar-dulaimi/prisma-trpc-generator/issues/new
• 💡 Feature requests: https://github.com/omar-dulaimi/prisma-trpc-generator/issues/new
• 💬 Discussions: https://github.com/omar-dulaimi/prisma-trpc-generator/discussions

Development setup

1. Fork and clone the repository

git clone https://github.com/your-username/prisma-trpc-generator.git
cd prisma-trpc-generator

2. Install dependencies (requires Node.js 20.19.0+; 22.x recommended, this repo uses pnpm)

pnpm install

3. Create your .env

prisma.config.ts reads DATABASE_URL, and .env is not committed, so a fresh clone has to create it before anything can run Prisma.

cp .env.example .env

4. Build/generate

pnpm run generate

5. Run tests

pnpm test

Testing

The suite lives in tests/ and is organised by feature: routers, Zod schemas, middleware and shield, auth, OpenAPI, Postman, tenancy and soft delete, and custom client paths. Every one of them generates from a real Prisma schema and asserts against the emitted files, so pnpm run generate must have run first.

Run specific test suites

# everything, quietly
pnpm test --silent

# one file
pnpm test tests/feature-zod-schemas.test.ts

# with coverage (a Vitest flag; there is no separate coverage script)
pnpm test --coverage

Coverage of src/ reads 0 because each suite shells out to prisma generate, which runs the generator in a child process that the coverage provider does not instrument. The numbers to read are the ones for the generated routers.

Packaging checks

The suites above run the built lib/ from inside this repo, where node_modules already holds every devDependency, so they pass even when the published manifest under-declares its runtime dependencies. This packs the tarball, installs it into an empty project outside the repo, and loads the generator from there:

pnpm run test:packaging

Contribution guidelines

1. Create an issue for bugs or feature requests.
2. Follow the existing code style (ESLint + Prettier).
3. Add tests for new functionality.
4. Update documentation as needed.
5. Submit a PR with a clear description.

Code style

pnpm run lint
pnpm run format

Release process

Semantic versioning

• Patch: bug fixes and small improvements
• Minor: new features and enhancements
• Major: breaking changes