Generate App-Router-Ready tRPC Procedures from Excel Data Schemas

A posts router for the App Router

A Posts sheet generates postsRouter with public reads and protected writes. Fix the ../trpc import and register on appRouter.

Input (sheet: Posts):
id,title,slug,published
1,Hello World,hello-world,true

Router name: postsRouter

Generated postsRouter.ts (top):
import { z } from "zod";
import { router, publicProcedure, protectedProcedure } from "../trpc";
import { TRPCError } from "@trpc/server";
// ...PostSchema, postCreateSchema, postUpdateSchema...
export const postsRouter = router({ list, getById, create, update, delete });
export type PostRouter = typeof postsRouter;

// 1) place in src/server/api/routers/posts.ts
// 2) fix import path -> from "@/server/api/trpc"
// 3) register on appRouter

Register on the root appRouter

Mount the generated router in server/api/root.ts so the App Router server/client helpers can reach it.

// src/server/api/root.ts
import { createTRPCRouter } from "@/server/api/trpc";
import { postsRouter } from "@/server/api/routers/posts";

export const appRouter = createTRPCRouter({
  posts: postsRouter,
});
export type AppRouter = typeof appRouter;

protectedProcedure is a placeholder you must define

The generated mutations use protectedProcedure, but the generator does not create it. It has to exist in your tRPC instance with your real auth middleware.

// In your @/server/api/trpc.ts (you own this):
export const protectedProcedure = t.procedure.use(({ ctx, next }) => {
  if (!ctx.session?.user) throw new TRPCError({ code: "UNAUTHORIZED" });
  return next({ ctx: { ...ctx, session: ctx.session } });
});

// The generated router just references it; if it's missing the file won't compile.

Consume from a Server Component and a Client hook

Once registered, the App Router helpers give you type-safe access on both the server and the client.

// Server Component (RSC):
const { data } = await api.posts.list({ page: 1, pageSize: 20 });

// Client Component:
const { data } = api.posts.list.useQuery({ page: 1, pageSize: 20, search: "hello" });

// Both infer types from the generated router -> no manual type annotations.

Multi-entity API from one workbook

Tabs for Posts and Comments produce a root router; splice its sub-routers into your existing appRouter.

Workbook tabs: Posts | Comments
Router name: contentRouter

export const contentRouter = router({
  posts: postsRouter,
  comments: commentsRouter,
});

// Mount whole thing:
export const appRouter = createTRPCRouter({ content: contentRouter });
// or splice: createTRPCRouter({ posts: ..., comments: ... })

The generated file imports from the literal relative path ../trpc. In a create-t3-app project the tRPC instance is usually at @/server/api/trpc (with createTRPCRouter, not a bare router). Adjust the import path — and the router vs createTRPCRouter name — to match your project, or the file won't compile.

The generator references protectedProcedure and publicProcedure but does not define them. They must already exist in your tRPC instance with your auth middleware wired in. If your project names them differently (or only has publicProcedure), rename the references after generating.

On Free / Pro / Pro+Media the tool throws tRPC Router Builder requires Developer tier. and shows an upgrade overlay. Generate on a Developer-tier account.

Reads are generated as publicProcedure. If your App Router screen requires auth for listing (e.g. an admin table), change list/getById to protectedProcedure after generating. The generator can't know which reads are public.

Those inputs are hard-coded to z.string().uuid() regardless of your id column. For a Prisma Int @id or a CUID, change the validator (z.number().int() or z.string()) so your App Router mutations accept the real id type.

ISO YYYY-MM-DD columns stay z.string(), not z.date(). If a Server Action or form passes a Date, coerce with z.coerce.date() after generating, or convert in the resolver before the ctx.db call.

For a multi-tab workbook each sub-router/entity name is taken from its sheet name, not the router name. Name tabs to your App Router entities (Posts, Comments) before generating.

SheetJS reads row 1 as field names. A title/metadata row above your schema will be parsed as fields. Remove any preamble so row 1 holds only column names.

The list search filter ORs over the first two z.string() columns. For an App Router search UI that should cover more fields, extend the generated where clause manually.

Large routers are cut off in the on-page preview. Use Copy (full string) or Download to get the complete file before pasting into your routers directory.