tRPC End-to-End Type Safe APIs · Aula

Mesclando e aninhando roteadores

Aprenda a organizar uma API tRPC em crescimento compondo vários sub-roteadores em um único roteador de aplicação aninhado.

Mesclando e aninhando roteadores é uma aula grátis de tRPC End-to-End Type Safe APIs no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de tRPC End-to-End Type Safe APIs, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de tRPC End-to-End Type Safe APIs inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Why Split Routers?

As your API grows, one giant router becomes hard to read. tRPC lets you build small focused sub-routers and merge them.

A Users Sub-Router

Group all user-related procedures together.

export const userRouter = router({
  list: publicProcedure.query(() => getUsers()),
  byId: publicProcedure.input(z.string()).query(({ input }) => getUser(input)),
});

A Posts Sub-Router

Define another router for posts.

export const postRouter = router({
  list: publicProcedure.query(() => getPosts()),
  create: publicProcedure.input(z.object({ title: z.string() })).mutation(({ input }) => addPost(input)),
});

Nesting Routers

Combine sub-routers under namespaces in the main router.

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

Calling Nested Procedures

The client path mirrors the nesting structure.

await client.user.list.query();
await client.post.create.mutate({ title: "Hi" });

Deep Nesting

You can nest several levels for clear domains.

export const appRouter = router({
  admin: router({
    user: userRouter,
    report: reportRouter,
  }),
});

Type Inference Flows Through

No matter how deeply you nest, full type inference and autocomplete reach every procedure on the client.

Merging vs Nesting

Nesting puts a router under a namespace key. Merging with t.mergeRouters flattens two routers into one with no extra namespace.

const merged = t.mergeRouters(userRouter, postRouter);

When to Merge

Merge when procedures naturally belong at the same level; nest when you want clear domain prefixes like user.* and post.*.

Avoiding Name Collisions

Merging two routers that share a procedure name causes a conflict. Nesting avoids this because each lives under its own namespace.

Keeping Files Small

Place each sub-router in its own file and import them into one root router file. This keeps modules focused and makes the API structure easy to navigate.

Quick Check

Test your router composition knowledge.

Recap

You learned to scale a tRPC API cleanly:

Build small sub-routers per domain
Nest them under namespaces for clear paths
Merge when procedures share a level

Composition keeps large APIs organized while preserving full type safety.

Perguntas Frequentes

A aula “Mesclando e aninhando roteadores” é grátis?

Sim — o texto completo de “Mesclando e aninhando roteadores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de tRPC End-to-End Type Safe APIs, atualize para CoddyKit PRO. O curso de tRPC End-to-End Type Safe APIs inclui 4 aulas no total.

O que vou aprender em “Mesclando e aninhando roteadores”?

Aprenda a organizar uma API tRPC em crescimento compondo vários sub-roteadores em um único roteador de aplicação aninhado. Você pratica tRPC End-to-End Type Safe APIs com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar tRPC End-to-End Type Safe APIs?

Nenhuma experiência prévia é necessária. tRPC End-to-End Type Safe APIs no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Mesclando e aninhando roteadores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de tRPC End-to-End Type Safe APIs?

Sim. Cada aula de tRPC End-to-End Type Safe APIs inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para tRPC End-to-End Type Safe APIs