Kurs vibe coding z Claude Code · Moduł 14: Klon Pinteresta

Skrzynie na skarby: tablice i zapisywanie

7 min czytania
W tej lekcji10

Przycisk Zapisz już świeci na każdym pinie ale nie ma dokąd zapisać. W Treasure Map piny trafiają na tablice, czyli skrzynie z nazwą: "Wyspy do odwiedzenia", "Stare mapy". Część skrzyń jest tajna: widzi je tylko właściciel i ludzie, których zaprosił do współpracy, czyli współpracownicy. Każda skrzynia ma też okładkę, czyli jeden pin, który reprezentuje ją na profilu. W tej lekcji Claude zbuduje tablice, okno tworzenia tablicy i okno zapisu pinu. Ty dopilnujesz miejsca, w którym agent najchętniej oszczędza: zamka.

Czego się nauczysz

  • zamówić tablice, których zasady dostępu stoją w jednym module i są sprawdzane na serwerze;
  • przeczytać okładkę z coverPinId z rozsądnym zapasem;
  • zbudować dwa okna na <dialog> z lekcji 6_2 i sprawdzić je klawiaturą;
  • udowodnić poleceniem curl, że tajna tablica nie wychodzi z serwera do obcych.

Nawyk: czysty diff

Ta zmiana dotknie kilkunastu plików, więc przed nią zadbaj o porządek w diffie. Jeśli nowy projekt nie ma jeszcze hooka PostToolUse z lekcji 7_1, poproś o niego jednym zdaniem albo przenieś .claude/settings.json z Ship's Comms, razem z Prettierem w projekcie. Hook formatuje każdy plik zaraz po edycji, więc w Source Control zobaczysz tylko zmiany w logice, a nie przesunięte wcięcia. Dzięki temu nie musisz prosić o formatowanie w każdym poleceniu.

Polecenie dla Claude Code

Krok dotyka danych, czterech tras, dwóch stron i dwóch okien, więc zaczynasz od planu:

Polecenie dla Claude Code:

/plan Dodaj tablice, czyli skrzynie na piny. lib/boards.ts: Board z ownerId,
name, description, isSecret, coverPinId, pinIds i collaboratorIds,
magazyn demo na globalThis. Tożsamość tylko z getCurrentUserId()
z lib/session.ts (ciasteczko demo-user, jak w lekcji 11_3), nigdy
z treści żądania. Tajną tablicę widzą właściciel i współpracownicy:
filtruje ją serwer w lib/boards.ts, obcy dostaje 404. Trasy: GET i POST
/api/boards, POST /api/boards/[id]/pins, DELETE /api/boards/[id]
(tylko właściciel). Okładka z coverPinId, a gdy go brak, pierwszy pin.
Okna tworzenia tablicy i zapisu pinu na <dialog> z showModal, jak
w lekcji 6_2. Najpierw testy okładki i trasy GET. Na koniec testy,
lint, npx tsc --noEmit i npm run build.

W planie sprawdź jedno zdanie: gdzie znika tajna tablica. Jeśli plan mówi o "ukryciu w komponencie", odpowiedz, że ma ją odfiltrować serwer.

Co napisał Claude: zasady w jednym miejscu

Otwórz w Cursorze lib/boards.ts. Kto co widzi i kto co może, mówią dwie małe funkcje:

// lib/boards.ts
export function canView(board: Board, viewerId: string | null): boolean {
  return !board.isSecret || board.ownerId === viewerId || board.collaboratorIds.includes(viewerId ?? "");
}

export function canSavePins(board: Board, viewerId: string | null): boolean {
  return viewerId !== null && (board.ownerId === viewerId || board.collaboratorIds.includes(viewerId));
}

viewerId to identyfikator osoby, która ogląda stronę, albo null, gdy nikt nie jest zalogowany. Jawną tablicę widzi każdy, tajną tylko właściciel i współpracownicy. Piny dokładają wyłącznie właściciel i współpracownicy, a usunąć tablicę może tylko właściciel. Każda trasa i każda strona woła te same funkcje, więc zasada stoi w jednym miejscu. Gdy jutro dojdzie nowa rola, zmienisz jeden plik, a nie sześć.

Co napisał Claude: okładka

Stary kod tego modułu sprawdzał coverPinId, ale i tak pokazywał pierwszy pin, więc pole istniało na niby. Wersja Claude:

// lib/boards.ts
export function boardCover(board: Board, pins: ReadonlyMap<string, Pin>): Pin | undefined {
  const coverId = board.coverPinId && board.pinIds.includes(board.coverPinId) ? board.coverPinId : board.pinIds[0];
  return coverId ? pins.get(coverId) : undefined;
}

coverPinId wygrywa, ale tylko wtedy, gdy ten pin wciąż leży w skrzyni. Ktoś mógł go usunąć, a okładka z cudzego pinu byłaby dziwna. W innym wypadku okładką zostaje pierwszy pin, a pusta tablica nie ma okładki wcale i profil pokazuje szary prostokąt. ReadonlyMap to mapa tylko do odczytu, z identyfikatora na pin. Cztery testy pilnują każdej gałęzi. Na profilu /u/kapitan skrzynia "Wyspy do odwiedzenia" pokazała u nas Lagunę z coverPinId, a nie pierwszy pin tablicy.

Tajna tablica znika na serwerze

Otwórz app/api/boards/route.ts:

// app/api/boards/route.ts
export async function GET(request: Request) {
  const owner = new URL(request.url).searchParams.get("owner");
  if (!owner) return Response.json({ error: "Podaj właściciela." }, { status: 400 });
  const viewerId = await getCurrentUserId();
  return Response.json(listBoards(owner, viewerId).map(({ id, name, isSecret }) => ({ id, name, isSecret })));
}

listBoards filtruje przez canView, zanim cokolwiek wyjdzie z serwera, a map wysyła tylko pola potrzebne liście. To jest typowy błąd agenta w tym miejscu: trasa oddaje wszystkie tablice, a komponent ukrywa tajne warunkiem !board.isSecret || isOwner. Na ekranie wszystko się zgadza, ale nazwa tajnej skrzyni leci do każdej przeglądarki i widać ją w zakładce Network. Sprawdź to przy działającym npm run dev, jako obcy i jako właściciel:

curl -s -b demo-user=papuga 'localhost:3000/api/boards?owner=kapitan'
curl -s -b demo-user=kapitan 'localhost:3000/api/boards?owner=kapitan'

-b wysyła ciasteczko, czyli udaje zalogowaną osobę. U nas Papuga dostała tylko [{"id":"b1","name":"Wyspy do odwiedzenia","isSecret":false}], a kapitan także "Kryjówkę skarbu". Strona tablicy działa tak samo: getBoard zwraca null dla cudzej tajnej tablicy, a strona woła notFound(). Obcy dostaje 404, a nie 403. Kod 403 zdradziłby, że tablica istnieje.

Co napisał Claude: okno zapisu

Otwórz components/SavePinDialog.tsx. PinFeed trzyma w stanie pin, który ktoś chce zapisać, a okno otwiera się, gdy ten pin się pojawi:

// components/SavePinDialog.tsx
useEffect(() => {
  if (pin) dialogRef.current?.showModal();
}, [pin]);

Efekt nie ustawia stanu, tylko woła metodę elementu, więc reguła set-state-in-effect nie ma się do czego przyczepić. Samo okno:

// components/SavePinDialog.tsx
<dialog ref={dialogRef} aria-labelledby="save-pin-title" onClose={() => { setStatus(null); onClose(); }} className="m-auto w-full max-w-sm rounded-2xl bg-white p-5 backdrop:bg-black/50">
  <h2 id="save-pin-title">Zapisz: {pin?.title}</h2>
  <button type="button" onClick={() => dialogRef.current?.close()} aria-label="Zamknij okno zapisu">×</button>

Z lekcji 6_2 wiesz, że showModal() przenosi fokus do okna, Esc je zamyka, a m-auto stawia je na środku mimo resetu marginesów w Tailwind 4. Zdarzenie onClose przychodzi i po Esc, i po close(), więc rodzic w obu przypadkach czyści wybrany pin. Krzyżyk ma aria-label, bo sam znak "×" nie mówi czytnikowi ekranu, co robi przycisk. Pod nagłówkiem stoi lista tablic zalogowanej osoby, przy tajnych dopisek "(tajna)". Kliknięcie wysyła POST /api/boards/[id]/pins, a pole role="status" mówi, czy się udało.

Okno tworzenia tablicy, components/CreateBoardDialog.tsx, ma formularz z nazwą (required, maxLength={50}) i polem wyboru "Tajna tablica". Trasa POST /api/boards sprawdza długość nazwy jeszcze raz, bo ograniczenia formularza to tylko podpowiedzi przeglądarki. Po sukcesie okno się zamyka, a router.refresh() odświeża dane Server Componentu, więc nowa skrzynia staje na profilu bez przeładowania.

Akcje właściciela na serwerze

Strona tablicy pokazuje przyciski Edytuj tablicę i Usuń tylko wtedy, gdy viewerId === board.ownerId. Ukryty przycisk niczego jednak nie chroni, bo żądanie można wysłać z pominięciem strony. Dlatego DELETE /api/boards/[id] sprawdza wszystko jeszcze raz, po kolei: tożsamość z getCurrentUserId(), potem getBoard (brak albo cudza tajna tablica to 404), dopiero potem właściciela (403). Usuwa na samym końcu. U nas Papuga, choć jest współpracownikiem, dostała przy próbie usunięcia {"error":"Tylko właściciel usuwa tablicę."} z kodem 403. Ta sama Papuga dołożyła pin do "Wysp do odwiedzenia" (201), a przy tajnej "Kryjówce skarbu" dostała 404.

Pod nagłówkiem tablicy przydadzą się jeszcze sekcje, czyli przegródki w skrzyni, na przykład Karaiby i Pacyfik. Wybrana sekcja to zwykły stan activeSection komponentu, a listę widocznych pinów liczy render z tego stanu, tak jak kolumny w lekcji 13_1.

Przegląd kapitana

  1. Zamek na serwerze. Wyszukaj isSecret w components/. Wolno go tylko wyświetlać jako "(tajna)", nigdy filtrować. Potem uruchom dwa polecenia curl z tej lekcji.
  2. Kto pyta. Wyszukaj body.ownerId i ownerId: w trasach. Właściciel nowej tablicy ma pochodzić z getCurrentUserId(). Agent lubi przyjąć ownerId z formularza, a wtedy każdy może założyć tablicę na cudze konto.
  3. Okładka. Ustaw jakiejś tablicy coverPinId na pin spoza niej i sprawdź profil: ma wrócić pierwszy pin.
  4. Klawiatura. Tab do przycisku Zapisz, Enter, Esc. U nas fokus wszedł na krzyżyk, a po Esc wrócił na "Zapisz pin: Zatoka o świcie". Okno tworzenia tablicy stanęło na środku z fokusem w polu Nazwa. Agent często buduje okno z div i fixed inset-0. Wtedy Esc nic nie robi, a Tab ucieka na stronę pod spodem.

Następny krok

Gdy przegląd przejdzie, poproś o commit "Tablice, tajne skrzynie i zapisywanie pinów". Potem mały krok, znowu z planem: "Dodaj sekcje tablicy: sections z id, name i pinIds, przełączane przyciskami nad siatką; sekcję może dodać tylko właściciel, co sprawdza trasa". W edytorze poniżej czeka skrzynia w miniaturze: okno zapisu na <dialog>, przełącznik widoku obcego i właściciela, sekcje i okładka z coverPinId.

Zapamiętaj: skrzynia bez zamka to tylko szkatułka, a zamek zakładasz w sercu portu, na serwerze, nie na wieku namalowanym w interfejsie.

Kod do tej lekcji: App.tsx
// Skrzynia w miniaturze: zamek po stronie serwera, okładka z coverPinId, okno zapisu na <dialog> i sekcje
import { useRef, useState } from 'react';

interface Pin {
  id: string;
  title: string;
  color: string;
  sectionId: string | null;
}

interface Board {
  id: string;
  ownerId: string;
  name: string;
  isSecret: boolean;
  coverPinId: string | null;
  pinIds: string[];
  collaboratorIds: string[];
}

const PINS: Pin[] = [
  { id: 'p1', title: 'Piasek pod palmą', color: '#e8c868', sectionId: 'karaiby' },
  { id: 'p2', title: 'Laguna', color: '#a8c808', sectionId: 'karaiby' },
  { id: 'p3', title: 'Dżungla na wyspie', color: '#284858', sectionId: 'pacyfik' },
  { id: 'p4', title: 'Złoto w skrzyni', color: '#f88808', sectionId: null },
  { id: 'p5', title: 'Stara mapa', color: '#986848', sectionId: null },
];
const pinsById = new Map(PINS.map((pin) => [pin.id, pin]));
const SECTIONS = [
  { id: 'karaiby', name: 'Karaiby' },
  { id: 'pacyfik', name: 'Pacyfik' },
];

const BOARDS: Board[] = [
  { id: 'b1', ownerId: 'kapitan', name: 'Wyspy do odwiedzenia', isSecret: false, coverPinId: 'p2', pinIds: ['p1', 'p2', 'p3'], collaboratorIds: ['papuga'] },
  { id: 'b2', ownerId: 'kapitan', name: 'Kryjówka skarbu', isSecret: true, coverPinId: null, pinIds: ['p4', 'p5'], collaboratorIds: [] },
];

// "Serwer": te funkcje w projekcie stoją w lib/boards.ts i trasach API
function canView(board: Board, viewerId: string | null) {
  return !board.isSecret || board.ownerId === viewerId || board.collaboratorIds.includes(viewerId ?? '');
}
function serverListBoards(viewerId: string | null) {
  return BOARDS.filter((board) => canView(board, viewerId));
}
function serverDeleteBoard(board: Board, viewerId: string | null) {
  return board.ownerId === viewerId ? '204: tablica usunięta' : '403: Tylko właściciel usuwa tablicę.';
}
function boardCover(board: Board): Pin | undefined {
  const coverId = board.coverPinId && board.pinIds.includes(board.coverPinId) ? board.coverPinId : board.pinIds[0];
  return coverId ? pinsById.get(coverId) : undefined;
}

const VIEWERS = [
  { id: 'kapitan', label: 'Kapitan (właściciel)' },
  { id: 'papuga', label: 'Papuga (współpracownik)' },
  { id: '', label: 'Obcy (bez logowania)' },
];

export default function App() {
  const [viewer, setViewer] = useState('kapitan');
  const viewerId = viewer || null;
  const [openBoardId, setOpenBoardId] = useState('b1');
  const [activeSection, setActiveSection] = useState<string | null>(null);
  const [message, setMessage] = useState('');
  const [savedTo, setSavedTo] = useState<string | null>(null);
  const dialogRef = useRef<HTMLDialogElement>(null);

  const boards = serverListBoards(viewerId);
  const board = boards.find((b) => b.id === openBoardId) ?? boards[0];
  const visiblePins = board.pinIds
    .map((id) => pinsById.get(id))
    .filter((pin): pin is Pin => pin !== undefined && (activeSection === null || pin.sectionId === activeSection));
  const myBoards = boards.filter((b) => viewerId !== null && (b.ownerId === viewerId || b.collaboratorIds.includes(viewerId)));

  return (
    <div className="min-h-screen space-y-4 bg-amber-50 p-4 text-zinc-900">
      <label className="flex items-center gap-2 text-sm">
        Kto ogląda:
        <select value={viewer} onChange={(e) => { setViewer(e.target.value); setMessage(''); }} className="rounded border border-zinc-300 px-2 py-1">
          {VIEWERS.map((v) => (
            <option key={v.id} value={v.id}>{v.label}</option>
          ))}
        </select>
      </label>
      <p className="rounded bg-zinc-900 p-2 font-mono text-xs text-green-300">
        GET /api/boards?owner=kapitan → {JSON.stringify(boards.map((b) => b.name))}
      </p>
      <ul className="grid grid-cols-2 gap-3">
        {boards.map((b) => {
          const cover = boardCover(b);
          return (
            <li key={b.id}>
              <button type="button" onClick={() => { setOpenBoardId(b.id); setActiveSection(null); }} className="w-full text-left">
                <div className="aspect-square rounded-xl" style={{ backgroundColor: cover?.color ?? '#d4d4d8' }} />
                <p className="font-semibold">{b.name}{b.isSecret ? ' (tajna)' : ''}</p>
                <p className="text-xs text-zinc-500">Okładka: {cover?.title ?? 'brak'}</p>
              </button>
            </li>
          );
        })}
      </ul>
      <section className="rounded-xl bg-white p-3">
        <h1 className="text-lg font-bold">{board.name}</h1>
        <div className="my-2 flex flex-wrap gap-2">
          <button type="button" onClick={() => setActiveSection(null)} className={activeSection === null ? 'rounded-full bg-black px-3 py-1 text-white' : 'rounded-full bg-zinc-200 px-3 py-1'}>
            Wszystkie
          </button>
          {SECTIONS.map((section) => (
            <button key={section.id} type="button" onClick={() => setActiveSection(section.id)} className={activeSection === section.id ? 'rounded-full bg-black px-3 py-1 text-white' : 'rounded-full bg-zinc-200 px-3 py-1'}>
              {section.name}
            </button>
          ))}
        </div>
        <ul className="flex flex-wrap gap-2">
          {visiblePins.map((pin) => (
            <li key={pin.id} className="rounded-lg px-3 py-6 text-sm text-white" style={{ backgroundColor: pin.color }}>
              <span className="rounded bg-black/50 px-1">{pin.title}</span>
            </li>
          ))}
        </ul>
        <div className="mt-3 flex flex-wrap gap-2">
          <button type="button" onClick={() => { setSavedTo(null); dialogRef.current?.showModal(); }} className="rounded-full bg-red-600 px-4 py-2 font-semibold text-white">
            Zapisz pin Rafa koralowa
          </button>
          {viewerId === board.ownerId && (
            <button type="button" className="rounded-full bg-zinc-200 px-4 py-2">Edytuj tablicę</button>
          )}
          <button type="button" onClick={() => setMessage(serverDeleteBoard(board, viewerId))} className="rounded-full bg-zinc-200 px-4 py-2">
            Wyślij DELETE (z pominięciem przycisku)
          </button>
        </div>
        {message && <p role="status" className="mt-2 text-sm">{message}</p>}
      </section>
      <dialog ref={dialogRef} aria-labelledby="save-title" className="m-auto w-full max-w-sm rounded-2xl bg-white p-5 backdrop:bg-black/50">
        <div className="flex items-start justify-between">
          <h2 id="save-title" className="text-lg font-bold">Zapisz: Rafa koralowa</h2>
          <button type="button" onClick={() => dialogRef.current?.close()} aria-label="Zamknij okno zapisu" className="px-2 text-xl">×</button>
        </div>
        {myBoards.length === 0 ? (
          <p className="mt-3">Zaloguj się, żeby zapisywać piny.</p>
        ) : (
          <ul className="mt-3 space-y-2">
            {myBoards.map((b) => (
              <li key={b.id}>
                <button type="button" onClick={() => setSavedTo(b.name)} className="w-full rounded-lg bg-zinc-100 px-3 py-2 text-left">
                  {b.name}{b.isSecret ? ' (tajna)' : ''}
                </button>
              </li>
            ))}
          </ul>
        )}
        <p role="status" className="mt-2 text-sm">{savedTo ? 'Zapisano w skrzyni: ' + savedTo : ''}</p>
      </dialog>
      <p className="text-sm text-zinc-600">Otwórz okno zapisu, a potem naciśnij Esc: okno się zamknie, a fokus wróci na przycisk.</p>
    </div>
  );
}

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. Czym jest tablica w naszym klonie?

  2. 2. Kto widzi tajną tablicę i gdzie zostaje ona ukryta przed resztą?

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

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż wywołanie, które otwiera okno zapisu jako modal:

  • Klikanie w kolejności

    Kliknij elementy, aby zbudować linię trasy, która ustala tożsamość z ciasteczka, a nie z treści żądania:

  • Edytor kodu

    Stwórz modal do tworzenia board

  • Układanie w pionie

    Uporządkuj kroki zapisu pinu przez SavePinDialog:

  • Edytor kodu

    Stwórz modal do zapisywania pina

  • Układanie w pionie

    Uporządkuj kroki trasy DELETE /api/boards/[id] od pierwszego do ostatniego:

  • Klikanie w kolejności

    Kliknij elementy, aby zbudować obsługę kliknięcia przycisku sekcji:

  • Układanie w poziomie

    Ułóż ostatnią linię funkcji boardCover:

  1. PytanieQuiz: Tablica w Treasure Map
  2. PytanieQuiz: Kto widzi tajną tablicę
  3. Ułóż w kolejnościSortowanie: Otwarcie okna dialog
  4. Kliknij w kolejnościBudowanie: Kto pyta
  5. Zadanie z kodemPraktyka: Create board modal
  6. PytanieQuiz: Sekcje tablicy
  7. PytanieQuiz: Prawa współpracownika
  8. Ułóż w kolejnościSortowanie: Zapis pinu do skrzyni
  9. Zadanie z kodemPraktyka: Save pin modal
  10. PytanieQuiz: Okładka z coverPinId
  11. Ułóż w kolejnościSortowanie: Kontrole trasy DELETE
  12. Kliknij w kolejnościBudowanie: Wybór sekcji
  13. PytanieQuiz: Akcje właściciela na serwerze
  14. Ułóż w kolejnościSortowanie: Okładka albo nic

Przydatne artykuły