Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React

React Query / TanStack Query - nowoczesne zarządzanie stanem serwerowym

8 min czytania ·
W tej lekcji6

Panel misji pokazuje profil astronauty w trzech komponentach naraz. Z useEffect i fetch każdy wyśle osobne żądanie, żaden nie zapamięta wyniku, a szybkie przełączanie profili może pokazać dane nie tej osoby. React Query, dziś pod nazwą TanStack Query, zmienia sposób, w jaki pobierasz, cache'ujesz i synchronizujesz stan serwerowy z UI. Jak system nawigacji, który sam śledzi pozycję statku, biblioteka sama zarządza stanem Twoich danych.

Dlaczego React Query zamiast useEffect + fetch?

Zobacz tradycyjne podejście i listę jego problemów w komentarzach:

// Tradycyjne podejście - WIELE PROBLEMÓW
function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    setLoading(true);
    fetch(`/api/users/${userId}`)
      .then(res => res.json())
      .then(data => {
        setUser(data);
        setLoading(false);
      })
      .catch(err => {
        setError(err);
        setLoading(false);
      });
  }, [userId]);

  // Problemy:
  // 1. Brak cachingu - te same dane pobierane wielokrotnie
  // 2. Brak automatycznego refetching
  // 3. Brak optymistycznych aktualizacji
  // 4. Brak deduplication requests
  // 5. Brak obsługi stale data
  // 6. Trzeba ręcznie zarządzać loading/error states
  // 7. Problemy z race conditions

  if (loading) return <div>Ładowanie...</div>;
  if (error) return <div>Błąd: {error.message}</div>;
  return <div>{user.name}</div>;
}

Stany loading i error prowadzisz ręcznie, a przy szybkiej zmianie userId starsza odpowiedź może nadpisać nowszą, czyli wystąpi wyścig (race condition). Nic tu nie jest cache'owane ani deduplikowane.

Ten sam komponent z TanStack Query wygląda tak:

// React Query - ELEGANCKIE I POTĘŻNE
import { useQuery } from '@tanstack/react-query';

function UserProfile({ userId }) {
  const { data: user, isPending, error } = useQuery({
    queryKey: ['user', userId],
    queryFn: () => fetch(`/api/users/${userId}`).then(res => res.json())
  });

  if (isPending) return <div>Ładowanie...</div>;
  if (error) return <div>Błąd: {error.message}</div>;
  return <div>{user.name}</div>;
}

Każde zapytanie potrzebuje dwóch rzeczy: queryKey, czyli unikalnego klucza w cache, i queryFn, funkcji zwracającej obietnicę z danymi. Klucz ['user', userId] daje każdemu użytkownikowi osobny wpis, a trzy komponenty z tym samym kluczem wyślą jedno żądanie. isPending oznacza, że danych jeszcze nie ma, więc po obu warunkach user jest już zdefiniowany. Pamiętaj, że fetch nie rzuca błędu przy statusie 404 czy 500, więc sprawdzaj res.ok, jak robi to createMission niżej.

Instalacja i podstawowa konfiguracja

Instalujesz główny pakiet i opcjonalne narzędzia deweloperskie:

# Instalacja TanStack Query (React Query v5)
npm install @tanstack/react-query
npm install @tanstack/react-query-devtools  # Opcjonalne DevTools

DevTools trafiają do paczki tylko w trybie deweloperskim, więc nie musisz ich usuwać przed wdrożeniem.

QueryClient przechowuje cache i domyślne opcje zapytań, a QueryClientProvider udostępnia go aplikacji:

// App.jsx - Setup QueryClient
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';

// Stwórz Query Client z konfiguracją
const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 1000 * 60 * 5, // 5 minut
      gcTime: 1000 * 60 * 30, // 30 minut
      refetchOnWindowFocus: true,
      refetchOnReconnect: true,
      retry: 3,
      retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
    },
  },
});

function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <YourApp />
      {/* DevTools - widoczne tylko w development */}
      <ReactQueryDevtools initialIsOpen={false} />
    </QueryClientProvider>
  );
}

staleTime mówi, jak długo dane są świeże, a gcTime (w wersji 4 cacheTime), po jakim czasie nieużywany wpis zniknie z pamięci. Domyślnie staleTime to 0, a gcTime 5 minut.

Cykl życia zapytania: status i fetchStatus

Strategia stale-while-revalidate polega na tym, że dane z cache pokazujesz od razu, nawet nieaktualne, a w tle biblioteka pobiera świeże i podmienia je w UI. Żeby wiedzieć, co dzieje się w danej chwili, TanStack Query v5 opisuje zapytanie dwoma niezależnymi polami. status mówi o danych: pending (jeszcze ich nie ma, w wersji 4 loading), error albo success. fetchStatus mówi o funkcji queryFn: fetching (właśnie działa), paused (chce pobierać, ale nie ma sieci) albo idle (nic nie robi). Wartości idle i loading w polu status już nie istnieją:

function MissionCounter() {
  const { data, status, fetchStatus, isStale } = useQuery({
    queryKey: ['missions'],
    queryFn: fetchMissions,
    staleTime: 30 * 1000, // Przez 30 sekund dane są świeże
  });

  if (status === 'pending') return <p>Pierwsze ładowanie (fetchStatus: {fetchStatus})</p>;
  if (status === 'error') return <p>Błąd pobierania misji</p>;

  return (
    <p>
      Misje: {data.length}, dane {isStale ? 'nieaktualne' : 'świeże'}
      {fetchStatus === 'fetching' && ' - odświeżanie w tle'}
    </p>
  );
}

Tak wygląda typowa droga zapytania od zamontowania komponentu:

  1. Montowanie - nie ma danych, więc status to pending, a fetchStatus to fetching. Tylko w tej sytuacji isLoading, czyli isPending && isFetching, ma wartość true.
  2. Sukces - dane dotarły: status zmienia się na success, a fetchStatus na idle. Przez czas staleTime dane są świeże i biblioteka nie wysyła nowych żądań.
  3. Dane nieaktualne - po upływie staleTime dane stają się nieaktualne (isStale ma wartość true), ale samo to niczego jeszcze nie pobiera. Domyślnie staleTime to 0, więc dane są nieaktualne od razu po pobraniu.
  4. Odświeżanie w tle - wyzwalacz, czyli nowy komponent z tym samym kluczem, powrót do karty przeglądarki (refetchOnWindowFocus), odzyskanie sieci (refetchOnReconnect) albo invalidateQueries, uruchamia pobieranie. status zostaje success i stare dane są nadal widoczne, a fetchStatus zmienia się na fetching, więc isFetching ma wartość true, a isLoading false.
  5. Znowu bezczynność - świeże dane zastępują stare, fetchStatus wraca do idle, a odliczanie staleTime zaczyna się od nowa.

Bez sieci zapytanie nie kończy się błędem, tylko przechodzi w fetchStatus: 'paused' i rusza samo po odzyskaniu połączenia. refetchInterval odświeża dane cyklicznie, niezależnie od staleTime.

useMutation - żądania POST, PUT i DELETE

Zapytania czytają dane, a mutacje je zmieniają. useMutation przyjmuje mutationFn i niczego nie wysyła sam, tylko zwraca obiekt z metodą mutate:

import { useMutation, useQueryClient } from '@tanstack/react-query';

async function createMission(newMission) {
  const response = await fetch('/api/missions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(newMission),
  });

  if (!response.ok) {
    throw new Error('Failed to create mission');
  }

  return response.json();
}

function CreateMissionForm() {
  const queryClient = useQueryClient();

  const mutation = useMutation({
    mutationFn: createMission,

    // Optimistic update
    onMutate: async (newMission) => {
      await queryClient.cancelQueries({ queryKey: ['missions'] });
      const previousMissions = queryClient.getQueryData(['missions']);
      queryClient.setQueryData(['missions'], (old) => [...old, newMission]);
      return { previousMissions };
    },

    // Rollback on error
    onError: (err, newMission, context) => {
      queryClient.setQueryData(['missions'], context.previousMissions);
    },

    // Invalidate and refetch
    onSettled: () => {
      queryClient.invalidateQueries({ queryKey: ['missions'] });
    },
  });

  const handleSubmit = (e) => {
    e.preventDefault();
    const formData = new FormData(e.target);

    mutation.mutate({
      name: formData.get('name'),
      destination: formData.get('destination'),
      date: formData.get('date'),
    });
  };

  return (
    <form onSubmit={handleSubmit}>
      <input name="name" placeholder="Nazwa misji" required />
      <input name="destination" placeholder="Cel misji" required />
      <input name="date" type="date" required />

      <button type="submit" disabled={mutation.isPending}>
        {mutation.isPending ? 'Tworzenie...' : 'Utwórz misję'}
      </button>
    </form>
  );
}

To optymistyczna aktualizacja: onMutate od razu dopisuje misję do cache, zanim serwer odpowie, i zapamiętuje poprzednią listę. Przy błędzie onError przywraca ją z context, a onSettled unieważnia klucz ['missions'], więc lista i tak zsynchronizuje się z serwerem. cancelQueries zatrzymuje trwające pobieranie, żeby nie nadpisało zmiany, a isPending blokuje przycisk.

Paginacja z React Query

Przy stronicowaniu numer strony trafia do klucza, więc każda strona ma osobny wpis w cache:

import { useQuery, keepPreviousData } from '@tanstack/react-query';

function PaginatedMissions() {
  const [page, setPage] = useState(1);

  const { data, isLoading, isPlaceholderData } = useQuery({
    queryKey: ['missions', page],
    queryFn: () => fetchMissions(page),
    placeholderData: keepPreviousData,
  });

  return (
    <div>
      {isLoading ? (
        <div>Ładowanie...</div>
      ) : (
        <>
          <div className="missions-list">
            {data.missions.map(mission => (
              <div key={mission.id} className="mission-item">
                <h3>{mission.name}</h3>
              </div>
            ))}
          </div>

          <div className="pagination">
            <button
              onClick={() => setPage(old => Math.max(old - 1, 1))}
              disabled={page === 1}
            >
              Poprzednia
            </button>

            <span>Strona {page} z {data.totalPages}</span>

            <button
              onClick={() => setPage(old => old + 1)}
              disabled={isPlaceholderData || page >= data.totalPages}
            >
              Następna
            </button>
          </div>
        </>
      )}
    </div>
  );
}

placeholderData: keepPreviousData zostawia na ekranie poprzednią stronę, dopóki nie dotrze następna, więc lista nie miga. isPlaceholderData mówi, że widzisz jeszcze stare dane, dlatego przycisk Następna czeka.

Infinite Queries - nieskończone scrollowanie

useInfiniteQuery przechowuje wszystkie pobrane strony nieskończonej listy w data.pages:

import { useInfiniteQuery } from '@tanstack/react-query';

function InfiniteMissions() {
  const {
    data,
    fetchNextPage,
    hasNextPage,
    isFetchingNextPage,
    status,
  } = useInfiniteQuery({
    queryKey: ['infiniteMissions'],
    queryFn: ({ pageParam }) => fetch(`/api/missions?page=${pageParam}&limit=20`).then(r => r.json()),
    initialPageParam: 1,
    getNextPageParam: (lastPage, allPages) => {
      return lastPage.hasMore ? allPages.length + 1 : undefined;
    },
  });

  if (status === 'pending') return <div>Ładowanie...</div>;
  if (status === 'error') return <div>Błąd ładowania</div>;

  return (
    <div>
      <div className="infinite-list">
        {data.pages.map((page, i) => (
          <React.Fragment key={i}>
            {page.missions.map(mission => (
              <div key={mission.id} className="mission-card">
                <h3>{mission.name}</h3>
              </div>
            ))}
          </React.Fragment>
        ))}
      </div>

      <button
        onClick={() => fetchNextPage()}
        disabled={!hasNextPage || isFetchingNextPage}
      >
        {isFetchingNextPage
          ? 'Ładowanie...'
          : hasNextPage
          ? 'Załaduj więcej'
          : 'Brak więcej danych'}
      </button>
    </div>
  );
}

initialPageParam (w wersji 5 obowiązkowy) ustala pierwszą stronę, a getNextPageParam zwraca numer następnej albo undefined, gdy dane się skończą, co ustawia hasNextPage na false.

Polecam trzymać dane z serwera w TanStack Query, a w useState czy Reduxie tylko stan interfejsu, jak otwarte panele, bo to dwa różne rodzaje stanu. Biblioteka automatyzuje pobieranie, cache'owanie, synchronizację i aktualizacje danych jak autopilot, który sam koryguje kurs, a Ty skupiasz się na doświadczeniu użytkownika. Przyda się w każdym projekcie z API, bo queryFn może być dowolną funkcją zwracającą obietnicę, także klientem GraphQL.

Pamiętaj: klucz zapytania to współrzędne w cache - te same współrzędne oznaczają te same dane, a nieaktualne dane odświeżą się w tle. W przykładzie poniżej obserwuj pola status i fetchStatus: poczekaj 5 sekund, aż dane się zestarzeją, wróć do karty, a potem dodaj misję, także z symulowanym błędem serwera.

Kod do tej lekcji: App.jsx
import { useEffect, useState, useSyncExternalStore } from 'react';

// === TanStack Query v5 - uproszczona symulacja cache ===
// W projekcie: npm install @tanstack/react-query i useQuery({ queryKey, queryFn, staleTime }).
// Ten mini-klient pokazuje te same pola co biblioteka: status (pending | error | success),
// fetchStatus (fetching | paused | idle) oraz dane świeże i nieaktualne po upływie staleTime.

const STALE_TIME = 5000; // Przez 5 sekund dane są świeże
const startedAt = Date.now();

// Fałszywy serwer z listą misji
let serverMissions = [
  { id: 1, name: 'Apollo-RQ1', status: 'aktywna', crew: 4 },
  { id: 2, name: 'Nebula-X7', status: 'zakończona', crew: 6 },
  { id: 3, name: 'Orion-3', status: 'planowana', crew: 3 },
];

const api = {
  getMissions: () => new Promise(resolve => setTimeout(() => resolve([...serverMissions]), 800)),
  addMission: (mission, fail) => new Promise((resolve, reject) => setTimeout(() => {
    if (fail) {
      reject(new Error('Serwer odrzucił misję'));
      return;
    }
    const saved = { ...mission, id: Date.now() };
    serverMissions = [...serverMissions, saved];
    resolve(saved);
  }, 700)),
};

// Wpis w cache dla klucza ['missions'] - to robi za Ciebie QueryClient
function createQuery(queryFn) {
  let state = { status: 'pending', fetchStatus: 'idle', data: undefined, error: null, dataUpdatedAt: 0, isStale: true, log: [] };
  let inFlight = null;
  let fetchId = 0;
  let staleTimer = null;
  const listeners = new Set();

  const setState = (patch, message) => {
    const time = ((Date.now() - startedAt) / 1000).toFixed(1) + ' s';
    const log = message ? [...state.log, { time, message }].slice(-10) : state.log;
    state = { ...state, ...patch, log };
    listeners.forEach(listener => listener());
  };

  const markFresh = (data, message) => {
    clearTimeout(staleTimer);
    setState({ status: 'success', data, error: null, dataUpdatedAt: Date.now(), isStale: false, fetchStatus: 'idle' }, message);
    staleTimer = setTimeout(() => setState({ isStale: true }, 'minął staleTime: dane nieaktualne, ale nic się jeszcze nie pobiera'), STALE_TIME);
  };

  const query = {
    subscribe(listener) {
      listeners.add(listener);
      return () => listeners.delete(listener);
    },
    getState() {
      return state;
    },
    fetch(reason) {
      if (inFlight) return inFlight; // Deduplikacja: jedno żądanie naraz
      if (state.status === 'success') {
        setState({ fetchStatus: 'fetching' }, 'fetchStatus: fetching, status nadal success - odświeżanie w tle (' + reason + ')');
      } else {
        setState({ fetchStatus: 'fetching' }, 'status: pending, fetchStatus: fetching - pierwsze ładowanie (isLoading: true)');
      }
      const id = ++fetchId;
      inFlight = queryFn()
        .then(data => {
          if (id === fetchId) markFresh(data, 'status: success, fetchStatus: idle - dane świeże przez ' + STALE_TIME / 1000 + ' s');
        })
        .catch(error => {
          if (id === fetchId) setState({ status: 'error', error, fetchStatus: 'idle' }, 'status: error - ' + error.message);
        })
        .finally(() => {
          if (id === fetchId) inFlight = null;
        });
      return inFlight;
    },
    // cancelQueries: wynik trwającego pobierania zostanie zignorowany
    cancel() {
      if (!inFlight) return;
      fetchId++;
      inFlight = null;
      setState({ fetchStatus: 'idle' }, 'cancelQueries: przerwano trwające pobieranie');
    },
    refetchIfStale(reason) {
      if (state.isStale) query.fetch(reason);
      else if (state.status === 'success') setState({}, reason + ': dane świeże, więc bez nowego żądania');
    },
    invalidate(reason) {
      clearTimeout(staleTimer);
      setState({ isStale: true });
      return query.fetch(reason);
    },
    setData(updater, message) {
      markFresh(updater(state.data), message);
    },
  };
  return query;
}

const missionsQuery = createQuery(api.getMissions);

// Odpowiednik useQuery({ queryKey: ['missions'], queryFn, staleTime: 5000 })
function useMissionsQuery() {
  const state = useSyncExternalStore(missionsQuery.subscribe, missionsQuery.getState);

  // Montowanie komponentu: pobierz, jeśli danych nie ma albo są nieaktualne
  useEffect(() => {
    missionsQuery.refetchIfStale('nowy komponent');
  }, []);

  // refetchOnWindowFocus: powrót do karty odświeża tylko nieaktualne dane
  useEffect(() => {
    const onFocus = () => missionsQuery.refetchIfStale('powrót do okna');
    window.addEventListener('focus', onFocus);
    return () => window.removeEventListener('focus', onFocus);
  }, []);

  return {
    ...state,
    isPending: state.status === 'pending',
    isFetching: state.fetchStatus === 'fetching',
    isLoading: state.status === 'pending' && state.fetchStatus === 'fetching',
  };
}

function Badge({ label, value, color }) {
  return (
    <span style={{ ...styles.badge, borderColor: color, color }}>
      {label}: <strong>{String(value)}</strong>
    </span>
  );
}

function QueryStatus({ query }) {
  return (
    <div style={styles.card}>
      <div style={styles.badges}>
        <Badge label="status" value={query.status} color="#00d4ff" />
        <Badge label="fetchStatus" value={query.fetchStatus} color={query.isFetching ? '#ffa500' : '#8892b0'} />
        <Badge label="isLoading" value={query.isLoading} color="#8892b0" />
        <Badge label="isFetching" value={query.isFetching} color="#8892b0" />
        <Badge label="dane" value={query.isStale ? 'nieaktualne' : 'świeże'} color={query.isStale ? '#ff6b6b' : '#00ff88'} />
      </div>
      <div style={styles.staleTrack}>
        {!query.isStale && <div key={query.dataUpdatedAt} style={styles.staleFill} />}
      </div>
      <div style={styles.buttons}>
        <button style={styles.button} onClick={() => missionsQuery.refetchIfStale('powrót do okna')}>
          Symuluj powrót do karty
        </button>
        <button style={styles.button} onClick={() => missionsQuery.invalidate('invalidateQueries')}>
          invalidateQueries(['missions'])
        </button>
      </div>
    </div>
  );
}

function AddMission({ ready }) {
  const [name, setName] = useState('');
  const [failServer, setFailServer] = useState(false);
  const [isPending, setIsPending] = useState(false);

  // Odpowiednik useMutation z optymistyczną aktualizacją
  const addMission = async () => {
    const mission = { name: name.trim(), status: 'planowana', crew: 2 };
    if (!mission.name || isPending || !ready) return;
    setName('');
    setIsPending(true);

    // onMutate: przerwij trwające pobieranie, zapamiętaj listę i od razu dopisz misję
    missionsQuery.cancel();
    const previous = missionsQuery.getState().data;
    missionsQuery.setData(old => [...old, { ...mission, id: 'temp-' + Date.now(), optimistic: true }], 'onMutate: misja dopisana optymistycznie');
    try {
      await api.addMission(mission, failServer);
    } catch (error) {
      // onError: przywróć listę sprzed zmiany
      missionsQuery.setData(() => previous, 'onError: ' + error.message + ' - przywrócono poprzednią listę');
    } finally {
      // onSettled: unieważnij klucz, żeby zsynchronizować się z serwerem
      setIsPending(false);
      missionsQuery.invalidate('onSettled');
    }
  };

  return (
    <div style={styles.form}>
      <input
        value={name}
        onChange={e => setName(e.target.value)}
        onKeyDown={e => e.key === 'Enter' && addMission()}
        placeholder="Nazwa nowej misji..."
        style={styles.input}
      />
      <button onClick={addMission} disabled={isPending || !ready} style={styles.primary}>
        {isPending ? 'Zapisywanie...' : 'Dodaj misję'}
      </button>
      <label style={styles.check}>
        <input type="checkbox" checked={failServer} onChange={e => setFailServer(e.target.checked)} />
        Symuluj błąd serwera
      </label>
    </div>
  );
}

export default function App() {
  const query = useMissionsQuery();

  return (
    <div style={styles.page}>
      <div style={{ maxWidth: '640px', margin: '0 auto' }}>
        <h1 style={styles.title}>TanStack Query v5 - cykl życia zapytania</h1>
        <p style={styles.subtitle}>staleTime: {STALE_TIME / 1000} s. Poczekaj, aż dane się zestarzeją, a potem wróć do karty.</p>

        <QueryStatus query={query} />

        <div style={styles.card}>
          {query.isPending ? (
            <p style={styles.muted}>Ładowanie misji...</p>
          ) : query.status === 'error' ? (
            <p style={{ color: '#ff6b6b' }}>Błąd: {query.error.message}</p>
          ) : (
            query.data.map(m => (
              <div key={m.id} style={{ ...styles.mission, opacity: m.optimistic ? 0.6 : 1 }}>
                <strong>{m.name}</strong>
                <span style={styles.muted}>
                  {m.optimistic ? 'zapis w toku (optymistycznie)' : m.status + ', załoga: ' + m.crew}
                </span>
              </div>
            ))
          )}
          <AddMission ready={query.status === 'success'} />
        </div>

        <div style={styles.card}>
          <h3 style={styles.logTitle}>Dziennik zapytania</h3>
          {query.log.map((entry, i) => (
            <div key={i} style={styles.logRow}>
              <span style={styles.logTime}>{entry.time}</span>
              <span>{entry.message}</span>
            </div>
          ))}
        </div>
      </div>
      <style>{'@keyframes staleCountdown { from { width: 100%; } to { width: 0%; } }'}</style>
    </div>
  );
}

const styles = {
  page: { minHeight: '100vh', background: 'linear-gradient(135deg, #0a0e27 0%, #1a1a3e 100%)', padding: '20px', color: '#e0e1dd', fontFamily: 'system-ui, sans-serif', fontSize: '13px' },
  title: { textAlign: 'center', color: '#00d4ff', margin: '0 0 6px', fontSize: '20px' },
  subtitle: { textAlign: 'center', color: '#8892b0', margin: '0 0 14px' },
  card: { background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(0,212,255,0.15)', borderRadius: '10px', padding: '12px', marginBottom: '12px' },
  badges: { display: 'flex', flexWrap: 'wrap', gap: '6px' },
  badge: { border: '1px solid', borderRadius: '6px', padding: '3px 8px', fontSize: '12px' },
  staleTrack: { height: '4px', background: 'rgba(255,255,255,0.08)', borderRadius: '2px', margin: '10px 0', overflow: 'hidden' },
  staleFill: { height: '100%', background: '#00ff88', animation: 'staleCountdown 5s linear forwards' },
  buttons: { display: 'flex', gap: '8px', flexWrap: 'wrap' },
  button: { padding: '6px 12px', background: 'rgba(0,212,255,0.15)', color: '#00d4ff', border: '1px solid rgba(0,212,255,0.4)', borderRadius: '6px', cursor: 'pointer', fontSize: '12px' },
  mission: { display: 'flex', justifyContent: 'space-between', gap: '8px', padding: '8px 10px', margin: '6px 0', background: 'rgba(0,212,255,0.06)', borderRadius: '6px' },
  muted: { color: '#8892b0' },
  form: { display: 'flex', gap: '8px', alignItems: 'center', flexWrap: 'wrap', marginTop: '10px' },
  input: { flex: '1 1 180px', padding: '7px 10px', background: 'rgba(255,255,255,0.08)', border: '1px solid rgba(0,212,255,0.3)', borderRadius: '6px', color: '#e0e1dd' },
  primary: { padding: '7px 14px', background: '#00d4ff', color: '#0a0e27', border: 'none', borderRadius: '6px', fontWeight: 'bold', cursor: 'pointer' },
  check: { display: 'flex', alignItems: 'center', gap: '6px', color: '#8892b0' },
  logTitle: { margin: '0 0 8px', color: '#64ffda', fontSize: '14px' },
  logRow: { display: 'flex', gap: '8px', padding: '2px 0', fontSize: '12px' },
  logTime: { color: '#8892b0', width: '48px', flexShrink: 0, textAlign: 'right' },
};

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co jest wymagane w konfiguracji useQuery?

  2. 2. Co to jest optimistic update w kontekście useMutation?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy wywołania useMutation w React Query od lewej do prawej:

  • Układanie w pionie

    Uporządkuj cykl życia zapytania w TanStack Query v5 od zamontowania komponentu do odświeżenia w tle:

  1. PytanieuseQuery w React Query
  2. Ułóż w kolejnościSkładnia useMutation w React Query
  3. PytanieOptymistyczne aktualizacje
  4. PytanieWzorzec stale-while-revalidate
  5. Ułóż w kolejnościCykl życia zapytania w TanStack Query

Przydatne artykuły