Combinación de Routers

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Escribir todo el código de la API en el mismo archivo puede volverse engorroso. Es fácil combinar routers para dividirlos en partes manejables.

Combinación con routers hijos

routers/user.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const userRouter = router({
  list: publicProcedure.query(() => {
    // [..]
    return [];
  }),
});

routers/user.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const userRouter = router({
  list: publicProcedure.query(() => {
    // [..]
    return [];
  }),
});

routers/post.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const postRouter = router({
  create: publicProcedure
    .input(
      z.object({
        title: z.string(),
      }),
    )
    .mutation((opts) => {
      const { input } = opts;
      // [...]
    }),
  list: publicProcedure.query(() => {
    // ...
    return [];
  }),
});

routers/post.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const postRouter = router({
  create: publicProcedure
    .input(
      z.object({
        title: z.string(),
      }),
    )
    .mutation((opts) => {
      const { input } = opts;
      // [...]
    }),
  list: publicProcedure.query(() => {
    // ...
    return [];
  }),
});

routers/_app.ts
ts
import { router } from '../trpc';
 
import { userRouter } from './user';
import { postRouter } from './post';
 
const appRouter = router({
  user: userRouter,
  post: postRouter,
});
 
appRouter.user
           
(property) user: DecorateCreateRouterOptions<{
    list: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}>
 
appRouter.post
           
(property) post: DecorateCreateRouterOptions<{
    create: MutationProcedure<{
        input: {
            title: string;
        };
        output: void;
        meta: object;
    }>;
    list: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}>
 
export type AppRouter = typeof appRouter;

routers/_app.ts
ts
import { router } from '../trpc';
 
import { userRouter } from './user';
import { postRouter } from './post';
 
const appRouter = router({
  user: userRouter,
  post: postRouter,
});
 
appRouter.user
           
(property) user: DecorateCreateRouterOptions<{
    list: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}>
 
appRouter.post
           
(property) post: DecorateCreateRouterOptions<{
    create: MutationProcedure<{
        input: {
            title: string;
        };
        output: void;
        meta: object;
    }>;
    list: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}>
 
export type AppRouter = typeof appRouter;

Combinación con t.mergeRouters

Si prefieres tener todos los procedimientos en un único espacio de nombres plano, puedes usar t.mergeRouters

routers/user.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const userRouter = router({
  userList: publicProcedure.query(() => {
    // [..]
    return [];
  }),
});

routers/user.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const userRouter = router({
  userList: publicProcedure.query(() => {
    // [..]
    return [];
  }),
});

routers/post.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const postRouter = router({
  postCreate: publicProcedure
    .input(
      z.object({
        title: z.string(),
      }),
    )
    .mutation((opts) => {
      const { input } = opts;
      // [...]
    }),
  postList: publicProcedure.query(() => {
    // ...
    return [];
  }),
});

routers/post.ts
ts
import { router, publicProcedure } from '../trpc';
import { z } from 'zod';
 
export const postRouter = router({
  postCreate: publicProcedure
    .input(
      z.object({
        title: z.string(),
      }),
    )
    .mutation((opts) => {
      const { input } = opts;
      // [...]
    }),
  postList: publicProcedure.query(() => {
    // ...
    return [];
  }),
});

routers/_app.ts
ts
import { mergeRouters } from '../trpc';
 
import { userRouter } from './user';
import { postRouter } from './post';
 
const appRouter = mergeRouters(userRouter, postRouter);
         
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    postCreate: MutationProcedure<{
        input: {
            title: string;
        };
        output: void;
        meta: object;
    }>;
    postList: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}> & DecorateCreateRouterOptions<{
    userList: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}>>
 
export type AppRouter = typeof appRouter;

routers/_app.ts
ts
import { mergeRouters } from '../trpc';
 
import { userRouter } from './user';
import { postRouter } from './post';
 
const appRouter = mergeRouters(userRouter, postRouter);
         
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    postCreate: MutationProcedure<{
        input: {
            title: string;
        };
        output: void;
        meta: object;
    }>;
    postList: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}> & DecorateCreateRouterOptions<{
    userList: QueryProcedure<{
        input: void;
        output: never[];
        meta: object;
    }>;
}>>
 
export type AppRouter = typeof appRouter;

Carga dinámica de routers

Puedes usar la función lazy para cargar tus routers dinámicamente. Esto resulta útil para reducir los arranques en frío de tu aplicación. No hay diferencia en cómo usas el router después de su carga diferida frente a cómo usas un router normal.

routers/greeting.ts
ts
import { router, publicProcedure } from '../trpc';
 
export const greetingRouter = router({
  hello: publicProcedure.query(() => 'world'),
});

routers/greeting.ts
ts
import { router, publicProcedure } from '../trpc';
 
export const greetingRouter = router({
  hello: publicProcedure.query(() => 'world'),
});

routers/user.ts
ts
import { router, publicProcedure } from '../trpc';
 
export const userRouter = router({
  list: publicProcedure.query(() => ['John', 'Jane', 'Jim']),
});

routers/user.ts
ts
import { router, publicProcedure } from '../trpc';
 
export const userRouter = router({
  list: publicProcedure.query(() => ['John', 'Jane', 'Jim']),
});

routers/_app.ts
ts
import { lazy } from '@trpc/server';
import { router } from '../trpc';
 
export const appRouter = router({
  // Option 1: Short-hand when the module has exactly 1 router exported
  greeting: lazy(() => import('./greeting.js')),
  // Option 2: if exporting more than 1 router
  user: lazy(() => import('./user.js').then((m) => m.userRouter)),
});
export type AppRouter = typeof appRouter;

routers/_app.ts
ts
import { lazy } from '@trpc/server';
import { router } from '../trpc';
 
export const appRouter = router({
  // Option 1: Short-hand when the module has exactly 1 router exported
  greeting: lazy(() => import('./greeting.js')),
  // Option 2: if exporting more than 1 router
  user: lazy(() => import('./user.js').then((m) => m.userRouter)),
});
export type AppRouter = typeof appRouter;