Komponenty serwerowe i pobieranie danych tRPC
Poznają Państwo sposób bezpośredniego pobierania danych w komponentach serwerowych Next.js za pomocą tRPC w celu uzyskania optymalnej wydajności.
Komponenty serwerowe i pobieranie danych tRPC to bezpłatna lekcja tRPC End-to-End Type Safe APIs na CoddyKit. To lekcja 3 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.
Intro to Server Components
Welcome! In Next.js, Server Components (SCs) are a powerful feature that lets you render parts of your UI directly on the server.
This means less JavaScript sent to the browser, faster initial page loads, and improved SEO!
Data Fetching on the Server
A key benefit of Server Components is their ability to fetch data directly on the server. Unlike Client Components, SCs don't need to make API calls from the browser.
This allows data to be fetched and rendered before the page is even sent to the client, boosting performance.
tRPC's Role in SCs
This is where tRPC shines! When used in Server Components, tRPC allows you to call your backend procedures directly, without any HTTP overhead.
It's like importing a local function, but with end-to-end type safety guaranteed by tRPC and TypeScript.
Build a Server-Side Caller
To fetch data in Server Components, we need a special tRPC client that calls procedures directly, bypassing HTTP. This is often called a "server-side caller" or "server client."
It uses your tRPC router directly to ensure type safety without network overhead. Here's a simplified example:
import { appRouter } from '@/server/routers/_app';
import { createCallerFactory } from '@trpc/server';
// Create a tRPC caller that can be used on the server
const createCaller = createCallerFactory(appRouter);
export const serverClient = createCaller({});
// Context can be passed here, e.g., createCaller({ user: currentUser })Fetching Data in an SC
Now, let's use our serverClient to fetch data directly within a Next.js Server Component. Notice how it looks just like calling a local function!
The data is fetched on the server before the component is rendered and sent to the client.
// app/page.tsx (Server Component)
import { serverClient } from '@/utils/trpc';
export default async function HomePage() {
const posts = await serverClient.post.list(); // Call a tRPC query
return (
<div>
<h1>Latest Posts</h1>
<ul>
{posts.map(post => (
<li key={post.id}>{post.title}</li>
))}
</ul>
</div>
);
}SC Data to Client Components
Server Components often fetch data, but UI interactions happen in Client Components. You can pass the fetched data as props from an SC to a CC.
Remember to mark client components with "use client" at the top.
// components/PostList.tsx (Client Component)
"use client";
interface Post {
id: string;
title: string;
}
export function PostList({ posts }: { posts: Post[] }) {
// Client-side interactions can happen here
return (
<ul>
{posts.map(post => (
<li key={post.id}>{post.title}</li>
))}
</ul>
);
}
// app/page.tsx (Server Component, updated)
import { serverClient } from '@/utils/trpc';
import { PostList } from '@/components/PostList';
export default async function HomePage() {
const posts = await serverClient.post.list();
return (
<div>
<h1>Latest Posts</h1>
<PostList posts={posts} /> {/* Pass data as props */}
</div>
);
}Queries with Input Parameters
Just like regular tRPC queries, you can pass input parameters to your server-side tRPC calls. This is useful for fetching specific data based on URL parameters or other server-side logic.
// app/posts/[id]/page.tsx (Server Component)
import { serverClient } from '@/utils/trpc';
interface PostPageProps {
params: { id: string };
}
export default async function PostPage({ params }: PostPageProps) {
const { id } = params;
const post = await serverClient.post.byId({ id }); // Pass 'id' as input
if (!post) {
return <div>Post not found!</div>;
}
return (
<div>
<h1>{post.title}</h1>
<p>{post.content}</p>
</div>
);
}Graceful Error Handling
Errors thrown by your tRPC procedures on the server will propagate up to the Server Component. You can use standard JavaScript try...catch blocks to handle them.
This ensures your application remains robust even if data fetching fails.
// app/page.tsx (Server Component with error handling)
import { serverClient } from '@/utils/trpc';
export default async function HomePage() {
let posts = [];
let error = null;
try {
posts = await serverClient.post.list();
} catch (e) {
console.error("Failed to fetch posts:", e);
error = "Could not load posts. Please try again.";
}
return (
<div>
<h1>Latest Posts</h1>
{error && <p style={{ color: 'red' }}>{error}</p>}
<ul>
{posts.map(post => (
<li key={post.id}>{post.title}</li>
))}
</ul>
</div>
);
}SC vs. CC Data Fetching
When should you use Server Components for data fetching versus Client Components (e.g., with React Query)?
- Server Components: Ideal for initial data, SEO, static/server-rendered content, and reducing client bundle size.
- Client Components: Best for interactive data, real-time updates, user-specific data after initial load, and mutations.
Often, you'll use a mix of both!
Server Component Data Fetch
Consider a Next.js App Router project using tRPC. You need to display a list of products on the initial page load, which should be fast and SEO-friendly.
Recap: SCs & tRPC
In this lesson, we explored fetching data directly within Next.js Server Components using tRPC.
- We learned to create a server-side tRPC caller.
- Fetched data directly in Server Components.
- Passed fetched data as props to Client Components.
- Handled query parameters and errors in SCs.
- Understood the distinction between SC and CC data fetching.
This approach combines tRPC's type safety with Server Components' performance benefits for robust and efficient data fetching.
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
Często zadawane pytania
Czy lekcja „Komponenty serwerowe i pobieranie danych tRPC” jest bezpłatna?
Tak — pełny tekst „Komponenty serwerowe i pobieranie danych tRPC” 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 „Komponenty serwerowe i pobieranie danych tRPC”?
Poznają Państwo sposób bezpośredniego pobierania danych w komponentach serwerowych Next.js za pomocą tRPC w celu uzyskania optymalnej wydajności. Ć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 3 z 4.
Ile czasu zajmuje lekcja „Komponenty serwerowe i pobieranie danych tRPC”?
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
- tRPC z Next.js App Router
- Zaawansowana integracja React Query
- Komponenty serwerowe i pobieranie danych tRPC
- Optymistyczne aktualizacje z mutacjami tRPC