Generate Zod Input Schemas for tRPC Router Procedures

Generate the structural skeleton, then add the range constraints tRPC list procedures usually want.

Input sample:
{ "cursor": "abc", "limit": 20 }

Generated:
import { z } from "zod";
export const listPostsInput = z.object({
  cursor: z.string(),
  limit: z.number().int()
});
export type ListPostsInput = z.infer<typeof listPostsInput>;

Used (you add constraints):
listPosts: publicProcedure
  .input(listPostsInput.extend({ limit: z.number().int().max(100) }))
  .query(({ input }) => /* ... */);

Nested input objects become nested z.object blocks, matching the argument structure exactly.

Input sample:
{ "postId": "abc", "comment": { "body": "hi", "pinned": false } }

Generated:
export const addCommentInput = z.object({
  postId: z.string(),
  comment: z.object({
    body: z.string(),
    pinned: z.boolean()
  })
});

Used:
addComment: protectedProcedure
  .input(addCommentInput)
  .mutation(({ input }) => /* input.comment.body is typed */);

A homogeneous array collapses to a single element type. Add a non-empty constraint for batch operations.

Input sample:
{ "ids": ["a", "b", "c"], "published": true }

Generated:
export const bulkUpdateInput = z.object({
  ids: z.array(z.string()),
  published: z.boolean()
});

Refined:
.input(bulkUpdateInput.extend({
  ids: z.array(z.string().cuid()).min(1)
}))

With Strict objects on, a client sending an undeclared argument is rejected at the procedure boundary — a strong guarantee for end-to-end safety.

Strict objects: ON

export const getPostInput = z.strictObject({
  id: z.string()
});

getPost: publicProcedure.input(getPostInput).query(...)
// A call with { id, debug: true } throws Unrecognized key(s).

If an optional arg wasn't in the sample, add it after generating. tRPC respects .optional() and .default() on the input.

Generated (only required args seen):
export const searchInput = z.object({ q: z.string() });

You add the optional filter:
export const searchInput = z.object({
  q: z.string(),
  category: z.string().optional(),
  sort: z.enum(['new','top']).default('new')
});

The generator infers structure from value types, so any id string is z.string(). Add .cuid(), .uuid(), or .regex(...) to match your id format. This keeps inference deterministic — it never guesses an id convention.

Only keys present in the sample input are inferred. An optional argument you left out will not be in the schema. Add it as .optional() (or .default(...)) by hand, or include it in the sample with a representative value.

A null argument produces z.null(), accepting only null. For a nullable argument, rewrite to z.string().nullable() (or the appropriate base). The generator can't infer the non-null type from one null.

If you paste an array whose objects differ in shape, the generator emits z.array(z.union([...])) rather than a discriminated union. tRPC inputs that vary by a type field need a hand-built z.discriminatedUnion('type', [...]) — the generator can't infer the discriminator.

An array like [1, "x"] yields z.array(z.union([z.number().int(), z.string()])). Faithful to the sample, but for a clean contract you usually want a single element type — normalise the sample or tighten the schema by hand.

An empty array ([]) becomes z.array(z.unknown()). Provide at least one element in the sample so the element type can be inferred, or replace z.unknown() with the intended element schema.

This tool generates one schema from one sample, which you use as the procedure input. tRPC usually infers the output type from your resolver, so you rarely need an explicit .output(). If you do, generate a separate schema from a sample response.

Free tier permits 1 generation per day (UTC reset) with array inputs capped at 100 rows. Each procedure schema is one run. Generate your most-complex inputs first, or upgrade — Pro is 5/day and Developer is unlimited.