Table of Contents

• About The Project
• Supported Prisma Versions
• Installation
• Usage
• Additional Options

About The Project

Automatically generate fully implemented tRPC routers from your Prisma Schema. This includes routers, app router and of course all input schemas using Zod. Updates every time npx prisma generate runs.

Supported Prisma Versions

4.0.0 or higher

Supported TRPC Versions

10.0.0 or higher

Installation

Using npm:

 npm install @conte-ltd/prisma-trpc-generator @conte-ltd/prisma-zod-generator

Using yarn:

 yarn add @conte-ltd/prisma-trpc-generator @conte-ltd/prisma-zod-generator

Usage

1- Star this repo 😉

2- Add the generator to your Prisma schema

generator trpc {
  provider         = "prisma-trpc-generator"
  baseRouterPath   = "../../../src/router"
  baseRouterName   = "baseRouter"
  createRouterName = "createRouter"
}

3- Enable strict mode in tsconfig as it is required by Zod, and considered a Typescript best practice

{
  "compilerOptions": {
    "strict": true
  }
}

4- Running npx prisma generate for the following schema.prisma

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?
}

will generate

import { createRouter } from "../../router";
import { PostFindUniqueSchema } from "../schemas/findUniquePost.schema";
import { PostFindFirstSchema } from "../schemas/findFirstPost.schema";
import { PostFindManySchema } from "../schemas/findManyPost.schema";
import { PostCreateOneSchema } from "../schemas/createOnePost.schema";
import { PostDeleteOneSchema } from "../schemas/deleteOnePost.schema";
import { PostUpdateOneSchema } from "../schemas/updateOnePost.schema";
import { PostDeleteManySchema } from "../schemas/deleteManyPost.schema";
import { PostUpdateManySchema } from "../schemas/updateManyPost.schema";
import { PostUpsertSchema } from "../schemas/upsertOnePost.schema";
import { PostAggregateSchema } from "../schemas/aggregatePost.schema";
import { PostGroupBySchema } from "../schemas/groupByPost.schema";

export const postsRouter = createRouter()

  .query("aggregate", {
    input: PostAggregateSchema,
    async resolve({ ctx, input }) {
      const aggregate = await ctx.prisma.post.aggregate(input);
      return aggregate;
    },
  })

  .mutation("createOne", {
    input: PostCreateOneSchema,
    async resolve({ ctx, input }) {
      const createOne = await ctx.prisma.post.create({ data: input.data });
      return createOne;
    },
  })

  .mutation("deleteMany", {
    input: PostDeleteManySchema,
    async resolve({ ctx, input }) {
      const deleteMany = await ctx.prisma.post.deleteMany(input);
      return deleteMany;
    },
  })

  .mutation("deleteOne", {
    input: PostDeleteOneSchema,
    async resolve({ ctx, input }) {
      const deleteOne = await ctx.prisma.post.delete({ where: input.where });
      return deleteOne;
    },
  })

  .query("findFirst", {
    input: PostFindFirstSchema,
    async resolve({ ctx, input }) {
      const findFirst = await ctx.prisma.post.findFirst(input);
      return findFirst;
    },
  })

  .query("findMany", {
    input: PostFindManySchema,
    async resolve({ ctx, input }) {
      const findMany = await ctx.prisma.post.findMany(input);
      return findMany;
    },
  })

  .query("findUnique", {
    input: PostFindUniqueSchema,
    async resolve({ ctx, input }) {
      const findUnique = await ctx.prisma.post.findUnique({ where: input.where });
      return findUnique;
    },
  })

  .query("groupBy", {
    input: PostGroupBySchema,
    async resolve({ ctx, input }) {
      const groupBy = await ctx.prisma.post.groupBy({ where: input.where, orderBy: input.orderBy, by: input.by, having: input.having, take: input.take, skip: input.skip });
      return groupBy;
    },
  })

  .mutation("updateMany", {
    input: PostUpdateManySchema,
    async resolve({ ctx, input }) {
      const updateMany = await ctx.prisma.post.updateMany(input);
      return updateMany;
    },
  })

  .mutation("updateOne", {
    input: PostUpdateOneSchema,
    async resolve({ ctx, input }) {
      const updateOne = await ctx.prisma.post.update({ where: input.where, data: input.data });
      return updateOne;
    },
  })

  .mutation("upsertOne", {
    input: PostUpsertSchema,
    async resolve({ ctx, input }) {
      const upsertOne = await ctx.prisma.post.upsert({ where: input.where, create: input.create, update: input.update });
      return upsertOne;
    },
  })

5- Make sure you have a valid Context file, as specified in contextPath option. The official tRPC docs for reference.

Additional Options

| Option | Description | Type | Default | |-----------------|------------------------------------------------------------|------------------------------|----------------------| | output | Output directory for the generated routers and zod schemas | string | ./generated | | initTRPCPath | Sets the init trpc path used in your routers | string | .../../../src/trpc | | initTRPCName | Sets the init trpc name used in your routers | string | t | | procedureName | Sets the procedure name used in your routers | string | procedure | | exportRouter | partial or merged routers | 'both', 'marged', 'partal' | both |

Example of init trpc

import { initTRPC } from '@trpc/server';
import { Context } from './context';

export const t = initTRPC.context<Context>().create()
export const procedure = t.procedure