The Complete Production SOP: How to Deploy and Run tRPC Server Procedures, Routers & Middleware Context in Autonomous AI Agents

import { initTRPC, TRPCError } from '@trpc/server';
import type { FetchCreateContextFnOptions } from '@trpc/server/adapters/fetch';
import { z } from 'zod';

export interface Context {
  user: { id: string; role: 'admin' | 'user' } | null;
  reqHeaders: Headers;
}

export const createContext = async (opts: FetchCreateContextFnOptions): Promise<Context> => {
  const authHeader = opts.req.headers.get('authorization');
  const user = authHeader ? { id: 'usr_123', role: 'user' as const } : null;
  return { user, reqHeaders: opts.req.headers };
};

const t = initTRPC.context<Context>().create({
  errorFormatter({ shape, error }) {
    return {
      ...shape,
      data: {
        ...shape.data,
        zodError: error.cause instanceof z.ZodError ? error.cause.flatten() : null,
      },
    };
  },
});

export const router = t.router;
export const publicProcedure = t.procedure;

const isAuthed = t.middleware(async ({ ctx, next }) => {
  if (!ctx.user) {
    throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Authentication required' });
  }
  return next({
    ctx: {
      user: ctx.user,
    },
  });
});

export const protectedProcedure = t.procedure.use(isAuthed);

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "declaration": true,
    "skipLibCheck": true,
    "isolatedModules": true
  }
}

import { z } from 'zod';
import { router, publicProcedure, protectedProcedure } from '../trpc';

export const postRouter = router({
  list: publicProcedure
    .input(z.object({ limit: z.number().min(1).max(100).default(10) }))
    .query(async ({ input, ctx }) => {
      return { items: [], limit: input.limit };
    }),
  create: protectedProcedure
    .input(z.object({ title: z.string().min(5), content: z.string() }))
    .mutation(async ({ input, ctx }) => {
      // ctx.user is non-nullable here due to isAuthed middleware
      return {
        id: 'post_new',
        title: input.title,
        authorId: ctx.user.id,
      };
    }),
});

import { router } from './trpc';
import { postRouter } from './routers/post';

export const appRouter = router({
  post: postRouter,
});

export type AppRouter = typeof appRouter;