davepoon/buildwithclaude / plugins/nextjs-expert/skills/server-components
server-components
VerifiedThis skill should be used when the user asks about "Server Components", "Client Components", "'use client' directive", "when to use server vs client", "RSC patterns", "component composition", "data fetching in components", or needs guidance on React Server Components architecture in Next.js.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 5.9 KB |
| examples/data-fetching-patterns.md | markdown | 8.6 KB |
| references/composition-patterns.md | markdown | 8.3 KB |
| references/server-vs-client.md | markdown | 7.3 KB |
references/composition-patterns.md
View on GitHub# Server and Client Component Composition Patterns
## The Children Pattern
Pass Server Components to Client Components via children:
```tsx
// components/modal.tsx (Client)
'use client'
import { useState } from 'react'
export function Modal({ children }: { children: React.ReactNode }) {
const [isOpen, setIsOpen] = useState(false)
return (
<>
<button onClick={() => setIsOpen(true)}>Open</button>
{isOpen && (
<div className="modal">
{children} {/* Server-rendered! */}
<button onClick={() => setIsOpen(false)}>Close</button>
</div>
)}
</>
)
}
// app/page.tsx (Server)
import { Modal } from '@/components/modal'
import { ServerContent } from '@/components/server-content'
export default async function Page() {
const data = await getData() // Fetched on server
return (
<Modal>
<ServerContent data={data} /> {/* Rendered on server */}
</Modal>
)
}
```
## The Slots Pattern
Multiple render props for complex layouts:
```tsx
// components/dashboard-shell.tsx (Client)
'use client'
import { useState } from 'react'
interface DashboardShellProps {
header: React.ReactNode
sidebar: React.ReactNode
main: React.ReactNode
}
export function DashboardShell({ header, sidebar, main }: DashboardShellProps) {
const [sidebarOpen, setSidebarOpen] = useState(true)
return (
<div className="flex flex-col h-screen">
<header className="h-16 border-b">{header}</header>
<div className="flex flex-1">
{sidebarOpen && <aside className="w-64">{sidebar}</aside>}
<main className="flex-1">{main}</main>
</div>
</div>
)
}
// app/dashboard/page.tsx (Server)
export default async function DashboardPage() {
const user = await getUser()
const stats = await getStats()
const navigation = await getNavigation()
return (
<DashboardShell
header={<UserHeader user={user} />}
sidebar={<Navigation items={navigation} />}
main={<DashboardContent stats={stats} />}
/>
)
}
```
## Provider Pattern
Wrap providers at the boundary:
```tsx
// app/providers.tsx (Client)
'use client'
import { ThemeProvider } from 'next-themes'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
const queryClient = new QueryClient()
export function Providers({ children }: { children: React.ReactNode }) {
return (
<QueryClientProvider client={queryClient}>
<ThemeProvider attribute="class" defaultTheme="system">
{children}
</ThemeProvider>
</QueryClientProvider>
)
}
// app/layout.tsx (Server)
import { Providers } from './providers'
export default function RootLayout({
children,
}: {
children: React.ReactNode
}) {
return (
<html lang="en">
<body>
<Providers>{children}</Providers>
</body>
</html>
)
}
```
## Data Down, Actions Up
Pass server data down, use Server Actions for mutations:
```tsx
// app/posts/page.tsx (Server)
import { PostList } from '@/components/post-list'
import { deletePost } from '@/actions/posts'
export default async function PostsPage() {
const posts = await db.post.findMany()
return <PostList posts={posts} onDelete={deletePost} />
}
// components/post-list.tsx (Client)
'use client'
import { useTransition } from 'react'
interface Post {
id: string
title: string
}
interface PostListProps {
posts: Post[]
onDelete: (id: string) => Promise<void>
}
export function PostList({ posts, onDelete }: PostListProps) {
const [isPending, startTransition] = useTransition()
const handleDelete = (id: string) => {
startTransition(async () => {
await onDelete(id)
})
}
return (
<ul>
{posts.map(post => (
<li key={post.id}>
{post.title}
<button
onClick={() => handleDelete(post.id)}
disabled={isPending}
>
Delete
</button>
</li>
))}
</ul>
)
}
// actions/posts.ts
'use server'
import { revalidatePath } from 'next/cache'
export async function deletePost(id: string) {
await db.post.delete({ where: { id } })
revalidatePath('/posts')
}
```
## Lifting State Up
Move state to closest Client Component ancestor:
```tsx
// Before: Too much client code
'use client'
export function ProductPage() {
const [selectedSize, setSelectedSize] = useState('M')
const product = useProduct() // Client fetch
return (
<div>
<h1>{product.title}</h1> {/* Could be server */}
<p>{product.description}</p> {/* Could be server */}
<SizeSelector value={selectedSize} onChange={setSelectedSize} />
<AddToCart productId={product.id} size={selectedSize} />
</div>
)
}
// After: Minimal client code
// app/products/[id]/page.tsx (Server)
export default async function ProductPage({ params }) {
const { id } = await params
const product = await getProduct(id)
return (
<div>
<h1>{product.title}</h1>
<p>{product.description}</p>
<ProductActions productId={product.id} />
</div>
)
}
// components/product-actions.tsx (Client)
'use client'
export function ProductActions({ productId }: { productId: string }) {
const [selectedSize, setSelectedSize] = useState('M')
return (
<>
<SizeSelector value={selectedSize} onChange={setSelectedSize} />
<AddToCart productId={productId} size={selectedSize} />
</>
)
}
```
## Shared Data Pattern
Use React's cache() for shared data:
```tsx
// lib/get-user.ts
import { cache } from 'react'
export const getUser = cache(async () => {
const response = await fetch('/api/user')
return response.json()
})
// app/layout.tsx (Server)
import { getUser } from '@/lib/get-user'
export default async function Layout({ children }) {
const user = await getUser() // Cached
return (
<div>
<header>Welcome, {user.name}</header>
{children}
</div>
)
}
// app/page.tsx (Server)
import { getUser } from '@/lib/get-user'
export default async function Page() {
const user = await getUser() // Returns cached result
return <h1>Hello, {user.name}!</h1>
}
```
## Context for Client Tree
Context only works in Client Components:
```tsx
// context/cart-context.tsx (Client)
'use client'
import { createContext, useContext, useState } from 'react'
interface CartContextType {
items: string[]
addItem: (id: string) => void
}
const CartContext = createContext<CartContextType | null>(null)
export function CartProvider({ children }: { children: React.ReactNode }) {
const [items, setItems] = useState<string[]>([])
const addItem = (id: string) => {
setItems(prev => [...prev, id])
}
return (
<CartContext.Provider value={{ items, addItem }}>
{children}
</CartContext.Provider>
)
}
export function useCart() {
const context = useContext(CartContext)
if (!context) throw new Error('useCart must be used within CartProvider')
return context
}
// components/add-to-cart.tsx (Client)
'use client'
import { useCart } from '@/context/cart-context'
export function AddToCart({ productId }: { productId: string }) {
const { addItem } = useCart()
return (
<button onClick={() => addItem(productId)}>
Add to Cart
</button>
)
}
```
## Render Props for Server Components
```tsx
// components/data-fetcher.tsx (Server)
interface DataFetcherProps<T> {
fetch: () => Promise<T>
render: (data: T) => React.ReactNode
}
export async function DataFetcher<T>({ fetch, render }: DataFetcherProps<T>) {
const data = await fetch()
return <>{render(data)}</>
}
// Usage in Server Component
export default function Page() {
return (
<DataFetcher
fetch={getUsers}
render={(users) => (
<ul>
{users.map(u => <li key={u.id}>{u.name}</li>)}
</ul>
)}
/>
)
}
```
## Higher-Order Component Pattern
```tsx
// lib/with-auth.tsx
import { auth } from '@/auth'
import { redirect } from 'next/navigation'
export function withAuth<P extends object>(
Component: React.ComponentType<P & { user: User }>
) {
return async function AuthenticatedComponent(props: P) {
const session = await auth()
if (!session?.user) {
redirect('/login')
}
return <Component {...props} user={session.user} />
}
}
// app/dashboard/page.tsx
import { withAuth } from '@/lib/with-auth'
function DashboardPage({ user }: { user: User }) {
return <h1>Welcome, {user.name}</h1>
}
export default withAuth(DashboardPage)
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |