Convert Excel Column Headers to a Type-Safe tRPC Router

A users sheet to a flat CRUD router

A single-sheet workbook with id, name, email, and an active flag. The router name usersRouter yields the User entity (trailing router stripped, PascalCased). Note id is numeric in the sample so it becomes z.number(), while the UUID validation on getById/update is fixed by the generator regardless of the id column's inferred type.

Input (Sheet1, first row = headers):
id,name,email,active
1,Alice,alice@acme.com,true
2,Bob,bob@acme.com,false

Router name: usersRouter

Generated usersRouter.ts (schema + list excerpt):
export const UserSchema = z.object({
  id: z.number().optional(),
  name: z.string().optional(),
  email: z.string().optional(),
  active: z.boolean().optional(),
});
export const userCreateSchema = UserSchema.required();
export const userUpdateSchema = UserSchema.partial().extend({
  id: z.string().uuid(),
});
export interface User { id?: number; name?: string; email?: string; active?: boolean; }

export const usersRouter = router({
  list: publicProcedure
    .input(z.object({
      page: z.number().int().min(1).default(1),
      pageSize: z.number().int().min(1).max(100).default(20),
      search: z.string().optional(),
    }))
    .query(async ({ input, ctx }) => { /* ctx.db.user.findMany(...) */ }),
  // getById, create, update, delete follow
});
export type UserRouter = typeof usersRouter;

Search targets the first two string columns

The list procedure's optional search builds a case-insensitive contains filter — but only over the first two columns the tool typed as z.string(). Here name and email are the first two strings, so search hits both; a later notes column is ignored by search (you'd add it by hand).

Headers: id, name, email, signupDate, notes
  id        -> z.number()
  name      -> z.string()   (1st string)
  email     -> z.string()   (2nd string)
  signupDate-> z.string()   (ISO date, kept as string)
  notes     -> z.string()

Generated where clause (search non-empty):
where: search ? {
  OR: [
    { name:  { contains: search, mode: "insensitive" } },
    { email: { contains: search, mode: "insensitive" } },
  ],
} : undefined

// notes is NOT searched — only the first 2 string columns are wired in.

A multi-sheet workbook becomes a nested router

When the workbook has more than one non-empty sheet, the tool emits a root router with one sub-router per sheet. Critically, sub-router entity names come from the SHEET NAMES, not from the router name — so name your tabs deliberately.

Workbook tabs: Users | Products

Router name: appRouter

Generated appRouter.ts (structure):
// Schemas for both entities (UserSchema, ProductSchema...)
const usersRouter = router({ /* list/getById/create/update/delete for User */ });
const productsRouter = router({ /* ...for Product */ });

export const appRouter = router({
  users: usersRouter,
  products: productsRouter,
});
export type AppRouter = typeof appRouter;

// Entity names = sheet names (Users -> User, Products -> Product),
// independent of the routerName you typed.

Numeric ID column inferred as z.number()

Spreadsheets almost always store IDs as plain integers, so the id column is typed z.number() in the schema and interface — even though getById and the update key are hard-coded to z.string().uuid(). Decide whether your real keys are numeric or UUID and reconcile after generating.

Input:
id,sku,price
1001,ABC-1,19.99
1002,DEF-2,4.50

Generated schema fields:
  id:    z.number().optional()   // numeric samples -> z.number()
  sku:   z.string().optional()
  price: z.number().optional()   // 19.99 / 4.50 match the numeric regex

// But getById input is fixed: z.object({ id: z.string().uuid() })
// If your real id is a numeric PK, change this to z.number() by hand.

Empty / sparse columns fall back to z.string()

A column whose first 50 sampled cells are all blank has no samples to type, so no rule fires and it defaults to z.string(). Same outcome for a column that mixes a number with any non-numeric value — one stray n/a disqualifies z.number().

Input:
id,middleName,age
1,,30
2,,n/a

Inference:
  id         -> z.number()   (1, 2)
  middleName -> z.string()   (all samples empty -> fallback)
  age        -> z.string()   ('n/a' present -> not all-numeric)

// Clean or backfill columns before generating if you want stronger types.

The processor checks the tier and throws tRPC Router Builder requires Developer tier. before doing any work; the UI shows an upgrade overlay (requires the Developer plan) over the form. This is the most common reason no output appears. Upgrade to Developer to generate routers.

When every sampled value in a column matches the ISO date prefix YYYY-MM-DD, the tool deliberately assigns z.string() (not z.date() or z.coerce.date()). The generated schema validates the shape as text. If you want real date validation, change those fields to z.string().datetime() or z.coerce.date() after generating.

The base ${Entity}Schema makes every field .optional(). ${entity}CreateSchema re-tightens with .required() (all fields mandatory on create) and ${entity}UpdateSchema uses .partial() plus a required id: z.string().uuid(). If some fields should be required on read too, edit the base schema by hand — the generator can't know which columns are nullable in your DB.

Regardless of how the tool typed your id column, the getById input, the delete input, and the update schema's id are hard-wired to z.string().uuid(). If your primary key is a numeric autoincrement or a CUID, replace z.string().uuid() with the correct validator in those three places after generating.

SheetJS reads the first row as column keys. If your first row is actual data instead of headers, those data values become the Zod field names (e.g. a field literally named Alice). Always keep a clean header row at the top before uploading.

Two columns named email are disambiguated by SheetJS (the second becomes email_1 or similar) so the keys stay unique — meaning your schema gets a field with the suffixed name. Rename duplicate headers in the source sheet to get clean field names.

A header like First Name or sign-up date is converted to a camelCase field (firstName, signUpDate) for both the Zod schema and the TS interface. The transformation strips non-alphanumeric separators and uppercases the following letter; verify the result reads as you expect for unusual headers.

If no sheet has any data rows, the tool returns a placeholder // No data text result rather than a router. Make sure at least one sheet has a header row plus data before running.

In a multi-sheet workbook, each sub-router's entity name is derived from its sheet/tab name (PascalCased), not from the router name you typed. A tab called Sheet1 produces a Sheet1 entity. Rename tabs to your intended entity names before generating.

The on-page code preview shows the first 4,000 characters and appends a truncation note for larger files. The full router is always intact — use the Download button (or Copy, which copies the complete generated string) to get every line.