tRPC End-to-End Type Safe APIs · Lekcja

Łączenie i zagnieżdżanie routerów

Dowiedz się, jak organizować rozrastające się API tRPC, łącząc wiele podrzędnych routerów w jeden zagnieżdżony router aplikacji.

Lekcja 4 z 413 kroki

Łączenie i zagnieżdżanie routerów to bezpłatna lekcja tRPC End-to-End Type Safe APIs na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej tRPC End-to-End Type Safe APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs tRPC End-to-End Type Safe APIs zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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.

Odpowiedz w interaktywnej lekcji

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.

Bezpłatny start

Ucz się tRPC End-to-End Type Safe APIs dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 10
Lekcje: 40

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Łączenie i zagnieżdżanie routerów” jest bezpłatna?

Tak — pełny tekst „Łączenie i zagnieżdżanie routerów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu tRPC End-to-End Type Safe APIs, przejdź na CoddyKit PRO. Kurs tRPC End-to-End Type Safe APIs zawiera 4 lekcji w sumie.

Co nauczysz się w „Łączenie i zagnieżdżanie routerów”?

Dowiedz się, jak organizować rozrastające się API tRPC, łącząc wiele podrzędnych routerów w jeden zagnieżdżony router aplikacji. Ćwiczysz tRPC End-to-End Type Safe APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć tRPC End-to-End Type Safe APIs?

Nie wymagamy żadnego doświadczenia. tRPC End-to-End Type Safe APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Łączenie i zagnieżdżanie routerów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji tRPC End-to-End Type Safe APIs?

Tak. Każda lekcja tRPC End-to-End Type Safe APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do tRPC End-to-End Type Safe APIs