Prisma tRPC Generator
A Prisma generator that automates creating your tRPC routers from your Prisma schema.
Explore the options »
Report Bug
·
Request Feature
Table of Contents
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-generatorUsing yarn:
yarn add @conte-ltd/prisma-trpc-generator @conte-ltd/prisma-zod-generatorUsage
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