Routers

// src/trpc/procedures/routers/my-resource.ts
import { createTRPCRouter } from "@/trpc/init";
import { authProcedure } from "@/trpc/procedures/trpc";
import { z } from "zod";

export const myResourceRouter = createTRPCRouter({
  list: authProcedure
    .meta({ rateLimit: "QUERY" })
    .query(async ({ ctx }) => {
      return {
        success: true,
        payload: await ctx.db.myResource.list(),
      };
    }),

  get: authProcedure
    .meta({ rateLimit: "QUERY" })
    .input(z.object({ id: z.string() }))
    .query(async ({ ctx, input }) => {
      return {
        success: true,
        payload: await ctx.db.myResource.get({ id: input.id }),
      };
    }),

  create: authProcedure
    .meta({ rateLimit: "MUTATION" })
    .input(myResourceSchema)
    .mutation(async ({ ctx, input }) => {
      const result = await ctx.db.myResource.create(input);
      return {
        success: true,
        message: ctx.t("toasts.saved"),
        payload: result,
      };
    }),
});

// src/trpc/procedures/root.ts
import { createTRPCRouter } from "@/trpc/init";
import { myResourceRouter } from "./routers/my-resource";
import { anotherRouter } from "./routers/another-resource";

export const appRouter = createTRPCRouter({
  myResource: myResourceRouter,
  another: anotherRouter,
});

export type AppRouter = typeof appRouter;

// Client-side
const { data } = api.myResource.list.useQuery();
const { data } = api.another.get.useQuery({ id: "123" });

// Server-side
const data = await api.myResource.list();

src/trpc/procedures/routers/
├── auth.ts           # Authentication operations
├── users.ts          # User management
├── organizations.ts  # Organization operations
├── api-keys.ts       # API key management
└── subscriptions.ts  # Subscription management

export const organizationRouter = createTRPCRouter({
  // Basic operations
  list: authProcedure.query(/* ... */),
  get: authProcedure.input(/* ... */).query(/* ... */),

  // Nested router for members
  members: createTRPCRouter({
    list: authProcedure.query(/* ... */),
    invite: authProcedure.mutation(/* ... */),
    remove: authProcedure.mutation(/* ... */),
  }),
});

const { data } = api.organization.list.useQuery();
const { data } = api.organization.members.list.useQuery();

return {
  success: true,
  message: ctx.t("toasts.saved"),
  payload: data,
} satisfies ActionResponse;

import { z } from "zod";

const createSchema = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email(),
});

create: authProcedure
  .input(createSchema)
  .mutation(async ({ input }) => {
    // input is fully typed and validated
  })

list: authProcedure
  .meta({ rateLimit: "QUERY" })
  .query(/* ... */),

create: authProcedure
  .meta({ rateLimit: "MUTATION" })
  .mutation(/* ... */),

export const myRouter = createTRPCRouter({
  list: authProcedure.query(async ({ ctx }) => {
    // ctx.user - Current user (available in authProcedure)
    // ctx.db - Database operations
    // ctx.t - Translations
    // ctx.headers - Request headers
    // ctx.session - Current session

    return await ctx.db.myResource.list({
      where: { userId: ctx.user.id },
    });
  }),
});