GraphQL & tRPC Integration
EntityTS eliminates API boilerplate by automatically deriving type-safe GraphQL schemas and tRPC routers directly from your entity metadata.
GraphQL Schema Generation (GraphQLSchemaBuilder)
GraphQLSchemaBuilder automatically compiles entity definitions and relationships into standard GraphQL Schema Definition Language (SDL) strings and executable resolver maps.
Generating SDL & Resolvers
import { GraphQLSchemaBuilder } from 'entityts';
import { User } from './entities/User';
import { Post } from './entities/Post';
const builder = new GraphQLSchemaBuilder([User, Post]);
// 1. Generate standard GraphQL SDL string
const typeDefs = builder.generateSdl();
console.log(typeDefs);
// 2. Build resolvers wired directly to your DbContext
const resolvers = builder.buildResolvers(dbContext);
Generated Schema Output
The generated SDL includes query, mutation, and input types:
type User {
id: ID!
name: String!
email: String!
posts: [Post]
}
type Query {
user(id: ID!): User
users(skip: Int, limit: Int): [User]
}
type Mutation {
createUser(name: String!, email: String!): User
updateUser(id: ID!, name: String, email: String): User
deleteUser(id: ID!): Boolean
}
Solving the N+1 Problem with DataLoaderBatcher
To prevent the classic $O(N)$ database queries when traversing relationships, EntityTS provides DataLoaderBatcher:
import { DataLoaderBatcher } from 'entityts';
const batcher = new DataLoaderBatcher<number, Post[]>(async userIds => {
// Fetches posts for all requested user IDs in a single SQL query
const posts = await db.posts.where(p => userIds.includes(p.userId)).toList();
const grouped = new Map<number, Post[]>();
for (const post of posts) {
if (!grouped.has(post.userId)) grouped.set(post.userId, []);
grouped.get(post.userId)!.push(post);
}
return userIds.map(id => grouped.get(id) ?? []);
});
// Resolvers load child relations via batcher
const userPosts = await batcher.load(user.id);
tRPC Router Generation (TrpcRouterBuilder)
For full-stack TypeScript applications with Next.js, Remix, or Vite, TrpcRouterBuilder creates type-safe procedure routers without writing repetitive CRUD endpoints:
import { TrpcRouterBuilder } from 'entityts';
import { User } from './entities/User';
// Create type-safe procedure router
const userRouter = TrpcRouterBuilder.createEntityRouter(dbContext, User);
// Inside your tRPC router definition:
export const appRouter = router({
user: router({
list: publicProcedure
.input(z.object({ skip: z.number().optional(), limit: z.number().optional() }))
.query(opts => userRouter.list.resolve(opts)),
byId: publicProcedure
.input(z.object({ id: z.number() }))
.query(opts => userRouter.byId.resolve(opts)),
create: publicProcedure
.input(userInputSchema)
.mutation(opts => userRouter.create.resolve(opts)),
update: publicProcedure
.input(userUpdateSchema)
.mutation(opts => userRouter.update.resolve(opts)),
delete: publicProcedure
.input(z.object({ id: z.number() }))
.mutation(opts => userRouter.delete.resolve(opts)),
}),
});