mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
hanzoskills.com/llms.txt now opens with the install line, the API reference index and the company index, so an agent that lands on any one of the three can find the rest. robots.txt claimed 537 documents while llms.txt counts 920. The number is gone from robots.txt; llms.txt derives it. public/ is regenerated from scripts/site.py, which it had fallen behind: the copy-prompt menu and agent bar were in the generator and not in the committed pages. tests/site.mjs passes against the result. Co-authored-by: Hanzo Dev <[email protected]>
767 lines
30 KiB
HTML
767 lines
30 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>frontend-react-data-fetching</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="alternate" type="text/markdown" href="/frontend-react-data-fetching.md">
|
|
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/frontend-react-data-fetching">
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/frontend-react-data-fetching.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>frontend-react-data-fetching</h1><p class="lede">Scope: SWR, React Query, Server Actions, caching strategies, optimistic updates Lines: ~310 Last Updated: 2025-10-18</p><h1>React Data Fetching</h1>
|
|
<p><strong>Scope</strong>: SWR, React Query, Server Actions, caching strategies, optimistic updates <strong>Lines</strong>: ~310 <strong>Last Updated</strong>: 2025-10-18</p>
|
|
<h2>When to Use This Skill</h2>
|
|
<p>Activate this skill when:</p>
|
|
<ul><li>Fetching data from APIs</li><li>Implementing caching strategies</li><li>Handling loading and error states</li><li>Optimistic UI updates</li><li>Infinite scrolling/pagination</li><li>Real-time data synchronization</li><li>Choosing between SWR and React Query</li></ul>
|
|
<h2>Core Concepts</h2>
|
|
<h3>Client vs Server Data</h3>
|
|
<p><strong>Client State</strong> - UI state, form inputs, modals</p>
|
|
<pre><code class="lang-tsx">const [isOpen, setIsOpen] = useState(false);</code></pre>
|
|
<p><strong>Server State</strong> - Data from API, database</p>
|
|
<pre><code class="lang-tsx">const { data: posts } = useSWR('/api/posts');</code></pre>
|
|
<p><strong>Key differences</strong>:</p>
|
|
<ul><li>Server state is async, remote, shared</li><li>Server state can be stale</li><li>Server state needs caching, revalidation</li><li>Server state is owned by server</li></ul>
|
|
<hr>
|
|
<h2>SWR (Stale-While-Revalidate)</h2>
|
|
<h3>Basic Usage</h3>
|
|
<pre><code class="lang-tsx">import useSWR from 'swr';
|
|
|
|
const fetcher = (url: string) => fetch(url).then(res => res.json());
|
|
|
|
function Profile() {
|
|
const { data, error, isLoading } = useSWR('/api/user', fetcher);
|
|
|
|
if (isLoading) return <div>Loading...</div>;
|
|
if (error) return <div>Failed to load</div>;
|
|
|
|
return <div>Hello {data.name}!</div>;
|
|
}</code></pre>
|
|
<h3>Global Configuration</h3>
|
|
<pre><code class="lang-tsx">// app/layout.tsx or _app.tsx
|
|
import { SWRConfig } from 'swr';
|
|
|
|
const fetcher = (url: string) => fetch(url).then(res => {
|
|
if (!res.ok) throw new Error('API error');
|
|
return res.json();
|
|
});
|
|
|
|
export default function App({ children }) {
|
|
return (
|
|
<SWRConfig value={{
|
|
fetcher,
|
|
revalidateOnFocus: false,
|
|
revalidateOnReconnect: true,
|
|
dedupingInterval: 2000,
|
|
}}>
|
|
{children}
|
|
</SWRConfig>
|
|
);
|
|
}</code></pre>
|
|
<h3>Mutations</h3>
|
|
<pre><code class="lang-tsx">function UpdateProfile() {
|
|
const { data: user, mutate } = useSWR('/api/user', fetcher);
|
|
|
|
const updateName = async (newName: string) => {
|
|
// Optimistic update
|
|
mutate({ ...user, name: newName }, false);
|
|
|
|
// API call
|
|
await fetch('/api/user', {
|
|
method: 'PATCH',
|
|
body: JSON.stringify({ name: newName }),
|
|
});
|
|
|
|
// Revalidate
|
|
mutate();
|
|
};
|
|
|
|
return (
|
|
<input
|
|
value={user?.name}
|
|
onChange={(e) => updateName(e.target.value)}
|
|
/>
|
|
);
|
|
}</code></pre>
|
|
<h3>Dependent Queries</h3>
|
|
<pre><code class="lang-tsx">function UserPosts({ userId }: { userId: string }) {
|
|
// First fetch user
|
|
const { data: user } = useSWR(`/api/users/${userId}`, fetcher);
|
|
|
|
// Then fetch user's posts (only when user is loaded)
|
|
const { data: posts } = useSWR(
|
|
user ? `/api/users/${user.id}/posts` : null,
|
|
fetcher
|
|
);
|
|
|
|
if (!user) return <div>Loading user...</div>;
|
|
if (!posts) return <div>Loading posts...</div>;
|
|
|
|
return <div>{posts.map(post => <div key={post.id}>{post.title}</div>)}</div>;
|
|
}</code></pre>
|
|
<h3>Pagination</h3>
|
|
<pre><code class="lang-tsx">function PostList() {
|
|
const [page, setPage] = useState(1);
|
|
|
|
const { data, isLoading } = useSWR(
|
|
`/api/posts?page=${page}&limit=10`,
|
|
fetcher
|
|
);
|
|
|
|
return (
|
|
<div>
|
|
{data?.posts.map(post => <div key={post.id}>{post.title}</div>)}
|
|
|
|
<button onClick={() => setPage(page - 1)} disabled={page === 1}>
|
|
Previous
|
|
</button>
|
|
<button onClick={() => setPage(page + 1)}>
|
|
Next
|
|
</button>
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<h3>Infinite Scroll</h3>
|
|
<pre><code class="lang-tsx">import useSWRInfinite from 'swr/infinite';
|
|
|
|
function InfinitePostList() {
|
|
const getKey = (pageIndex: number, previousPageData: any) => {
|
|
// Reached the end
|
|
if (previousPageData && !previousPageData.posts.length) return null;
|
|
|
|
// First page
|
|
return `/api/posts?page=${pageIndex + 1}&limit=10`;
|
|
};
|
|
|
|
const { data, size, setSize, isLoading } = useSWRInfinite(getKey, fetcher);
|
|
|
|
const posts = data ? data.flatMap(page => page.posts) : [];
|
|
const isLoadingMore = isLoading || (size > 0 && data && typeof data[size - 1] === 'undefined');
|
|
const isEmpty = data?.[0]?.posts.length === 0;
|
|
const isReachingEnd = isEmpty || (data && data[data.length - 1]?.posts.length < 10);
|
|
|
|
return (
|
|
<div>
|
|
{posts.map(post => <div key={post.id}>{post.title}</div>)}
|
|
|
|
{!isReachingEnd && (
|
|
<button onClick={() => setSize(size + 1)} disabled={isLoadingMore}>
|
|
{isLoadingMore ? 'Loading...' : 'Load More'}
|
|
</button>
|
|
)}
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>React Query (TanStack Query)</h2>
|
|
<h3>Basic Usage</h3>
|
|
<pre><code class="lang-tsx">import { useQuery } from '@tanstack/react-query';
|
|
|
|
function Posts() {
|
|
const { data, isLoading, error } = useQuery({
|
|
queryKey: ['posts'],
|
|
queryFn: async () => {
|
|
const res = await fetch('/api/posts');
|
|
if (!res.ok) throw new Error('Failed to fetch');
|
|
return res.json();
|
|
},
|
|
});
|
|
|
|
if (isLoading) return <div>Loading...</div>;
|
|
if (error) return <div>Error: {error.message}</div>;
|
|
|
|
return (
|
|
<div>
|
|
{data.map((post: Post) => (
|
|
<div key={post.id}>{post.title}</div>
|
|
))}
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<h3>Query Client Setup</h3>
|
|
<pre><code class="lang-tsx">// app/providers.tsx
|
|
'use client';
|
|
|
|
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
|
|
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
|
|
import { useState } from 'react';
|
|
|
|
export function QueryProvider({ children }: { children: React.ReactNode }) {
|
|
const [queryClient] = useState(() => new QueryClient({
|
|
defaultOptions: {
|
|
queries: {
|
|
staleTime: 60 * 1000, // 1 minute
|
|
refetchOnWindowFocus: false,
|
|
},
|
|
},
|
|
}));
|
|
|
|
return (
|
|
<QueryClientProvider client={queryClient}>
|
|
{children}
|
|
<ReactQueryDevtools initialIsOpen={false} />
|
|
</QueryClientProvider>
|
|
);
|
|
}</code></pre>
|
|
<h3>Mutations</h3>
|
|
<pre><code class="lang-tsx">import { useMutation, useQueryClient } from '@tanstack/react-query';
|
|
|
|
function CreatePost() {
|
|
const queryClient = useQueryClient();
|
|
|
|
const mutation = useMutation({
|
|
mutationFn: async (newPost: { title: string; content: string }) => {
|
|
const res = await fetch('/api/posts', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(newPost),
|
|
});
|
|
if (!res.ok) throw new Error('Failed to create');
|
|
return res.json();
|
|
},
|
|
onSuccess: () => {
|
|
// Invalidate and refetch
|
|
queryClient.invalidateQueries({ queryKey: ['posts'] });
|
|
},
|
|
});
|
|
|
|
return (
|
|
<button
|
|
onClick={() => mutation.mutate({ title: 'New Post', content: 'Content' })}
|
|
disabled={mutation.isPending}
|
|
>
|
|
{mutation.isPending ? 'Creating...' : 'Create Post'}
|
|
</button>
|
|
);
|
|
}</code></pre>
|
|
<h3>Optimistic Updates</h3>
|
|
<pre><code class="lang-tsx">function UpdatePost({ post }: { post: Post }) {
|
|
const queryClient = useQueryClient();
|
|
|
|
const mutation = useMutation({
|
|
mutationFn: async (updatedPost: Post) => {
|
|
const res = await fetch(`/api/posts/${post.id}`, {
|
|
method: 'PUT',
|
|
body: JSON.stringify(updatedPost),
|
|
});
|
|
return res.json();
|
|
},
|
|
|
|
// Optimistic update
|
|
onMutate: async (updatedPost) => {
|
|
// Cancel outgoing refetches
|
|
await queryClient.cancelQueries({ queryKey: ['posts', post.id] });
|
|
|
|
// Snapshot previous value
|
|
const previousPost = queryClient.getQueryData(['posts', post.id]);
|
|
|
|
// Optimistically update cache
|
|
queryClient.setQueryData(['posts', post.id], updatedPost);
|
|
|
|
// Return context with snapshot
|
|
return { previousPost };
|
|
},
|
|
|
|
// Rollback on error
|
|
onError: (err, updatedPost, context) => {
|
|
queryClient.setQueryData(['posts', post.id], context?.previousPost);
|
|
},
|
|
|
|
// Always refetch after error or success
|
|
onSettled: () => {
|
|
queryClient.invalidateQueries({ queryKey: ['posts', post.id] });
|
|
},
|
|
});
|
|
|
|
return (
|
|
<button onClick={() => mutation.mutate({ ...post, title: 'Updated' })}>
|
|
Update
|
|
</button>
|
|
);
|
|
}</code></pre>
|
|
<h3>Pagination</h3>
|
|
<pre><code class="lang-tsx">function PaginatedPosts() {
|
|
const [page, setPage] = useState(1);
|
|
|
|
const { data, isLoading, isPlaceholderData } = useQuery({
|
|
queryKey: ['posts', page],
|
|
queryFn: async () => {
|
|
const res = await fetch(`/api/posts?page=${page}&limit=10`);
|
|
return res.json();
|
|
},
|
|
placeholderData: (previousData) => previousData, // Keep previous data while fetching
|
|
});
|
|
|
|
return (
|
|
<div>
|
|
{data?.posts.map((post: Post) => (
|
|
<div key={post.id}>{post.title}</div>
|
|
))}
|
|
|
|
<button
|
|
onClick={() => setPage(page - 1)}
|
|
disabled={page === 1}
|
|
>
|
|
Previous
|
|
</button>
|
|
<button
|
|
onClick={() => setPage(page + 1)}
|
|
disabled={isPlaceholderData || !data?.hasMore}
|
|
>
|
|
Next
|
|
</button>
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<h3>Infinite Queries</h3>
|
|
<pre><code class="lang-tsx">import { useInfiniteQuery } from '@tanstack/react-query';
|
|
|
|
function InfinitePosts() {
|
|
const {
|
|
data,
|
|
fetchNextPage,
|
|
hasNextPage,
|
|
isFetchingNextPage,
|
|
} = useInfiniteQuery({
|
|
queryKey: ['posts'],
|
|
queryFn: async ({ pageParam = 1 }) => {
|
|
const res = await fetch(`/api/posts?page=${pageParam}&limit=10`);
|
|
return res.json();
|
|
},
|
|
getNextPageParam: (lastPage, pages) => {
|
|
return lastPage.hasMore ? pages.length + 1 : undefined;
|
|
},
|
|
initialPageParam: 1,
|
|
});
|
|
|
|
const posts = data?.pages.flatMap(page => page.posts) ?? [];
|
|
|
|
return (
|
|
<div>
|
|
{posts.map((post: Post) => (
|
|
<div key={post.id}>{post.title}</div>
|
|
))}
|
|
|
|
{hasNextPage && (
|
|
<button onClick={() => fetchNextPage()} disabled={isFetchingNextPage}>
|
|
{isFetchingNextPage ? 'Loading...' : 'Load More'}
|
|
</button>
|
|
)}
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>Next.js Server Actions</h2>
|
|
<h3>Basic Server Action</h3>
|
|
<pre><code class="lang-tsx">// app/actions.ts
|
|
'use server';
|
|
|
|
import { revalidatePath } from 'next/cache';
|
|
|
|
export async function createPost(formData: FormData) {
|
|
const title = formData.get('title') as string;
|
|
const content = formData.get('content') as string;
|
|
|
|
await prisma.post.create({
|
|
data: { title, content }
|
|
});
|
|
|
|
revalidatePath('/posts');
|
|
}
|
|
|
|
// app/posts/new/page.tsx
|
|
import { createPost } from '@/app/actions';
|
|
|
|
export default function NewPostPage() {
|
|
return (
|
|
<form action={createPost}>
|
|
<input name="title" required />
|
|
<textarea name="content" required />
|
|
<button type="submit">Create</button>
|
|
</form>
|
|
);
|
|
}</code></pre>
|
|
<h3>Client-Side with useFormStatus</h3>
|
|
<pre><code class="lang-tsx">// app/components/SubmitButton.tsx
|
|
'use client';
|
|
|
|
import { useFormStatus } from 'react-dom';
|
|
|
|
export function SubmitButton() {
|
|
const { pending } = useFormStatus();
|
|
|
|
return (
|
|
<button type="submit" disabled={pending}>
|
|
{pending ? 'Creating...' : 'Create Post'}
|
|
</button>
|
|
);
|
|
}
|
|
|
|
// app/posts/new/page.tsx
|
|
import { createPost } from '@/app/actions';
|
|
import { SubmitButton } from '@/app/components/SubmitButton';
|
|
|
|
export default function NewPostPage() {
|
|
return (
|
|
<form action={createPost}>
|
|
<input name="title" required />
|
|
<textarea name="content" required />
|
|
<SubmitButton />
|
|
</form>
|
|
);
|
|
}</code></pre>
|
|
<h3>useFormState for Validation</h3>
|
|
<pre><code class="lang-tsx">// app/actions.ts
|
|
'use server';
|
|
|
|
export async function createPost(prevState: any, formData: FormData) {
|
|
const title = formData.get('title') as string;
|
|
const content = formData.get('content') as string;
|
|
|
|
// Validation
|
|
if (!title || title.length < 3) {
|
|
return { error: 'Title must be at least 3 characters' };
|
|
}
|
|
|
|
await prisma.post.create({ data: { title, content } });
|
|
|
|
return { success: true };
|
|
}
|
|
|
|
// app/components/PostForm.tsx
|
|
'use client';
|
|
|
|
import { useFormState } from 'react-dom';
|
|
import { createPost } from '@/app/actions';
|
|
|
|
export function PostForm() {
|
|
const [state, formAction] = useFormState(createPost, null);
|
|
|
|
return (
|
|
<form action={formAction}>
|
|
<input name="title" required />
|
|
{state?.error && <p className="error">{state.error}</p>}
|
|
<textarea name="content" required />
|
|
<button type="submit">Create</button>
|
|
</form>
|
|
);
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>Caching Strategies</h2>
|
|
<h3>Stale-While-Revalidate (SWR Pattern)</h3>
|
|
<pre><code class="lang-tsx">// Return stale data immediately, revalidate in background
|
|
const { data } = useSWR('/api/posts', fetcher, {
|
|
revalidateOnFocus: true, // Revalidate when window regains focus
|
|
revalidateOnReconnect: true, // Revalidate when network reconnects
|
|
dedupingInterval: 2000, // Dedupe requests within 2 seconds
|
|
});</code></pre>
|
|
<h3>Cache and Network (React Query)</h3>
|
|
<pre><code class="lang-tsx">const { data } = useQuery({
|
|
queryKey: ['posts'],
|
|
queryFn: fetchPosts,
|
|
staleTime: 5 * 60 * 1000, // 5 minutes before stale
|
|
cacheTime: 10 * 60 * 1000, // 10 minutes in cache
|
|
refetchOnWindowFocus: true,
|
|
refetchOnReconnect: true,
|
|
});</code></pre>
|
|
<h3>Time-Based Revalidation (Next.js)</h3>
|
|
<pre><code class="lang-tsx">// app/posts/page.tsx
|
|
export const revalidate = 60; // Revalidate every 60 seconds
|
|
|
|
async function getPosts() {
|
|
const res = await fetch('https://api.example.com/posts', {
|
|
next: { revalidate: 60 }
|
|
});
|
|
return res.json();
|
|
}
|
|
|
|
export default async function PostsPage() {
|
|
const posts = await getPosts();
|
|
return <div>{posts.map(post => <div key={post.id}>{post.title}</div>)}</div>;
|
|
}</code></pre>
|
|
<h3>On-Demand Revalidation (Next.js)</h3>
|
|
<pre><code class="lang-tsx">// app/actions.ts
|
|
'use server';
|
|
|
|
import { revalidatePath, revalidateTag } from 'next/cache';
|
|
|
|
export async function createPost(data: any) {
|
|
await prisma.post.create({ data });
|
|
|
|
// Revalidate specific paths
|
|
revalidatePath('/posts');
|
|
revalidatePath('/');
|
|
|
|
// Or revalidate by tag
|
|
revalidateTag('posts');
|
|
}
|
|
|
|
// Fetch with tag
|
|
async function getPosts() {
|
|
const res = await fetch('https://api.example.com/posts', {
|
|
next: { tags: ['posts'] }
|
|
});
|
|
return res.json();
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>SWR vs React Query</h2>
|
|
<h3>Comparison</h3>
|
|
<p>| Feature | SWR | React Query | |---------|-----|-------------| | <strong>Bundle Size</strong> | 4.3kb | 12.9kb | | <strong>Complexity</strong> | Simple | More features | | <strong>DevTools</strong> | No | Yes | | <strong>Mutations</strong> | Manual | Built-in | | <strong>TypeScript</strong> | Good | Excellent | | <strong>Best For</strong> | Simple apps, Next.js | Complex apps, large teams |</p>
|
|
<h3>When to Use SWR</h3>
|
|
<pre><code>✅ Next.js projects (official Vercel library)
|
|
✅ Simple data fetching needs
|
|
✅ Small bundle size priority
|
|
✅ Straightforward caching
|
|
✅ Quick setup</code></pre>
|
|
<h3>When to Use React Query</h3>
|
|
<pre><code>✅ Complex mutations
|
|
✅ Optimistic updates
|
|
✅ DevTools needed
|
|
✅ Pagination/infinite scroll
|
|
✅ Large apps with many queries
|
|
✅ Advanced caching strategies</code></pre>
|
|
<hr>
|
|
<h2>Quick Reference</h2>
|
|
<h3>SWR Basic Pattern</h3>
|
|
<pre><code class="lang-tsx">const { data, error, isLoading, mutate } = useSWR(key, fetcher, options);
|
|
|
|
// Mutate
|
|
mutate(newData, false); // Optimistic
|
|
mutate(); // Revalidate</code></pre>
|
|
<h3>React Query Basic Pattern</h3>
|
|
<pre><code class="lang-tsx">const { data, error, isLoading } = useQuery({
|
|
queryKey: ['key'],
|
|
queryFn: fetchFn,
|
|
});
|
|
|
|
const mutation = useMutation({
|
|
mutationFn: createFn,
|
|
onSuccess: () => queryClient.invalidateQueries({ queryKey: ['key'] }),
|
|
});</code></pre>
|
|
<h3>Server Actions Pattern</h3>
|
|
<pre><code class="lang-tsx">'use server';
|
|
export async function action(formData: FormData) {
|
|
// Mutation
|
|
revalidatePath('/path');
|
|
}
|
|
|
|
// Client
|
|
<form action={action}>...</form></code></pre>
|
|
<hr>
|
|
<h2>Common Anti-Patterns</h2>
|
|
<p>❌ <strong>Fetching in useEffect</strong>: Use SWR/React Query instead ✅ Dedicated data fetching library</p>
|
|
<p>❌ <strong>Global state for server data</strong>: Server state !== client state ✅ Keep server data in SWR/React Query cache</p>
|
|
<p>❌ <strong>No loading/error states</strong>: Poor UX ✅ Always handle loading, error, empty states</p>
|
|
<p>❌ <strong>Not caching</strong>: Unnecessary refetches ✅ Use staleTime, cacheTime appropriately</p>
|
|
<hr>
|
|
<h2>Related Skills</h2>
|
|
<ul><li><code>react-state-management.md</code> - Client state (Zustand, Context)</li><li><code>nextjs-app-router.md</code> - Server Components, Server Actions</li><li><code>frontend-performance.md</code> - Request deduplication, prefetching</li><li><code>react-form-handling.md</code> - Form validation, submission</li></ul>
|
|
<hr>
|
|
<p><strong>Last Updated</strong>: 2025-10-18 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/frontend-react-data-fetching.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |