Komponen Server dan Pengambilan Data tRPC
Pahami cara mengambil data langsung di Komponen Server Next.js menggunakan tRPC untuk kinerja optimal.
Komponen Server dan Pengambilan Data tRPC adalah pelajaran tRPC End-to-End Type Safe APIs gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar tRPC End-to-End Type Safe APIs, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus tRPC End-to-End Type Safe APIs mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
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.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Komponen Server dan Pengambilan Data tRPC” gratis?
Ya — teks lengkap “Komponen Server dan Pengambilan Data tRPC” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus tRPC End-to-End Type Safe APIs, upgrade ke CoddyKit PRO. Kursus tRPC End-to-End Type Safe APIs mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Komponen Server dan Pengambilan Data tRPC”?
Pahami cara mengambil data langsung di Komponen Server Next.js menggunakan tRPC untuk kinerja optimal. Kamu berlatih tRPC End-to-End Type Safe APIs dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai tRPC End-to-End Type Safe APIs?
Tidak diperlukan pengalaman sebelumnya. tRPC End-to-End Type Safe APIs di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.
Berapa lama pelajaran “Komponen Server dan Pengambilan Data tRPC” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran tRPC End-to-End Type Safe APIs ini?
Ya. Setiap pelajaran tRPC End-to-End Type Safe APIs menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- tRPC dengan App Router Next.js
- Integrasi React Query Tingkat Lanjut
- Komponen Server dan Pengambilan Data tRPC
- Pembaruan Optimistis dengan Mutasi tRPC