Kurs vibe coding z Claude Code · Moduł 15: Claude Code dla zaawansowanych

Bezpieczeństwo kodu od Claude Code: lista kontrolna przed publikacją

10 min czytania
W tej lekcji12

Treasure Map ma wypłynąć na szerokie wody: jeszcze jedna funkcja i pierwsze wdrożenie, jak w lekcji 10_5. Tą funkcją jest edycja pinu. Właściciel zmienia tytuł i tagi, a przycisk "Podpowiedz tagi" pyta zewnętrzną usługę o propozycje. Claude oddał ją w kwadrans: testy zielone, build przechodzi, w przeglądarce wszystko się zgadza. Pustego tytułu formularz nie wyśle, a sto pierwszego znaku nie da się wpisać. Ekran nie pokazuje jednak dwóch rzeczy. Serwer przyjmuje wszystko, co do niego przyjdzie, bo required i maxLength działają tylko w przeglądarce. A klucz do usługi tagów leży w kodzie klienta, więc każdy gość pobiera go razem ze stroną. Ta lekcja daje Ci listę kontrolną bezpieczeństwa kodu: Claude ją przechodzi, a Ty sprawdzasz jego meldunek.

Co już umiesz

Lekcja 14_7 pilnowała tego, co agent może zrobić na Twoim komputerze: tryb auto, reguły deny i sandbox. Ta lekcja pilnuje tego, co jego kod zrobi u Twoich użytkowników. Większość punktów znasz: klucz w ładowni z lekcji 8_4, przedrostek NEXT_PUBLIC_ i klucz w buildzie z lekcji 10_5, zamek w każdej trasie z lekcji 11_3 i 13_2, listę dozwolonych pól z lekcji 13_5, /security-review z lekcji 8_7 i skill /przed-publikacja z lekcji 10_7. Tu składasz je w jedną listę dla kodu aplikacji i dokładasz nagłówki bezpieczeństwa oraz npm audit.

Polecenie dla Claude Code

Lista ma sens tylko wtedy, gdy każdy punkt kończy się dowodem, dlatego prosisz o plik i linię, a nie o zapewnienie. Claude niczego nie zmienia, a pliki dostaje przez @:

Przed publikacją przejdź listę bezpieczeństwa kodu Treasure Map. Niczego nie
zmieniaj. Pliki: @components/EditPinForm.tsx, @app/api/pins/[id]/route.ts,
@app/api/pins/route.ts, @app/api/boards/[id]/route.ts, @next.config.ts.
Punkty: (1) klucz w zmiennej NEXT_PUBLIC_ albo process.env w komponencie
z "use client"; (2) każda trasa zapisu sprawdza sesję i właściciela, zanim
coś zmieni; (3) dane z ciała żądania przechodzą przez schemat Zod z listą
dozwolonych pól na serwerze; (4) każdy handler zwraca Response w każdej
gałęzi; (5) nagłówki bezpieczeństwa w next.config.ts. Wynik: tabela
z kolumnami punkt, plik i linia, ZALICZONE albo NIE ZALICZONE, dowód.

Co odpowiedział Claude

Uruchomiliśmy to polecenie w trybie -p, z Sonnetem i samymi narzędziami do czytania. Odpowiedź przyszła jako tabela. Trzy jej wiersze, skrócone, wyglądały tak:

(1) Sekrety | components/EditPinForm.tsx:12 | NIE ZALICZONE | Komponent ma "use client" i czyta process.env.NEXT_PUBLIC_TAGS_API_KEY, więc klucz trafia do paczki w przeglądarce.
(2) Sesja i właściciel, PATCH pinu | app/api/pins/[id]/route.ts:14-16 | NIE ZALICZONE | Sprawdza tylko, czy jest sesja. Każdy zalogowany może zmienić cudzy pin.
(3) Zod na serwerze, PATCH pinu | app/api/pins/[id]/route.ts:15-16 | NIE ZALICZONE | Wartości z request.json() idą do updatePin bez schematu.

Tabela to meldunek zwiadowcy, a nie wyrok. Każdy wiersz NIE ZALICZONE sprawdzasz sam, jak raport w lekcji 8_7: otwierasz plik w Cursorze na podanej linii i próbujesz odtworzyć problem. Czytaj tabelę, a nie podsumowanie: zdanie nad nią mówiło o trzech nieudanych punktach z pięciu, a w samej tabeli każdy punkt miał przynajmniej jeden wiersz NIE ZALICZONE. Pod tabelą Claude dopisał uwagę, o którą nie prosiliśmy: skoro klucz był w paczce, trzeba go uznać za ujawniony i wymienić.

Punkt 1: klucz zostaje na serwerze

Linia, którą wskazał Claude, wygląda niewinnie:

// components/EditPinForm.tsx (wersja agenta)
headers: { Authorization: `Bearer ${process.env.NEXT_PUBLIC_TAGS_API_KEY}` },

Przedrostek NEXT_PUBLIC_ każe Next.js wpisać wartość zmiennej w kod wysyłany do przeglądarki, już w czasie builda. U nas po next build klucz z przedrostkiem znalazł się w pliku w .next/static/chunks, a klucz bez przedrostka, czytany tylko na serwerze, nie pojawił się tam ani razu. Lint, tsc i build milczały. Poprawka to wzór z lekcji 8_4: trasa app/api/tags/route.ts czyta process.env.TAGS_API_KEY i sama pyta usługę, a formularz woła już tylko naszą trasę. Klucz, który choć raz trafił do wdrożonej paczki, wymieniasz u dostawcy, bo nie wiesz, kto go pobrał.

Punkt 2: zamki w każdej trasie zapisu

Wersja agenta sprawdzała tylko, czy ktoś jest zalogowany, więc u nas Kapitan zmienił tytuł pinu Papugi jednym poleceniem curl. Poprawiona trasa zaczyna od zamków, w tej kolejności:

// app/api/pins/[id]/route.ts
const viewerId = await getCurrentUserId();
if (!viewerId) return Response.json({ error: "Zaloguj się." }, { status: 401 });
const ownerId = await getPinOwner(id);
if (!ownerId) return Response.json({ error: "Nie ma takiego pinu." }, { status: 404 });
if (ownerId !== viewerId) return Response.json({ error: "Tylko autor edytuje pin." }, { status: 403 });

getPinOwner i updatePin to dwie małe funkcje z lib/pinStore.ts: pierwsza czyta z bazy samo pole ownerId, druga zapisuje tytuł i tagi. Właściciel pochodzi z bazy, a zalogowany z sesji, nigdy z ciała żądania. Kolejność ma znaczenie: obcy dostaje odmowę, zanim serwer przeczyta choć jedno pole formularza.

Punkt 3: walidacja na serwerze

Atrybuty required i maxLength to uprzejmość dla uczciwego gościa, a nie straż, bo curl w ogóle nie otwiera formularza. U nas wersja agenta bez schematu przyjęła z kodem 200 tytuł z trzech spacji, siedem tagów i tytuł na pięć tysięcy znaków, a baza zapisała wszystko. Na serwerze stoi więc lista dozwolonych pól z lekcji 13_5, tym razem dla edycji:

// lib/pinInput.ts
export const pinEditSchema = z.strictObject({
  title: z.string().trim().min(1, "Podaj tytuł.").max(100, "Tytuł ma najwyżej 100 znaków."),
  tags: z.array(z.string().trim().min(1).max(30)).max(5, "Najwyżej 5 tagów."),
});

Schemat przepuszcza tylko tytuł i tagi. Obrazu, wymiarów ani właściciela edycją zmienić się nie da, a z.strictObject odrzuca każde pole spoza listy, także ownerId. Atrybuty w formularzu zostają, bo oszczędzają uczciwym użytkownikom zbędnej rundy do serwera, ale granica przebiega w trasie.

Punkt 4: odpowiedź w każdej gałęzi

Uważaj na poprawkę, która tylko wygląda na gotową. Taki handler stał w starej wersji tej lekcji jako wzór:

// app/api/pins/[id]/route.ts (wersja z błędem)
const body = await request.json();
try {
  const data = pinEditSchema.parse(body);
  await updatePin(id, data);
} catch {
  return Response.json({ error: "Niepoprawne dane." }, { status: 400 });
}

Złe dane dostają 400, ale po udanym zapisie funkcja kończy się bez return, czyli zwraca undefined. Next.js odpowiada wtedy kodem 500, a w logu next start pisze No response is returned from route handler z radą, żeby zwracać Response we wszystkich gałęziach. Najgorsze, że zmiana zdążyła trafić do bazy: klient widzi błąd i klika jeszcze raz. tsc, lint i build przepuściły ten handler, a złapał go dopiero test z expect(res).toBeInstanceOf(Response). Do tego catch łapie każdy wyjątek, więc awarię bazy też przedstawi jako złe dane. Poprawiona druga połowa trasy odpowiada w każdej gałęzi:

const body = await request.json().catch(() => null);
const result = pinEditSchema.safeParse(body);
if (!result.success) {
  return Response.json({ error: "Popraw pola.", fields: z.flattenError(result.error).fieldErrors }, { status: 400 });
}
const pin = await updatePin(id, result.data);
return Response.json(pin);

safeParse nie rzuca wyjątku, tylko zwraca wynik z polem success, więc każda ścieżka kończy się jawnym return, a ciało, które nie jest JSON-em, daje 400 zamiast 500. U nas curl dostał kolejno 401 bez ciasteczka, 403 jako obcy, 400 dla pustego tytułu i dla pola ownerId, 404 dla nieistniejącego pinu i 200 dla właściciela. Przy okazji: stara lekcja sprawdzała adres zapisem z.string().email(), który obecny Zod oznacza jako przestarzały. Dziś piszesz z.email().

Punkt 5: nagłówki bezpieczeństwa

Nagłówki to instrukcje dla przeglądarki, dołączane do każdej odpowiedzi. Stara wersja lekcji ustawiała je w next.config.js przez module.exports i tak samo wyglądają przykłady w dokumentacji Next.js, więc agent chętnie przepisze tę postać. Projekt z create-next-app ma jednak next.config.ts z export default, a nagłówki dopisujesz do niego:

// next.config.ts
const securityHeaders = [
  { key: "X-Content-Type-Options", value: "nosniff" },
  { key: "Referrer-Policy", value: "strict-origin-when-cross-origin" },
  { key: "X-Frame-Options", value: "DENY" },
  { key: "Permissions-Policy", value: "camera=(), microphone=(), geolocation=()" },
];

Pierwszy zabrania przeglądarce zgadywania typu pliku, drugi ogranicza adres zdradzany innym stronom, trzeci nie pozwala osadzić Treasure Map w ramce (iframe) na żadnej stronie, a czwarty wyłącza kamerę, mikrofon i położenie, których aplikacja nie używa, bo lupa bierze zdjęcie z pliku. W obiekcie nextConfig, obok turbopack, dochodzą dwie pozycje:

  poweredByHeader: false,
  async headers() {
    return [{ source: "/:path*", headers: securityHeaders }];
  },

source: "/:path*" obejmuje każdą ścieżkę, także trasy API, a poweredByHeader: false usuwa nagłówek X-Powered-By, który zdradza framework. Sprawdzasz na zbudowanej aplikacji: npm run build, npm run start i w drugim terminalu curl -sI localhost:3000/api/pins/p01. U nas pod HTTP/1.1 200 OK stały wszystkie cztery nagłówki i ani śladu X-Powered-By.

Najmocniejszy nagłówek, Content-Security-Policy, wylicza dozwolone źródła skryptów, stylów i obrazów. Dokumentacja Next.js ma dla niego osobny przewodnik: bez jednorazowych kodów (nonce) ustawisz go w tym samym headers(), a z nimi każda strona musi renderować się dynamicznie. Polityka wymaga wypisania każdego źródła, z którego korzysta aplikacja, więc to osobny krok, sprawdzany w przeglądarce, a nie linijka przepisana z poradnika.

Punkt 6: npm audit z rozsądkiem

npm audit wysyła do rejestru npm opis zależności projektu i wypisuje znane podatności w ich wersjach. Gdy znajdzie choć jedną, kończy się kodem różnym od zera. U nas w Treasure Map (stan na listopad 2026) zgłosił osiem podatności o wadze moderate, a pierwsza wyglądała tak:

minimatch  7.0.0 - 11.0.0
Severity: moderate
fix available via `npm audit fix --force`
Will install eslint-config-next@15.5.29, which is a breaking change

Raport czytasz od pytania, gdzie ta paczka pracuje. Wszystkie osiem wpisów to jeden łańcuch: minimatch w narzędziach typescript-eslint, których używa eslint-config-next, czyli lint na Twoim komputerze, a nie kod u użytkowników. Proponowana naprawa cofnęłaby konfigurację lintu do starszej linii Next.js, bo --force według dokumentacji npm instaluje wersje spoza zakresu z package.json, także ze zmianą łamiącą zgodność. Kod aplikacji sprawdza npm audit --omit=dev, które pomija zależności deweloperskie. U nas odpowiedziało found 0 vulnerabilities. Podatność w zależności produkcyjnej poprawiasz od razu i sprawdzasz testami, a podatność w narzędziu zapisujesz i czekasz na wydanie, które ją usunie.

Punkt 7: /security-review na gałęzi

Lista łapie to, czego umiesz szukać. /security-review z lekcji 8_7 szuka tego, o czym nie pomyślałeś: porównuje gałąź z domyślną gałęzią origin i czyta zmiany pod kątem wstrzyknięć, błędów uwierzytelniania i wycieku danych. Na tej gałęzi go nie uruchamialiśmy, więc nie pokazujemy raportu. Każde zgłoszenie ma wagę (Severity) i pewność (Confidence), ale obie to ocena modelu, a nie dowód. Otwierasz wskazany plik, próbujesz odtworzyć atak poleceniem curl albo testem i dopiero wtedy decydujesz. Przyjęty punkt poprawiasz wąskim poleceniem z testem, który bez poprawki pada, a przy odrzuconym zapisujesz, czym go odrzuciłeś. Pusty raport nie znaczy, że lista jest zbędna, bo przegląd potrafi pominąć prawdziwe, ale mało groźne znalezisko.

Przegląd kapitana

  1. Sekrety. grep -rn NEXT_PUBLIC_ app components nie pokazuje żadnego klucza, a po buildzie fragment każdego klucza daje zero trafień w .next/static.
  2. Zamki. Każda trasa zapisu ma test na brak sesji i na cudzego użytkownika.
  3. Każda gałąź. Test sukcesu sprawdza, że handler zwrócił Response z właściwym kodem, a nie tylko, że dane się zapisały.
  4. Nagłówki i paczki. curl -sI pokazuje cztery nagłówki, a każdy wpis z npm audit ma Twoją decyzję.

Typowy błąd agenta: walidacja tylko w przeglądarce. Claude dopisuje required, maxLength albo sprawdzenie w onSubmit i melduje, że dane są sprawdzone, a trasa dalej przyjmuje ciało bez schematu. Rozpoznasz to w diffie: zmiany są w komponencie, a w trasie nie ma safeParse. Sprawdzisz poleceniem curl, które formularza w ogóle nie widzi.

Następny krok

Poprawki zlecasz po jednej na punkt, z testem i commitem po każdej. Potem utrwalasz listę, żeby nie zależała od Twojej pamięci: "Dopisz do skilla /przed-publikacja z lekcji 10_7 część Bezpieczeństwo kodu: punkty 1-5 z naszej listy i npm audit --omit=dev, a dla kapitana /security-review i curl -sI na zbudowanej aplikacji. Skill niczego nie poprawia". Jeśli Treasure Map nie ma jeszcze tego skilla, Claude go utworzy. Zmianę w SKILL.md czytasz w diffie jak kod, a potem commit, na przykład "Bezpieczeństwo kodu przed publikacją". W edytorze poniżej czeka lista kontrolna: włączaj błędy agenta w trasie i konfiguracji i patrz, który punkt je łapie.

Pamiętaj: atrybuty formularza to uprzejmość dla uczciwej załogi, a zamki na serwerze to jedyna straż, której pirat nie obejdzie.

Kod do tej lekcji: App.tsx
// Lista kontrolna przed publikacją: włącz błędy agenta i zobacz, który punkt je łapie
import { useState } from 'react';

export type Status = 'ZALICZONE' | 'NIE ZALICZONE';
export type ConfigFile = 'ts' | 'js';
export type Scenario = 'bez sesji' | 'obcy' | 'pusty tytuł' | 'pole ownerId' | 'właściciel';

export interface Setup {
  keyInClient: boolean;
  sessionCheck: boolean;
  ownerCheck: boolean;
  serverSchema: boolean;
  catchJson: boolean;
  returnsOnSuccess: boolean;
  headers: boolean;
  configFile: ConfigFile;
  prodVulns: number;
  devVulns: number;
}

export interface Row {
  point: string;
  status: Status;
  proof: string;
}

export interface Outcome {
  status: number;
  saved: boolean;
}

export const SCENARIOS: Scenario[] = ['bez sesji', 'obcy', 'pusty tytuł', 'pole ownerId', 'właściciel'];

export const SAFE: Setup = {
  keyInClient: false,
  sessionCheck: true,
  ownerCheck: true,
  serverSchema: true,
  catchJson: true,
  returnsOnSuccess: true,
  headers: true,
  configFile: 'ts',
  prodVulns: 0,
  devVulns: 8,
};

export const AGENT: Setup = { ...SAFE, keyInClient: true, ownerCheck: false, serverSchema: false, catchJson: false, headers: false };
export const OLD_LESSON: Setup = { ...SAFE, sessionCheck: false, ownerCheck: false, catchJson: false, returnsOnSuccess: false, configFile: 'js' };

const OWNER = 'papuga';

function viewerOf(sc: Scenario): string | null {
  if (sc === 'bez sesji') return null;
  if (sc === 'obcy') return 'kapitan';
  return OWNER;
}

// Co odpowie trasa PATCH /api/pins/p01 i czy pin zmieni się w bazie
export function simulate(s: Setup, sc: Scenario): Outcome {
  const viewer = viewerOf(sc);
  if (s.sessionCheck && viewer === null) return { status: 401, saved: false };
  if (s.ownerCheck && viewer !== OWNER) return { status: 403, saved: false };
  const invalid = sc === 'pusty tytuł' || sc === 'pole ownerId';
  if (s.serverSchema && invalid) return { status: 400, saved: false };
  if (!s.returnsOnSuccess) return { status: 500, saved: true };
  return { status: 200, saved: true };
}

export function checklist(s: Setup): Row[] {
  const rows: Row[] = [];
  rows.push(
    s.keyInClient
      ? { point: '1. Sekrety', status: 'NIE ZALICZONE', proof: 'EditPinForm.tsx ma "use client" i czyta process.env.NEXT_PUBLIC_TAGS_API_KEY: klucz trafi do .next/static. Przenieś wywołanie do trasy i wymień klucz u dostawcy.' }
      : { point: '1. Sekrety', status: 'ZALICZONE', proof: 'Klucz czyta tylko trasa na serwerze: process.env.TAGS_API_KEY, bez przedrostka NEXT_PUBLIC_.' },
  );
  const stranger = simulate(s, 'obcy');
  const anonymous = simulate(s, 'bez sesji');
  if (anonymous.saved) {
    rows.push({ point: '2. Zamki', status: 'NIE ZALICZONE', proof: 'curl bez ciasteczka zmienia pin: trasa nie sprawdza sesji.' });
  } else if (stranger.saved) {
    rows.push({ point: '2. Zamki', status: 'NIE ZALICZONE', proof: 'Kapitan zmienia pin Papugi: brak porównania ownerId z viewerId i odpowiedzi 403.' });
  } else {
    rows.push({ point: '2. Zamki', status: 'ZALICZONE', proof: '401 bez sesji i 403 dla obcego, zanim serwer przeczyta ciało.' });
  }
  rows.push(
    s.serverSchema
      ? { point: '3. Walidacja', status: 'ZALICZONE', proof: 'pinEditSchema.safeParse na serwerze: tylko title i tags, z.strictObject odrzuca ownerId.' }
      : { point: '3. Walidacja', status: 'NIE ZALICZONE', proof: 'Tylko required i maxLength w formularzu: curl zapisuje tytuł z trzech spacji i siedem tagów.' },
  );
  if (!s.returnsOnSuccess) {
    rows.push({ point: '4. Odpowiedź', status: 'NIE ZALICZONE', proof: 'Po zapisie brak return: 500 i No response is returned from route handler, a zmiana już jest w bazie.' });
  } else if (!s.catchJson) {
    rows.push({ point: '4. Odpowiedź', status: 'NIE ZALICZONE', proof: 'request.json() bez .catch: ciało, które nie jest JSON-em, kończy się 500 zamiast 400.' });
  } else {
    rows.push({ point: '4. Odpowiedź', status: 'ZALICZONE', proof: 'Każda gałąź kończy się return z Response: 400, 401, 403, 404 albo 200.' });
  }
  if (s.configFile === 'js') {
    rows.push({ point: '5. Nagłówki', status: 'NIE ZALICZONE', proof: 'Przepisane z poradnika: next.config.js i module.exports. Projekt ma next.config.ts z export default, tam dopisz headers().' });
  } else if (!s.headers) {
    rows.push({ point: '5. Nagłówki', status: 'NIE ZALICZONE', proof: 'curl -sI nie pokazuje X-Content-Type-Options, Referrer-Policy, X-Frame-Options ani Permissions-Policy.' });
  } else {
    rows.push({ point: '5. Nagłówki', status: 'ZALICZONE', proof: 'curl -sI na zbudowanej aplikacji pokazuje cztery nagłówki i nie pokazuje X-Powered-By.' });
  }
  if (s.prodVulns > 0) {
    rows.push({ point: '6. npm audit', status: 'NIE ZALICZONE', proof: 'npm audit --omit=dev: ' + s.prodVulns + ' w zależnościach produkcyjnych. Popraw, uruchom testy, bez --force na ślepo.' });
  } else if (s.devVulns > 0) {
    rows.push({ point: '6. npm audit', status: 'ZALICZONE', proof: 'npm audit --omit=dev: found 0 vulnerabilities. ' + s.devVulns + ' w narzędziach deweloperskich: zapisz decyzję i czekaj na wydanie.' });
  } else {
    rows.push({ point: '6. npm audit', status: 'ZALICZONE', proof: 'npm audit: found 0 vulnerabilities.' });
  }
  return rows;
}

export function routeCode(s: Setup): string[] {
  const lines = ['export async function PATCH(request: Request, { params }: Ctx) {', '  const { id } = await params;'];
  if (s.sessionCheck) {
    lines.push('  const viewerId = await getCurrentUserId();');
    lines.push('  if (!viewerId) return Response.json({ error: "Zaloguj się." }, { status: 401 });');
  }
  if (s.ownerCheck) {
    lines.push('  const ownerId = await getPinOwner(id);');
    lines.push('  if (!ownerId) return Response.json({ error: "Nie ma takiego pinu." }, { status: 404 });');
    lines.push('  if (ownerId !== viewerId) return Response.json({ error: "Tylko autor edytuje pin." }, { status: 403 });');
  }
  lines.push(s.catchJson ? '  const body = await request.json().catch(() => null);' : '  const body = await request.json();');
  if (s.serverSchema) {
    lines.push('  const result = pinEditSchema.safeParse(body);');
    lines.push('  if (!result.success) return Response.json({ error: "Popraw pola." }, { status: 400 });');
    lines.push('  const pin = await updatePin(id, result.data);');
  } else {
    lines.push('  const pin = await updatePin(id, { title: body.title, tags: body.tags });');
  }
  lines.push(s.returnsOnSuccess ? '  return Response.json(pin);' : '  // brak return po zapisie');
  lines.push('}');
  return lines;
}

const STATUS_CLASS: Record<Status, string> = {
  ZALICZONE: 'text-emerald-400',
  'NIE ZALICZONE': 'text-rose-400',
};

function Toggle(props: { label: string; checked: boolean; onChange: (v: boolean) => void }) {
  return (
    <label className="flex items-center gap-2 text-sm">
      <input type="checkbox" checked={props.checked} onChange={(e) => props.onChange(e.target.checked)} />
      {props.label}
    </label>
  );
}

export default function App() {
  const [s, setS] = useState<Setup>(AGENT);
  const set = <K extends keyof Setup>(key: K, value: Setup[K]) => setS({ ...s, [key]: value });
  const rows = checklist(s);
  const failed = rows.filter((r) => r.status === 'NIE ZALICZONE').length;

  return (
    <div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
      <h1 className="text-xl font-bold">Lista kontrolna przed publikacją</h1>
      <p className="text-sm text-slate-300">Edycja pinu w Treasure Map. Przełączaj to, co napisał agent, i patrz, który punkt listy to łapie.</p>
      <div className="flex flex-wrap gap-2 text-sm">
        <button type="button" className="rounded bg-slate-800 px-2 py-1 hover:bg-slate-700" onClick={() => setS(AGENT)}>Wersja agenta</button>
        <button type="button" className="rounded bg-slate-800 px-2 py-1 hover:bg-slate-700" onClick={() => setS(OLD_LESSON)}>Wzór ze starej lekcji</button>
        <button type="button" className="rounded bg-slate-800 px-2 py-1 hover:bg-slate-700" onClick={() => setS(SAFE)}>Po poprawkach</button>
      </div>
      <div className="grid gap-2 md:grid-cols-2">
        <Toggle label="klucz w NEXT_PUBLIC_ w komponencie klienta" checked={s.keyInClient} onChange={(v) => set('keyInClient', v)} />
        <Toggle label="trasa sprawdza sesję (401)" checked={s.sessionCheck} onChange={(v) => set('sessionCheck', v)} />
        <Toggle label="trasa sprawdza właściciela (403)" checked={s.ownerCheck} onChange={(v) => set('ownerCheck', v)} />
        <Toggle label="schemat Zod na serwerze" checked={s.serverSchema} onChange={(v) => set('serverSchema', v)} />
        <Toggle label="request.json() z .catch" checked={s.catchJson} onChange={(v) => set('catchJson', v)} />
        <Toggle label="return po udanym zapisie" checked={s.returnsOnSuccess} onChange={(v) => set('returnsOnSuccess', v)} />
        <Toggle label="headers() w konfiguracji" checked={s.headers} onChange={(v) => set('headers', v)} />
        <Toggle label="konfiguracja jako next.config.js z module.exports" checked={s.configFile === 'js'} onChange={(v) => set('configFile', v ? 'js' : 'ts')} />
        <label className="flex items-center gap-2 text-sm">
          podatności w zależnościach produkcyjnych
          <input className="w-16 rounded bg-slate-900 p-1 font-mono" value={s.prodVulns} onChange={(e) => set('prodVulns', Math.max(0, Number(e.target.value) || 0))} />
        </label>
      </div>
      <div className="overflow-x-auto rounded bg-slate-900 p-2 font-mono text-xs">
        {routeCode(s).map((line, i) => (
          <div key={i} className="whitespace-pre">{line}</div>
        ))}
      </div>
      <table className="w-full text-left text-sm">
        <thead>
          <tr className="text-slate-400">
            <th className="p-1">curl</th>
            <th className="p-1">kod</th>
            <th className="p-1">pin w bazie</th>
          </tr>
        </thead>
        <tbody>
          {SCENARIOS.map((sc) => {
            const o = simulate(s, sc);
            return (
              <tr key={sc} className="border-t border-slate-800">
                <td className="p-1">{sc}</td>
                <td className="p-1 font-mono">{o.status}</td>
                <td className={'p-1 ' + (o.saved && (sc !== 'właściciel' || o.status !== 200) ? 'text-rose-400' : 'text-slate-300')}>{o.saved ? 'zmieniony' : 'bez zmian'}</td>
              </tr>
            );
          })}
        </tbody>
      </table>
      <ul className="space-y-2 text-sm">
        {rows.map((r) => (
          <li key={r.point} className="rounded border border-slate-800 p-2">
            <span className="font-semibold">{r.point}: </span>
            <span className={STATUS_CLASS[r.status]}>{r.status}</span>
            <p className="text-slate-300">{r.proof}</p>
          </li>
        ))}
      </ul>
      <p className="text-sm">{failed === 0 ? 'Lista czysta. Zostaje /security-review na gałęzi i Twoja decyzja przy każdym zgłoszeniu.' : 'Do poprawy: ' + failed + '. Jedno wąskie polecenie z testem na każdy punkt.'}</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. Claude wpisał klucz usługi tagów do zmiennej NEXT_PUBLIC_TAGS_API_KEY i czyta go w komponencie z "use client". Lint, tsc i build przechodzą. Co robisz?

  2. 2. Handler PATCH zapisuje pin w bloku try, a return ma tylko w catch dla złych danych. Co dostanie klient, który wyśle poprawne dane?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż linie handlera PATCH /api/pins/[id] tak, żeby obcy dostał odmowę, zanim serwer przeczyta dane z ciała żądania:

  1. PytanieQuiz: Klucz w NEXT_PUBLIC_
  2. PytanieQuiz: Handler bez return po zapisie
  3. Ułóż w kolejnościSortowanie: Zamki w trasie edycji
  4. PytanieQuiz: Nagłówki bezpieczeństwa w next.config.ts
  5. PytanieQuiz: Zgłoszenie z /security-review

Przydatne artykuły