Kurs Next.js · Moduł 9: Integracje i zaawansowane funkcje

Next.js z Zustand - Nowoczesne state management

19 min czytania ·
W tej lekcji11

Koszyk w sklepie Metropolii Quantum musi być widoczny w nagłówku, w szufladzie z produktami i na stronie kasy. Przekazywanie go propsami przez pięć poziomów komponentów szybko zamienia się w plątaninę kabli. Server Components pobierają dane z serwera, ale stan czysto kliencki, taki jak koszyk, motyw czy powiadomienia, potrzebuje wspólnego magazynu. Neo-Bot, zarządca stanu Metropolii, poleca do tego Zustand - minimalistyczną, ale potężną bibliotekę do zarządzania stanem.

Czym jest Zustand?

Zustand to nowoczesna biblioteka state management, która oferuje:

  • Minimalist API - proste i intuicyjne API
  • TypeScript-first - pełne wsparcie typowania
  • No boilerplate - brak kodu szablonowego
  • SSR-friendly - wsparcie dla Server-Side Rendering
  • DevTools support - integracja z Redux DevTools
  • Middleware ecosystem - bogaty ekosystem middleware

Zalety Zustand nad Redux

  • Mniej kodu - brak akcji, reducerów i dispatcherów
  • Lepsze TypeScript - naturalne wsparcie typów
  • Modular design - łatwe dzielenie store'ów
  • Performance - automatyczna optymalizacja re-renderów

Najważniejsza różnica: Zustand nie wymaga providera owijającego aplikację ani reducerów. Store to zwykły hook, który importujesz tam, gdzie go potrzebujesz.

Instalacja i podstawowa konfiguracja

Instalacja

Konfiguracja zawsze przebiega w tej samej kolejności: instalacja pakietu, utworzenie store'a funkcją create(), zdefiniowanie stanu i akcji, a na końcu użycie hooka w komponencie. Zaczynamy od instalacji:

# Zainstaluj Zustand
npm install zustand

# Dla development tools (opcjonalne)
npm install @redux-devtools/extension

Drugi pakiet jest opcjonalny. Do podglądu stanu wystarczy rozszerzenie przeglądarki Redux DevTools i middleware devtools, które poznasz za chwilę.

Podstawowy store

Najpierw opisujemy kształt store'a interfejsem CounterState: jedna wartość count i trzy akcje. Funkcja create zwraca hook, a set scala przekazany obiekt ze stanem:

// stores/counterStore.ts
import { create } from 'zustand';

interface CounterState {
  count: number;
  increment: () => void;
  decrement: () => void;
  reset: () => void;
}

export const useCounterStore = create<CounterState>()((set) => ({
  count: 0,
  increment: () => set((state) => ({ count: state.count + 1 })),
  decrement: () => set((state) => ({ count: state.count - 1 })),
  reset: () => set({ count: 0 }),
}));

Zwróć uwagę na podwójne nawiasy create<CounterState>()(...): to zalecany zapis w TypeScript, który pozwala poprawnie wywnioskować typy. Akcje to zwykłe funkcje w tym samym obiekcie co dane, bez żadnego dispatch.

Użycie w komponencie

Hook useCounterStore działa tylko w komponentach klienckich, dlatego plik zaczyna się od 'use client':

// components/Counter.tsx
'use client';

import { useCounterStore } from '@/stores/counterStore';

export default function Counter() {
  const { count, increment, decrement, reset } = useCounterStore();

  return (
    <div className="bg-white p-6 rounded-lg shadow">
      <h2 className="text-2xl font-bold mb-4">Licznik: {count}</h2>

      <div className="space-x-4">
        <button
          onClick={increment}
          className="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600"
        >
          +1
        </button>

        <button
          onClick={decrement}
          className="bg-red-500 text-white px-4 py-2 rounded hover:bg-red-600"
        >
          -1
        </button>

        <button
          onClick={reset}
          className="bg-gray-500 text-white px-4 py-2 rounded hover:bg-gray-600"
        >
          Reset
        </button>
      </div>
    </div>
  );
}

Licznik działa bez providera w drzewie. Ten zapis pobiera jednak cały store, więc komponent odświeża się przy każdej zmianie, a w sekcji o wydajności zobaczysz, jak to poprawić selektorami.

Zaawansowane patterns

User store z autentykacją

Prawdziwy store przechowuje też stan ładowania i błędy. Middleware persist zapisuje wybraną część stanu w localStorage, a get pozwala odczytać stan wewnątrz akcji:

// stores/userStore.ts
import { create } from 'zustand';
import { persist, createJSONStorage } from 'zustand/middleware';

interface User {
  id: string;
  name: string;
  email: string;
  avatar?: string;
  role: 'user' | 'admin';
}

interface UserState {
  user: User | null;
  isLoading: boolean;
  error: string | null;
  login: (email: string, password: string) => Promise<void>;
  logout: () => void;
  updateProfile: (data: Partial<User>) => Promise<void>;
  setUser: (user: User) => void;
  clearError: () => void;
}

export const useUserStore = create<UserState>()(
  persist(
    (set, get) => ({
      user: null,
      isLoading: false,
      error: null,

      login: async (email: string, password: string) => {
        set({ isLoading: true, error: null });

        try {
          const response = await fetch('/api/auth/login', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ email, password }),
          });

          if (!response.ok) {
            throw new Error('Nieprawidłowe dane logowania');
          }

          const userData = await response.json();
          set({ user: userData.user, isLoading: false });
        } catch (error) {
          set({
            error: error instanceof Error ? error.message : 'Wystąpił błąd',
            isLoading: false
          });
        }
      },

      logout: () => {
        set({ user: null, error: null });
        // Wywołaj API logout
        fetch('/api/auth/logout', { method: 'POST' });
      },

      updateProfile: async (data: Partial<User>) => {
        const { user } = get();
        if (!user) return;

        set({ isLoading: true });

        try {
          const response = await fetch('/api/user/profile', {
            method: 'PATCH',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(data),
          });

          if (!response.ok) {
            throw new Error('Nie udało się zaktualizować profilu');
          }

          const updatedUser = await response.json();
          set({ user: updatedUser, isLoading: false });
        } catch (error) {
          set({
            error: error instanceof Error ? error.message : 'Wystąpił błąd',
            isLoading: false
          });
        }
      },

      setUser: (user: User) => set({ user }),
      clearError: () => set({ error: null }),
    }),
    {
      name: 'user-storage',
      storage: createJSONStorage(() => localStorage),
      partialize: (state) => ({ user: state.user }), // Persist tylko user data
    }
  )
);

Akcje asynchroniczne to po prostu funkcje async, więc Zustand nie potrzebuje middleware typu thunk. Opcja partialize zapisuje tylko user, bez flag ładowania i błędów. Uwaga na SSR: serwer nie widzi localStorage, więc stan odtworzony po stronie klienta może różnić się od HTML-a z serwera.

Shopping cart store

Koszyk pokazuje, jak zmieniać tablice bez mutowania. Typ Omit<CartItem, 'quantity'> oznacza produkt bez pola ilości, bo ilość ustala store:

// stores/cartStore.ts
import { create } from 'zustand';
import { persist } from 'zustand/middleware';

interface CartItem {
  id: string;
  name: string;
  price: number;
  quantity: number;
  image?: string;
  variant?: {
    size?: string;
    color?: string;
  };
}

interface CartState {
  items: CartItem[];
  isOpen: boolean;
  addItem: (item: Omit<CartItem, 'quantity'>) => void;
  removeItem: (id: string) => void;
  updateQuantity: (id: string, quantity: number) => void;
  clearCart: () => void;
  toggleCart: () => void;
  getTotalItems: () => number;
  getTotalPrice: () => number;
}

export const useCartStore = create<CartState>()(
  persist(
    (set, get) => ({
      items: [],
      isOpen: false,

      addItem: (newItem) => {
        const { items } = get();
        const existingItem = items.find(item =>
          item.id === newItem.id &&
          JSON.stringify(item.variant) === JSON.stringify(newItem.variant)
        );

        if (existingItem) {
          set({
            items: items.map(item =>
              item === existingItem
                ? { ...item, quantity: item.quantity + 1 }
                : item
            ),
          });
        } else {
          set({
            items: [...items, { ...newItem, quantity: 1 }],
          });
        }
      },

      removeItem: (id) => {
        set({
          items: get().items.filter(item => item.id !== id),
        });
      },

      updateQuantity: (id, quantity) => {
        if (quantity <= 0) {
          get().removeItem(id);
          return;
        }

        set({
          items: get().items.map(item =>
            item.id === id ? { ...item, quantity } : item
          ),
        });
      },

      clearCart: () => set({ items: [] }),

      toggleCart: () => set({ isOpen: !get().isOpen }),

      getTotalItems: () => {
        return get().items.reduce((total, item) => total + item.quantity, 0);
      },

      getTotalPrice: () => {
        return get().items.reduce(
          (total, item) => total + item.price * item.quantity,
          0
        );
      },
    }),
    {
      name: 'cart-storage',
    }
  )
);

addItem zwiększa ilość, jeśli produkt w tym samym wariancie już jest w koszyku, a w przeciwnym razie dodaje nową pozycję. Oryginalna tablica nigdy się nie zmienia: map i filter zawsze tworzą nową, dzięki czemu React wykrywa zmianę.

Middleware i DevTools

Redux DevTools integration

Wbudowane middleware Zustand to m.in. devtools, persist, immer, subscribeWithSelector, combine i redux. devtools pokazuje każdą zmianę stanu w rozszerzeniu Redux DevTools:

// stores/appStore.ts
import { create } from 'zustand';
import { devtools } from 'zustand/middleware';

interface AppState {
  theme: 'light' | 'dark';
  sidebarOpen: boolean;
  notifications: Array<{
    id: string;
    type: 'info' | 'success' | 'warning' | 'error';
    message: string;
    timestamp: number;
  }>;
  toggleTheme: () => void;
  toggleSidebar: () => void;
  addNotification: (notification: Omit<AppState['notifications'][0], 'id' | 'timestamp'>) => void;
  removeNotification: (id: string) => void;
}

export const useAppStore = create<AppState>()(
  devtools(
    (set, get) => ({
      theme: 'light',
      sidebarOpen: false,
      notifications: [],

      toggleTheme: () => {
        const newTheme = get().theme === 'light' ? 'dark' : 'light';
        set({ theme: newTheme });

        // Update document class
        if (typeof window !== 'undefined') {
          document.documentElement.classList.toggle('dark', newTheme === 'dark');
        }
      },

      toggleSidebar: () => set({ sidebarOpen: !get().sidebarOpen }),

      addNotification: (notification) => {
        const id = Math.random().toString(36).substring(2);
        const timestamp = Date.now();

        set({
          notifications: [
            ...get().notifications,
            { ...notification, id, timestamp }
          ]
        });

        // Auto remove after 5 seconds
        setTimeout(() => {
          get().removeNotification(id);
        }, 5000);
      },

      removeNotification: (id) => {
        set({
          notifications: get().notifications.filter(n => n.id !== id)
        });
      },
    }),
    {
      name: 'app-store',
    }
  )
);

Motyw, panel boczny i powiadomienia trafiają do jednego store'a aplikacji. Powiadomienie samo znika po 5 sekundach, a typeof window chroni kod przed uruchomieniem na serwerze.

Immer middleware dla immutable updates

Middleware immer pozwala pisać zmiany tak, jakbyś mutował stan. Wymaga osobnego pakietu:

npm install immer

Teraz state.todos.push(...) w środku set jest bezpieczne, bo Immer tworzy nową kopię za kulisami:

// stores/todosStore.ts
import { create } from 'zustand';
import { immer } from 'zustand/middleware/immer';

interface Todo {
  id: string;
  text: string;
  completed: boolean;
  priority: 'low' | 'medium' | 'high';
  dueDate?: Date;
}

interface TodosState {
  todos: Todo[];
  filter: 'all' | 'active' | 'completed';
  addTodo: (text: string, priority?: Todo['priority']) => void;
  toggleTodo: (id: string) => void;
  deleteTodo: (id: string) => void;
  editTodo: (id: string, text: string) => void;
  setFilter: (filter: TodosState['filter']) => void;
  clearCompleted: () => void;
}

export const useTodosStore = create<TodosState>()(
  immer((set) => ({
    todos: [],
    filter: 'all',

    addTodo: (text, priority = 'medium') =>
      set((state) => {
        state.todos.push({
          id: Math.random().toString(36).substring(2),
          text,
          completed: false,
          priority,
        });
      }),

    toggleTodo: (id) =>
      set((state) => {
        const todo = state.todos.find((t) => t.id === id);
        if (todo) {
          todo.completed = !todo.completed;
        }
      }),

    deleteTodo: (id) =>
      set((state) => {
        state.todos = state.todos.filter((t) => t.id !== id);
      }),

    editTodo: (id, text) =>
      set((state) => {
        const todo = state.todos.find((t) => t.id === id);
        if (todo) {
          todo.text = text;
        }
      }),

    setFilter: (filter) =>
      set((state) => {
        state.filter = filter;
      }),

    clearCompleted: () =>
      set((state) => {
        state.todos = state.todos.filter((t) => !t.completed);
      }),
  }))
);

Porównaj toggleTodo z wersją bez Immera: zamiast mapowania całej tablicy zmieniasz jedno pole. Na zewnątrz nic się nie zmienia, komponenty dalej dostają niemutowalny stan.

SSR i hydration

Store provider dla SSR

Store utworzony na poziomie modułu jest na serwerze wspólny dla wszystkich żądań, więc dane jednego użytkownika mogłyby trafić do drugiego. Dokumentacja Zustand zaleca w Next.js osobny store na każde żądanie, przekazywany przez React Context:

// providers/StoreProvider.tsx
'use client';

import { type ReactNode, createContext, useRef, useContext } from 'react';
import { useStore } from 'zustand';
import { type UserStore, createUserStore, initUserStore } from '@/stores/userStore';

export type UserStoreApi = ReturnType<typeof createUserStore>;

export const UserStoreContext = createContext<UserStoreApi | undefined>(undefined);

export interface UserStoreProviderProps {
  children: ReactNode;
  initialState?: Parameters<typeof initUserStore>[0];
}

export const UserStoreProvider = ({ children, initialState }: UserStoreProviderProps) => {
  const storeRef = useRef<UserStoreApi | null>(null);

  if (!storeRef.current) {
    storeRef.current = createUserStore(initUserStore(initialState));
  }

  return (
    <UserStoreContext.Provider value={storeRef.current}>
      {children}
    </UserStoreContext.Provider>
  );
};

export const useUserStore = <T,>(selector: (store: UserStore) => T): T => {
  const userStoreContext = useContext(UserStoreContext);

  if (!userStoreContext) {
    throw new Error('useUserStore must be used within UserStoreProvider');
  }

  return useStore(userStoreContext, selector);
};

useRef gwarantuje, że store powstanie tylko raz na instancję providera. W React 19 useRef wymaga wartości początkowej, stąd null. Hook useStore z paczki zustand czyta wybrany fragment store'a z kontekstu.

Updated store definition

Sam store tworzymy teraz funkcją createStore z zustand/vanilla, która zwraca obiekt store'a zamiast hooka:

// stores/userStore.ts (updated for SSR)
import { createStore } from 'zustand/vanilla';

export interface UserStore {
  user: User | null;
  isLoading: boolean;
  login: (email: string, password: string) => Promise<void>;
  logout: () => void;
}

export const initUserStore = (initialState?: Partial<UserStore>): UserStore => {
  return {
    user: null,
    isLoading: false,
    login: async (email: string, password: string) => {
      // Implementation
    },
    logout: () => {
      // Implementation
    },
    ...initialState,
  };
};

export const createUserStore = (initialState: UserStore) => {
  return createStore<UserStore>()(() => initialState);
};

initUserStore składa stan początkowy, a createUserStore tworzy store. Logika akcji się nie zmieniła, zmienia się tylko miejsce powstawania store'a.

Komponenty z Zustand

Theme toggle component

Przełącznik motywu czyta stan i akcję ze store'a aplikacji:

// components/ThemeToggle.tsx
'use client';

import { useAppStore } from '@/stores/appStore';
import { Moon, Sun } from 'lucide-react';

export default function ThemeToggle() {
  const { theme, toggleTheme } = useAppStore();

  return (
    <button
      onClick={toggleTheme}
      className="p-2 rounded-lg bg-gray-200 dark:bg-gray-800 hover:bg-gray-300 dark:hover:bg-gray-700 transition-colors"
      aria-label="Toggle theme"
    >
      {theme === 'light' ? (
        <Moon className="w-5 h-5" />
      ) : (
        <Sun className="w-5 h-5" />
      )}
    </button>
  );
}

Komponent nie wie nic o document ani o klasie dark, całą logikę trzyma store.

Shopping cart drawer

Szuflada koszyka to większy komponent, który korzysta ze wszystkich akcji koszyka:

// components/CartDrawer.tsx
'use client';

import { useCartStore } from '@/stores/cartStore';
import { X, Plus, Minus, Trash2 } from 'lucide-react';

export default function CartDrawer() {
  const {
    items,
    isOpen,
    toggleCart,
    updateQuantity,
    removeItem,
    getTotalPrice,
    getTotalItems,
  } = useCartStore();

  if (!isOpen) return null;

  return (
    <div className="fixed inset-0 z-50">
      {/* Overlay */}
      <div
        className="absolute inset-0 bg-black/50"
        onClick={toggleCart}
      />

      {/* Drawer */}
      <div className="absolute right-0 top-0 h-full w-96 bg-white shadow-xl">
        <div className="flex items-center justify-between p-4 border-b">
          <h2 className="text-lg font-semibold">
            Koszyk ({getTotalItems()})
          </h2>
          <button
            onClick={toggleCart}
            className="p-2 hover:bg-gray-100 rounded"
          >
            <X className="w-5 h-5" />
          </button>
        </div>

        <div className="flex-1 overflow-y-auto p-4">
          {items.length === 0 ? (
            <p className="text-gray-500 text-center mt-8">
              Koszyk jest pusty
            </p>
          ) : (
            <div className="space-y-4">
              {items.map((item) => (
                <div key={item.id} className="flex items-center space-x-4 p-4 border rounded">
                  {item.image && (
                    <img
                      src={item.image}
                      alt={item.name}
                      className="w-16 h-16 object-cover rounded"
                    />
                  )}

                  <div className="flex-1">
                    <h3 className="font-medium">{item.name}</h3>
                    <p className="text-gray-600">{item.price} zł</p>

                    {item.variant && (
                      <p className="text-sm text-gray-500">
                        {item.variant.size && `Rozmiar: ${item.variant.size}`}
                        {item.variant.color && ` Kolor: ${item.variant.color}`}
                      </p>
                    )}
                  </div>

                  <div className="flex items-center space-x-2">
                    <button
                      onClick={() => updateQuantity(item.id, item.quantity - 1)}
                      className="p-1 hover:bg-gray-100 rounded"
                    >
                      <Minus className="w-4 h-4" />
                    </button>

                    <span className="w-8 text-center">{item.quantity}</span>

                    <button
                      onClick={() => updateQuantity(item.id, item.quantity + 1)}
                      className="p-1 hover:bg-gray-100 rounded"
                    >
                      <Plus className="w-4 h-4" />
                    </button>

                    <button
                      onClick={() => removeItem(item.id)}
                      className="p-1 hover:bg-red-100 text-red-600 rounded"
                    >
                      <Trash2 className="w-4 h-4" />
                    </button>
                  </div>
                </div>
              ))}
            </div>
          )}
        </div>

        {items.length > 0 && (
          <div className="border-t p-4">
            <div className="flex justify-between mb-4">
              <span className="font-semibold">Łącznie:</span>
              <span className="font-semibold">{getTotalPrice()} zł</span>
            </div>

            <button className="w-full bg-blue-600 text-white py-3 rounded-lg hover:bg-blue-700 transition-colors">
              Przejdź do kasy
            </button>
          </div>
        )}
      </div>
    </div>
  );
}

Przyciski plus i minus wołają updateQuantity, a zejście do zera usuwa pozycję, bo tak zdefiniowaliśmy akcję w store. Komponent niczego nie liczy sam, sumy dają getTotalItems i getTotalPrice.

Notifications component

Lista powiadomień renderuje osobny komponent NotificationItem dla każdego wpisu:

// components/Notifications.tsx
'use client';

import { useEffect } from 'react';
import { useAppStore } from '@/stores/appStore';
import { X, CheckCircle, AlertCircle, Info, AlertTriangle } from 'lucide-react';

export default function Notifications() {
  const { notifications, removeNotification } = useAppStore();

  return (
    <div className="fixed top-4 right-4 z-50 space-y-2">
      {notifications.map((notification) => (
        <NotificationItem
          key={notification.id}
          notification={notification}
          onRemove={() => removeNotification(notification.id)}
        />
      ))}
    </div>
  );
}

interface NotificationItemProps {
  notification: {
    id: string;
    type: 'info' | 'success' | 'warning' | 'error';
    message: string;
    timestamp: number;
  };
  onRemove: () => void;
}

function NotificationItem({ notification, onRemove }: NotificationItemProps) {
  const { type, message } = notification;

  const icons = {
    info: Info,
    success: CheckCircle,
    warning: AlertTriangle,
    error: AlertCircle,
  };

  const colors = {
    info: 'bg-blue-50 border-blue-200 text-blue-800',
    success: 'bg-green-50 border-green-200 text-green-800',
    warning: 'bg-yellow-50 border-yellow-200 text-yellow-800',
    error: 'bg-red-50 border-red-200 text-red-800',
  };

  const Icon = icons[type];

  useEffect(() => {
    const timer = setTimeout(onRemove, 5000);
    return () => clearTimeout(timer);
  }, [onRemove]);

  return (
    <div className={`flex items-center p-4 border rounded-lg shadow-lg ${colors[type]} min-w-80 max-w-md`}>
      <Icon className="w-5 h-5 mr-3 shrink-0" />

      <div className="flex-1">
        <p className="text-sm font-medium">{message}</p>
      </div>

      <button
        onClick={onRemove}
        className="ml-3 shrink-0 p-1 hover:bg-white hover:bg-white/20 rounded"
      >
        <X className="w-4 h-4" />
      </button>
    </div>
  );
}

Ikony i kolory są zwykłymi obiektami wybieranymi po typie powiadomienia. Store już usuwa powiadomienie po 5 sekundach, więc timer w komponencie jest tu dodatkowym zabezpieczeniem.

API integration

API client z Zustand

Klient HTTP może czytać stan poza Reactem przez getState(), bez hooka:

// lib/api-client.ts
import { useUserStore } from '@/stores/userStore';

class ApiClient {
  private baseURL: string;

  constructor(baseURL: string) {
    this.baseURL = baseURL;
  }

  private async request<T>(
    endpoint: string,
    options: RequestInit = {}
  ): Promise<T> {
    const { user } = useUserStore.getState();

    const config: RequestInit = {
      headers: {
        'Content-Type': 'application/json',
        ...(user && { Authorization: `Bearer ${user.token}` }),
        ...options.headers,
      },
      ...options,
    };

    const response = await fetch(`${this.baseURL}${endpoint}`, config);

    if (!response.ok) {
      throw new Error(`API Error: ${response.status}`);
    }

    return response.json();
  }

  get<T>(endpoint: string): Promise<T> {
    return this.request<T>(endpoint);
  }

  post<T>(endpoint: string, data: any): Promise<T> {
    return this.request<T>(endpoint, {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  put<T>(endpoint: string, data: any): Promise<T> {
    return this.request<T>(endpoint, {
      method: 'PUT',
      body: JSON.stringify(data),
    });
  }

  delete<T>(endpoint: string): Promise<T> {
    return this.request<T>(endpoint, {
      method: 'DELETE',
    });
  }
}

export const apiClient = new ApiClient(process.env.NEXT_PUBLIC_API_URL || '');

Każde żądanie dostaje nagłówek autoryzacji, jeśli użytkownik jest zalogowany. W prawdziwym projekcie typ User musi mieć wtedy pole token.

Products store z API

Store produktów łączy pobieranie danych, wyszukiwanie i filtrowanie:

// stores/productsStore.ts
import { create } from 'zustand';
import { apiClient } from '@/lib/api-client';

interface Product {
  id: string;
  name: string;
  price: number;
  description: string;
  images: string[];
  category: string;
  inStock: boolean;
}

interface ProductsState {
  products: Product[];
  loading: boolean;
  error: string | null;
  searchQuery: string;
  selectedCategory: string | null;
  fetchProducts: () => Promise<void>;
  searchProducts: (query: string) => void;
  filterByCategory: (category: string | null) => void;
  getFilteredProducts: () => Product[];
}

export const useProductsStore = create<ProductsState>()((set, get) => ({
  products: [],
  loading: false,
  error: null,
  searchQuery: '',
  selectedCategory: null,

  fetchProducts: async () => {
    set({ loading: true, error: null });

    try {
      const products = await apiClient.get<Product[]>('/products');
      set({ products, loading: false });
    } catch (error) {
      set({
        error: error instanceof Error ? error.message : 'Failed to fetch products',
        loading: false,
      });
    }
  },

  searchProducts: (query: string) => {
    set({ searchQuery: query });
  },

  filterByCategory: (category: string | null) => {
    set({ selectedCategory: category });
  },

  getFilteredProducts: () => {
    const { products, searchQuery, selectedCategory } = get();

    return products.filter((product) => {
      const matchesSearch = searchQuery === '' ||
        product.name.toLowerCase().includes(searchQuery.toLowerCase()) ||
        product.description.toLowerCase().includes(searchQuery.toLowerCase());

      const matchesCategory = selectedCategory === null ||
        product.category === selectedCategory;

      return matchesSearch && matchesCategory;
    });
  },
}));

getFilteredProducts wylicza wynik z aktualnego stanu, zamiast trzymać drugą kopię listy. W Next.js dane startowe lepiej jednak pobrać w Server Component, a w Zustand trzymać tylko stan interfejsu, jak fraza wyszukiwania.

Performance optimization

Selectors dla optymalizacji

Selektor wybiera ze store'a tylko potrzebny fragment, więc komponent odświeża się tylko przy jego zmianie. Gdy selektor zwraca nowy obiekt, owiń go w useShallow:

// hooks/useOptimizedSelectors.ts
import { useShallow } from 'zustand/react/shallow';
import { useCartStore } from '@/stores/cartStore';

// Dobrze - używaj selektorów
export const useCartInfo = () => {
  return useCartStore(
    useShallow((state) => ({
      totalItems: state.getTotalItems(),
      totalPrice: state.getTotalPrice(),
      itemsCount: state.items.length,
    }))
  );
};

// Dobrze - pojedyncze wartości
export const useCartIsOpen = () => useCartStore((state) => state.isOpen);

// Źle - cały store
// export const useEntireStore = () => useCartStore();

Bez useShallow każdy render tworzyłby nowy obiekt, a Zustand 5 uznałby go za zmianę. Pojedyncza wartość, jak isOpen, nie potrzebuje tego zabezpieczenia.

Subscription pattern

Metoda subscribe wywołuje funkcję przy każdej zmianie stanu, poza cyklem renderowania. Dostaje nowy i poprzedni stan:

// hooks/useStoreSubscription.ts
import { useEffect } from 'react';
import { useCartStore } from '@/stores/cartStore';

export const useCartAnalytics = () => {
  useEffect(() => {
    const unsubscribe = useCartStore.subscribe(
      (state, prevState) => {
        const items = state.items;
        const prevItems = prevState.items;
        // Track analytics when cart changes
        if (items.length > prevItems.length) {
          // Item added
          console.log('Item added to cart');
        } else if (items.length < prevItems.length) {
          // Item removed
          console.log('Item removed from cart');
        }
      }
    );

    return unsubscribe;
  }, []);
};

Hook porównuje długość listy przed i po zmianie, a funkcja zwrócona z subscribe sprząta subskrypcję. Wariant z osobnym selektorem jako pierwszym argumentem wymaga middleware subscribeWithSelector.

Testing

Store testing

Store to zwykły hook, więc testujesz go przez renderHook z Testing Library, a setState resetuje stan przed każdym testem:

// __tests__/stores/counterStore.test.ts
import { renderHook, act } from '@testing-library/react';
import { useCounterStore } from '@/stores/counterStore';

describe('Counter Store', () => {
  beforeEach(() => {
    useCounterStore.setState({ count: 0 });
  });

  it('should increment count', () => {
    const { result } = renderHook(() => useCounterStore());

    act(() => {
      result.current.increment();
    });

    expect(result.current.count).toBe(1);
  });

  it('should decrement count', () => {
    const { result } = renderHook(() => useCounterStore());

    act(() => {
      result.current.increment();
      result.current.decrement();
    });

    expect(result.current.count).toBe(0);
  });

  it('should reset count', () => {
    const { result } = renderHook(() => useCounterStore());

    act(() => {
      result.current.increment();
      result.current.increment();
      result.current.reset();
    });

    expect(result.current.count).toBe(0);
  });
});

Każdy test startuje od zera dzięki beforeEach, więc wyniki nie przeciekają między testami.

Najlepsze praktyki

1. Store organization

Dziel stan tematycznie, zamiast budować jeden magazyn na wszystko:

// Dobrze - podziel store'y tematycznie
// stores/
//   ├── userStore.ts      // User authentication & profile
//   ├── cartStore.ts      // Shopping cart
//   ├── productsStore.ts  // Products catalog
//   └── appStore.ts       // Global app state

// Źle - jeden gigantyczny store
// stores/globalStore.ts  // Everything in one place

Małe store'y łatwiej testować i żaden komponent nie subskrybuje danych, których nie używa.

2. TypeScript best practices

Interfejs stanu pisz przed implementacją, a typ przekazuj generykiem:

// Dobrze - definiuj interfaces
interface UserState {
  user: User | null;
  login: (email: string, password: string) => Promise<void>;
}

// Dobrze - używaj typów generycznych
export const useUserStore = create<UserState>()((set) => ({
  //
}));

Dzięki temu TypeScript sprawdzi każdą akcję i każde pole.

3. Error handling

Każda akcja asynchroniczna powinna ustawić loading, a błąd zapisać w stanie:

// Dobrze - obsługuj błędy w store
const fetchData = async () => {
  set({ loading: true, error: null });

  try {
    const data = await api.fetchData();
    set({ data, loading: false });
  } catch (error) {
    set({
      error: error instanceof Error ? error.message : 'Unknown error',
      loading: false
    });
  }
};

Komponent tylko czyta error i loading, nie potrzebuje własnego try/catch.

Podsumowanie

Zustand z Next.js tworzy potężną kombinację dla zarządzania stanem aplikacji:

  1. Minimalist API - proste i czytelne
  2. TypeScript-first - pełne wsparcie typów
  3. SSR-friendly - działa z Server-Side Rendering
  4. Performance - automatyczne optymalizacje
  5. Middleware - bogaty ekosystem rozszerzeń

Moja rada: dane z serwera pobieraj w Server Components, a Zustand zostaw dla stanu interfejsu, zawsze czytając go selektorami. W następnej lekcji poznasz zaawansowane wzorce Server Actions, które zapisują dane po stronie serwera.

Zapamiętaj: Zustand to lekki magazyn stanu Metropolii, jeden hook bez providera i bez boilerplate'u Reduxa.

Kod do tej lekcji: App.tsx
import React, { useState, useCallback } from 'react';

// Simulated Zustand-like store (Sandpack doesn't support zustand package)
function createStore<T>(initialState: T) {
  let state = initialState;
  const listeners = new Set<() => void>();

  return {
    getState: () => state,
    setState: (partial: Partial<T> | ((s: T) => Partial<T>)) => {
      const nextPartial = typeof partial === 'function' ? partial(state) : partial;
      state = { ...state, ...nextPartial };
      listeners.forEach(l => l());
    },
    subscribe: (listener: () => void) => {
      listeners.add(listener);
      return () => listeners.delete(listener);
    },
  };
}

interface Task {
  id: number;
  title: string;
  completed: boolean;
  priority: 'low' | 'medium' | 'high';
}

interface TodoState {
  tasks: Task[];
  filter: 'all' | 'active' | 'completed';
}

const store = createStore<TodoState>({
  tasks: [
    { id: 1, title: 'Configure Zustand store', completed: true, priority: 'high' },
    { id: 2, title: 'Add middleware (devtools, persist)', completed: false, priority: 'medium' },
    { id: 3, title: 'Implement SSR hydration', completed: false, priority: 'high' },
    { id: 4, title: 'Write unit tests', completed: false, priority: 'low' },
  ],
  filter: 'all',
});

function useStore<R>(selector: (s: TodoState) => R): R {
  const [, forceUpdate] = useState(0);
  React.useEffect(() => {
    return store.subscribe(() => forceUpdate(c => c + 1));
  }, []);
  return selector(store.getState());
}

const priorityColors = { high: '#f44336', medium: '#ff9800', low: '#4caf50' };

const ZustandDemo = () => {
  const tasks = useStore(s => s.tasks);
  const filter = useStore(s => s.filter);
  const [newTask, setNewTask] = useState('');
  const [newPriority, setNewPriority] = useState<Task['priority']>('medium');
  const [showCode, setShowCode] = useState(false);

  const filteredTasks = tasks.filter(t => {
    if (filter === 'active') return !t.completed;
    if (filter === 'completed') return t.completed;
    return true;
  });

  const addTask = () => {
    if (!newTask.trim()) return;
    store.setState(s => ({
      tasks: [...s.tasks, { id: Date.now(), title: newTask, completed: false, priority: newPriority }]
    }));
    setNewTask('');
  };

  const toggleTask = (id: number) => {
    store.setState(s => ({
      tasks: s.tasks.map(t => t.id === id ? { ...t, completed: !t.completed } : t)
    }));
  };

  const removeTask = (id: number) => {
    store.setState(s => ({ tasks: s.tasks.filter(t => t.id !== id) }));
  };

  const setFilter = (f: TodoState['filter']) => store.setState({ filter: f });

  const stats = {
    total: tasks.length,
    completed: tasks.filter(t => t.completed).length,
    active: tasks.filter(t => !t.completed).length,
  };

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#fff', fontFamily: 'sans-serif' }}>
      <h1 style={{ color: '#64ffda', textAlign: 'center' }}>Next.js + Zustand</h1>
      <p style={{ textAlign: 'center', color: '#888', marginBottom: '20px' }}>Lightweight state management</p>

      <div style={{ maxWidth: '600px', margin: '0 auto' }}>
        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '10px', marginBottom: '16px' }}>
          {[
            { label: 'Total', value: stats.total, color: '#7c4dff' },
            { label: 'Active', value: stats.active, color: '#ff9800' },
            { label: 'Done', value: stats.completed, color: '#4caf50' },
          ].map(s => (
            <div key={s.label} style={{ background: 'rgba(255,255,255,0.05)', padding: '16px', borderRadius: '8px', textAlign: 'center' }}>
              <div style={{ color: s.color, fontSize: '24px', fontWeight: 'bold' }}>{s.value}</div>
              <div style={{ color: '#888', fontSize: '12px' }}>{s.label}</div>
            </div>
          ))}
        </div>

        <div style={{ display: 'flex', gap: '8px', marginBottom: '16px' }}>
          <input value={newTask} onChange={e => setNewTask(e.target.value)} placeholder="New task..."
            onKeyDown={e => e.key === 'Enter' && addTask()}
            style={{ flex: 1, padding: '10px', background: '#16213e', border: '1px solid #444', borderRadius: '6px', color: '#fff' }} />
          <select value={newPriority} onChange={e => setNewPriority(e.target.value as Task['priority'])}
            style={{ padding: '10px', background: '#16213e', border: '1px solid #444', borderRadius: '6px', color: '#fff' }}>
            <option value="high">High</option>
            <option value="medium">Medium</option>
            <option value="low">Low</option>
          </select>
          <button onClick={addTask} style={{ padding: '10px 16px', background: '#7c4dff', border: 'none', borderRadius: '6px', color: '#fff', cursor: 'pointer' }}>Add</button>
        </div>

        <div style={{ display: 'flex', gap: '6px', marginBottom: '12px' }}>
          {(['all', 'active', 'completed'] as const).map(f => (
            <button key={f} onClick={() => setFilter(f)}
              style={{ padding: '6px 14px', background: filter === f ? '#7c4dff' : 'rgba(255,255,255,0.1)', border: 'none', borderRadius: '4px', color: '#fff', cursor: 'pointer', fontSize: '12px' }}>
              {f.charAt(0).toUpperCase() + f.slice(1)}
            </button>
          ))}
        </div>

        <div style={{ background: 'rgba(255,255,255,0.05)', borderRadius: '10px', overflow: 'hidden' }}>
          {filteredTasks.map(task => (
            <div key={task.id} style={{ display: 'flex', alignItems: 'center', gap: '10px', padding: '12px 16px', borderBottom: '1px solid #1a1a2e' }}>
              <input type="checkbox" checked={task.completed} onChange={() => toggleTask(task.id)} />
              <span style={{ width: '8px', height: '8px', borderRadius: '50%', background: priorityColors[task.priority] }} />
              <span style={{ flex: 1, textDecoration: task.completed ? 'line-through' : 'none', color: task.completed ? '#555' : '#fff' }}>{task.title}</span>
              <button onClick={() => removeTask(task.id)} style={{ background: 'none', border: 'none', color: '#f44336', cursor: 'pointer', fontSize: '16px' }}>x</button>
            </div>
          ))}
          {filteredTasks.length === 0 && <p style={{ textAlign: 'center', color: '#555', padding: '20px' }}>No tasks</p>}
        </div>
      </div>
    </div>
  );
};

export default ZustandDemo;

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. Zustand to biblioteka do:

  2. 2. Które z poniższych NIE jest wbudowanym middleware Zustand?

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

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz store Zustand do zarządzania stanem koszyka zakupowego

  • Edytor kodu

    Zaimplementuj store z actions i selectors.

  • Klikanie w kolejności

    Uporządkuj kroki konfiguracji Zustand store w aplikacji Next.js.

  1. PytanieZustand - biblioteka state management
  2. PytanieMiddleware Zustand
  3. PytanieZustand vs inne state managers
  4. Zadanie z kodemPraktyka: State management z Zustand
  5. Zadanie z kodemZustand store implementation
  6. Kliknij w kolejnościKonfiguracja Zustand store

Przydatne artykuły