Generate tRPC, Zod, and Prisma-Ready Boilerplate from an Excel Data Model

Single-entity model to a Prisma-ready router

A Product tab with id, name, price, inStock. The generator types price as z.number() and inStock as z.boolean(); you then map ctx.db.product to your actual Prisma model.

Input (sheet: Product):
id,name,price,inStock
1,Widget,19.99,true
2,Gadget,4.50,false

Router name: productsRouter

Generated (excerpt):
export const ProductSchema = z.object({
  id: z.number().optional(),
  name: z.string().optional(),
  price: z.number().optional(),
  inStock: z.boolean().optional(),
});
export const productCreateSchema = ProductSchema.required();
// create procedure:
create: protectedProcedure
  .input(productCreateSchema)
  .mutation(async ({ input, ctx }) => ctx.db.product.create({ data: input })),

// Manual step: confirm ctx.db.product matches your prisma model name.

Multi-tab model becomes a nested router

A workbook with User, Product, and Order tabs generates a root router mounting three sub-routers. Each entity name comes from its sheet name, so the tab labels are load-bearing.

Workbook tabs: User | Product | Order
Router name: appRouter

Generated appRouter.ts:
const userRouter    = router({ /* CRUD for User */ });
const productRouter = router({ /* CRUD for Product */ });
const orderRouter   = router({ /* CRUD for Order */ });
export const appRouter = router({
  user: userRouter,
  product: productRouter,
  order: orderRouter,
});
export type AppRouter = typeof appRouter;

Reconciling the id type with Prisma

Spreadsheets store ids as plain integers so the tool infers z.number(), but getById/update/delete hard-code z.string().uuid(). Pick the truth that matches your Prisma @id and edit both places.

Inferred: id: z.number().optional()
Fixed by generator: getById input -> z.object({ id: z.string().uuid() })

If your Prisma model uses Int @id @default(autoincrement()):
  - change getById/delete input to z.object({ id: z.number().int() })
  - change updateSchema's id to z.number().int()
If it uses String @id @default(cuid()):
  - change z.string().uuid() to z.string() (cuid isn't a uuid)

Dates need coercion before they hit Prisma

A signupDate column stays z.string(). Prisma DateTime fields expect a Date, so either coerce in the resolver or tighten the Zod field after generating.

Inferred: signupDate: z.string().optional()   // ISO date kept as string

Option A (tighten the schema):
  signupDate: z.coerce.date().optional()

Option B (coerce in resolver before ctx.db.create):
  const data = { ...input, signupDate: new Date(input.signupDate!) };

Required-on-create vs optional-on-read

The base schema marks every field optional; createSchema re-requires all of them via .required(). If a column is genuinely nullable in your DB, relax it in createSchema by hand.

export const UserSchema = z.object({
  id: z.number().optional(),
  email: z.string().optional(),
  middleName: z.string().optional(),   // nullable in DB
});
export const userCreateSchema = UserSchema.required();  // forces middleName!

// Fix for a nullable column:
export const userCreateSchema = UserSchema.required().partial({ middleName: true });

The tool produces only the tRPC + Zod layer. There is no .prisma output — you author and migrate the Prisma datamodel yourself. The generated ctx.db.<entity>.* calls assume a Prisma-shaped context but won't create or validate against your actual models.

The generator names the data accessor after the camelCased entity (ctx.db.product). If your Prisma model is named differently (e.g. Products mapping to ctx.db.products), the placeholder won't resolve. Align the accessor with your real model name after generating.

On Free / Pro / Pro+Media the processor throws tRPC Router Builder requires Developer tier. and the UI shows an upgrade overlay. Full-stack teams scripting this should ensure the account or runner key is on the Developer plan.

ISO YYYY-MM-DD columns are kept as z.string(). Prisma DateTime fields need a Date — coerce in your resolver or change the Zod field to z.coerce.date() before wiring the create/update mutations to ctx.db.

Every field in ${Entity}Schema is .optional(). create re-requires all of them via .required(). If your model has genuinely nullable columns, relax them in ${entity}CreateSchema (e.g. with .partial({ field: true })) so create doesn't reject valid null inputs.

getById, delete, and the update schema's id are all z.string().uuid() regardless of the inferred id type. For an Int @id @default(autoincrement()) Prisma model, swap them to z.number().int(); for a CUID model use z.string() (a cuid is not a uuid).

Sub-router entity names come from sheet names, not the router name. A default Sheet1 tab yields a Sheet1 entity and ctx.db.sheet1. Rename tabs to your intended entity names before generating a multi-entity router.

The list procedure's search filter ORs over only the first two z.string() columns with contains + insensitive mode. For models where another text field should be searchable, extend the generated where clause manually.

SheetJS treats row 1 as headers. A metadata/title row above your field names will be parsed as the field list. Strip any preamble so the first row contains only the model's field names.

If no sheet contains data rows, the tool returns // No data instead of a router. Ensure each entity tab has a header row plus at least one sample row before generating.