Kurs vibe coding z Claude Code · Moduł 12: Klon Medium

Redakcja pod banderą: publikacje, uprawnienia i rekomendacje

7 min czytania
W tej lekcji9

Jeden autor to jedna łódź ale kronika rośnie we flotę. Kapitan chce publikacji, czyli wspólnej strony kilku autorów z własną załogą: właściciel nią zarządza, redaktor publikuje teksty, a pisarz je zgłasza. Pojawia się pytanie, które w kodzie łatwo przeoczyć: kto naprawdę może nacisnąć "Publikuj"? W tej lekcji budujesz stronę publikacji ze szkicu, pilnujesz uprawnień na serwerze i dokładasz rekomendacje, które da się komuś wyjaśnić.

Czego się nauczysz

  • dać Claude własny szkic jako część polecenia;
  • przeczytać zakładki opisane typem zamiast as any i listę ze stabilnymi kluczami;
  • sprawdzić uprawnienie na serwerze i udowodnić to komendą curl;
  • zamówić punktację rekomendacji, którą da się opisać jednym zdaniem.

Szkic jako polecenie

Układ strony trudno opisać słowami, więc pokażesz go rysunkiem, jak w lekcji 3_2. Narysuj na kartce własny szkic: nazwa publikacji i liczba obserwujących u góry, pod nimi trzy zakładki, niżej lista tytułów. Rysuj swój pomysł, nie przerysowuj ani nie wklejaj zrzutu cudzej platformy. Zdjęcie kartki zapisz w projekcie jako szkice/publikacja.jpg. Szkic mówi, jak strona wygląda, a tekst polecenia mówi, jak działa i kto co może.

Polecenie dla Claude Code:

/plan Najpierw opisz w kilku zdaniach szkic szkice/publikacja.jpg.
Potem zaplanuj stronę /publikacje/[slug] ułożoną jak na szkicu:
nazwa i liczba obserwujących, zakładki Najnowsze, Najlepsze i O nas,
lista artykułów. Typy w types/publication.ts, przykładowe dane
w lib/publications.ts. Role: owner, editor, writer. Publikują tylko
owner i editor: trasa POST /api/articles/[id]/publish sprawdza rolę
na serwerze i zwraca 403 pozostałym. Logowania nie ma: kim jesteś,
mówi ciasteczko demo-user w lib/session.ts. Bez as any.
Będzie gotowe, gdy curl jako writer dostanie 403, a jako editor 200,
a npm run lint, npx tsc --noEmit i npm run build przejdą.

Przeczytaj opis szkicu na początku planu. Jeśli Claude pomylił, gdzie stoją zakładki, popraw plan, zanim powstanie kod.

Co napisał Claude: role i jedno uprawnienie

Otwórz w Cursorze types/publication.ts. Rola to jedna z trzech nazw, a członek publikacji łączy osobę z rolą:

// types/publication.ts
export type Role = "owner" | "editor" | "writer";

export interface PublicationMember {
  userId: string;
  name: string;
  role: Role;
}

Publication w tym samym pliku ma jeszcze slug, nazwę, opis, liczbę obserwujących i listę members. Uprawnienie wynika z roli, więc w lib/publications.ts stoi jedna funkcja zamiast kilku pól prawda-fałsz rozsianych po danych:

// lib/publications.ts
// Publikuje właściciel i redaktor. Pisarz tylko zgłasza tekst.
export function canPublish(role: Role | undefined): boolean {
  return role === "owner" || role === "editor";
}

undefined to ktoś spoza załogi publikacji: funkcja zwraca dla niego false. Jedna funkcja to jedno miejsce do zmiany, gdy kapitan zdecyduje, że pisarze też mogą publikować.

Co napisał Claude: zakładki z typem

Otwórz components/PublicationTabs.tsx. Lista zakładek ma na końcu as const:

// components/PublicationTabs.tsx
const TABS = [
  { key: "latest", label: "Najnowsze" },
  { key: "top", label: "Najlepsze" },
  { key: "about", label: "O nas" },
] as const;

type TabKey = (typeof TABS)[number]["key"];

as const mówi TypeScriptowi, że key to dokładnie "latest", "top" albo "about", a nie dowolny napis. TabKey wyciąga te trzy nazwy z tablicy, więc nowa zakładka dopisana do TABS od razu trafia do typu. Kliknięcie to zwykłe onClick={() => setTab(t.key)}, bez rzutowania.

Typowa droga agenta wygląda inaczej. Typ zakładek zapisany osobno i tablica bez as const dały u nas błąd tsc: Argument of type 'string' is not assignable to parameter of type 'SetStateAction<TabKey>'. Najszybsza "poprawka" to setTab(t.key as any), która ucisza kompilator. npm run lint jej nie przepuścił: Unexpected any. Specify a different type. Gdy Claude proponuje as any, poproś o typ, który pasuje, jak w lekcji 1_4.

Co napisał Claude: klucz z danych

Lista artykułów sortuje kopię danych według zakładki, a każdy element dostaje klucz z identyfikatora artykułu:

// components/PublicationTabs.tsx
{sorted.map((article) => (
  <li key={article.id}>

sorted to [...articles].sort(...): po dacie dla Najnowszych, po oklaskach dla Najlepszych. Dokumentacja Reacta ostrzega przed indeksem jako kluczem właśnie wtedy, gdy kolejność się zmienia: przy key={i} React po przełączeniu zakładki dopasuje stan i elementy po pozycji, a nie po artykule. Ostrzega też przed key={Math.random()}, który odtwarza całą listę przy każdym rysowaniu.

Zamek na serwerze

Przycisk "Publikuj" pokazuje się tylko członkom z canPublish. To wygoda, nie zabezpieczenie: żądanie można wysłać bez strony. Typowy błąd agenta to sprawdzenie roli tylko w komponencie i uznanie sprawy za zamkniętą. Dlatego decyduje trasa:

// app/api/articles/[id]/publish/route.ts
export async function POST(_request: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const article = getArticle(id);
  if (!article) {
    return Response.json({ error: "Nie ma takiego artykułu" }, { status: 404 });
  }
  const role = roleIn(article.publication, await getCurrentUserId());
  if (!canPublish(role)) {
    return Response.json({ error: "Publikują tylko właściciel i redaktorzy" }, { status: 403 });
  }
  publishArticle(id);
  return Response.json({ id, status: "published" });
}

roleIn szuka roli osoby w publikacji artykułu, a getCurrentUserId z lib/session.ts czyta ciasteczko demo-user. To udawane logowanie, potrzebne tylko do nauki: w prawdziwej aplikacji identyfikator daje sesja z lekcji 8_5. Sprawdź zamek z terminala, jako pisarz i jako redaktor:

curl -s -X POST -b "demo-user=u-jack" localhost:3000/api/articles/a4/publish -w ' %{http_code}\n'
curl -s -X POST -b "demo-user=u-bill" localhost:3000/api/articles/a4/publish -w ' %{http_code}\n'

U nas pisarz Calico Jack dostał {"error":"Publikują tylko właściciel i redaktorzy"} 403, a redaktor Billy Bones {"id":"a4","status":"published"} 200. W przeglądarce, po ustawieniu ciasteczka redaktora w konsoli narzędzi deweloperskich, kliknięcie "Publikuj" przeniosło tekst na listę Najnowszych.

Rekomendacje, które da się wyjaśnić

Strona główna ma pokazać czytelnikowi teksty dla niego. Polecenie "dodaj algorytm rekomendacji" potrafi skończyć się pustym komentarzem w rodzaju "tu algorytm" albo wzorem z wagami, których nikt nie umie uzasadnić. Lepiej zamówić zasadę, którą sam sprawdzisz na palcach: "W lib/recommend.ts dodaj punktację: 3 za każdy obserwowany temat, 2 za obserwowanego autora, 1 za każde pełne 100 oklasków, ale za oklaski najwyżej 3. Wypisz zasadę w komentarzu nad funkcją i dodaj test z punktami przykładowych artykułów."

// lib/recommend.ts
export function score(article: Article, reader: Reader): number {
  const topics = article.topics.filter((t) => reader.followedTopics.includes(t)).length;
  const author = reader.followedAuthors.includes(article.authorId) ? 1 : 0;
  const claps = Math.min(3, Math.floor(article.claps / 100));
  return 3 * topics + 2 * author + claps;
}

Reader to listy tematów i autorów, które czytelnik obserwuje. recommend sortuje kopię artykułów według punktów, przy remisie nowszy wygrywa. Limit za oklaski ma powód: przy punkcie za każde 10 oklasków i bez górnej granicy "Mapa skarbów" z 340 oklaskami dostałaby 34 punkty i przykryła każdy obserwowany temat. U nas test policzył dla czytelnika, który obserwuje żeglugę i kucharkę Mary, punkty { a1: 4, a2: 3, a3: 5, a4: 3 }.

Przegląd kapitana

  1. Zamek. Uprawnienie sprawdza trasa, a nie tylko ukryty przycisk. Komendy curl jako pisarz i redaktor to Twój dowód.
  2. Typy zamiast rzutowania. Wyszukaj w projekcie (Cmd+Shift+F) as any: zero trafień, a npm run lint kończy się bez błędów.
  3. Klucze. Każde key= w listach to identyfikator z danych, nie indeks i nie Math.random().
  4. Punktacja. Komentarz nad score opisuje zasadę jednym zdaniem, a test sprawdza konkretne liczby.
  5. Pamięć serwera. publishArticle dopisuje identyfikator do zbioru na globalThis, jak oklaski w lekcji 11_2. Pierwsza wersja zmieniała pole status w danych modułu: u nas trasa odpowiedziała 200, a strona po odświeżeniu dalej pokazywała tekst jako zgłoszony, bo trasa zmieniła swoją kopię danych.

Następny krok

Poproś o commit "Publikacje, uprawnienia i rekomendacje". Potem strona główna. Zmiana dotknie co najmniej trzech plików, więc znowu zacznij od planu:

/plan Na stronie głównej dodaj zakładki Dla Ciebie i Obserwowane.
Dla Ciebie używa recommend z @lib/recommend.ts, Obserwowane pokazuje
teksty obserwowanych autorów od najnowszych. Obok listy panel
z tematami. Typ zakładek jak w PublicationTabs, bez as any.

Plan przeczytaj tak jak dziś: czy zakładki mają typ, czy listy mają klucze z danych i czy sortowanie idzie na kopii. W edytorze poniżej czeka strona publikacji w miniaturze: przełącz rolę, spróbuj opublikować tekst przy włączonym błędzie agenta "zamek tylko w przycisku" i sprawdź punkty rekomendacji.

Zapamiętaj: flota płynie bezpiecznie, gdy klucze do sterowni mają tylko kapitan i oficerowie, a zamek wisi na drzwiach sterowni, a nie na mapie, którą każdy może przerysować.

Kod do tej lekcji: App.jsx
// Publikacja w miniaturze: role, zakładki, zamek na udawanym serwerze i punktacja rekomendacji
import { useState } from 'react';

const MEMBERS = [
  { userId: 'u-anne', name: 'Anne Bonny', role: 'owner' },
  { userId: 'u-bill', name: 'Billy Bones', role: 'editor' },
  { userId: 'u-jack', name: 'Calico Jack', role: 'writer' },
];
const ROLE_LABELS = { owner: 'właściciel', editor: 'redaktor', writer: 'pisarz' };

const TABS = [
  { key: 'latest', label: 'Najnowsze' },
  { key: 'top', label: 'Najlepsze' },
  { key: 'about', label: 'O nas' },
];

const ARTICLES = [
  { id: 'a1', publication: 'kroniki', title: 'Jak przetrwać sztorm na Atlantyku', authorId: 'u-anne', topics: ['żegluga', 'pogoda'], claps: 120, publishedAt: '2026-11-10' },
  { id: 'a2', publication: 'kroniki', title: 'Mapa skarbów, której nie było', authorId: 'u-jack', topics: ['skarby'], claps: 340, publishedAt: '2026-11-12' },
  { id: 'a3', publication: 'kambuz', title: 'Kucharz okrętowy radzi: suchary na sześć tygodni', authorId: 'u-mary', topics: ['kuchnia', 'żegluga'], claps: 45, publishedAt: '2026-11-14' },
  { id: 'a4', publication: 'kroniki', title: 'Wachta nocna bez kawy', authorId: 'u-jack', topics: ['żegluga'], claps: 0, publishedAt: '2026-11-15' },
];
const AUTHORS = { 'u-anne': 'Anne Bonny', 'u-jack': 'Calico Jack', 'u-mary': 'Mary Read' };
const TOPICS = ['żegluga', 'pogoda', 'skarby', 'kuchnia'];

// Publikuje właściciel i redaktor. Pisarz tylko zgłasza tekst.
function canPublish(role) {
  return role === 'owner' || role === 'editor';
}

function roleOf(userId) {
  const member = MEMBERS.find((m) => m.userId === userId);
  return member ? member.role : undefined;
}

// Udawany serwer: trasa POST /api/articles/a4/publish
function publishOnServer(userId, lockOnlyInButton) {
  if (!lockOnlyInButton && !canPublish(roleOf(userId))) return 403;
  return 200;
}

// 3 za obserwowany temat, 2 za obserwowanego autora, 1 za każde pełne 100 oklasków (najwyżej 3)
function score(article, reader, noCap) {
  const topics = article.topics.filter((t) => reader.topics.includes(t)).length;
  const author = reader.authors.includes(article.authorId) ? 1 : 0;
  const clapPoints = noCap ? Math.floor(article.claps / 10) : Math.min(3, Math.floor(article.claps / 100));
  return 3 * topics + 2 * author + clapPoints;
}

export default function App() {
  const [userId, setUserId] = useState('u-jack');
  const [tab, setTab] = useState('latest');
  const [publishedIds, setPublishedIds] = useState(['a1', 'a2', 'a3']);
  const [lockOnlyInButton, setLockOnlyInButton] = useState(false);
  const [log, setLog] = useState('');
  const [reader, setReader] = useState({ topics: ['żegluga'], authors: ['u-mary'] });
  const [noCap, setNoCap] = useState(false);

  const role = roleOf(userId);
  const published = ARTICLES.filter((a) => publishedIds.includes(a.id));
  const submitted = ARTICLES.filter((a) => a.id === 'a4' && !publishedIds.includes(a.id));
  const mine = published.filter((a) => a.publication === 'kroniki');
  const sorted =
    tab === 'top'
      ? [...mine].sort((a, b) => b.claps - a.claps)
      : [...mine].sort((a, b) => b.publishedAt.localeCompare(a.publishedAt));
  const recommended = [...published]
    .map((a) => ({ article: a, points: score(a, reader, noCap) }))
    .sort((a, b) => b.points - a.points || b.article.publishedAt.localeCompare(a.article.publishedAt));

  function publish(source) {
    const status = publishOnServer(userId, lockOnlyInButton);
    setLog(source + ': serwer odpowiedział ' + status);
    if (status === 200) setPublishedIds((ids) => (ids.includes('a4') ? ids : [...ids, 'a4']));
  }

  function toggle(list, value) {
    return list.includes(value) ? list.filter((v) => v !== value) : [...list, value];
  }

  return (
    <div className="min-h-screen bg-gray-50 p-4 text-gray-900">
      <div className="mx-auto max-w-xl space-y-4 rounded-xl bg-white p-4 shadow-sm">
        <label className="block text-sm">
          Zalogowany (udawane ciasteczko demo-user):{' '}
          <select value={userId} onChange={(e) => setUserId(e.target.value)} className="rounded border border-gray-300">
            {MEMBERS.map((m) => (
              <option key={m.userId} value={m.userId}>{m.name} ({ROLE_LABELS[m.role]})</option>
            ))}
            <option value="u-guest">Gość spoza załogi</option>
          </select>
        </label>
        <header>
          <h1 className="text-2xl font-bold">Kroniki Przylądka</h1>
          <p className="text-gray-600">{(12480).toLocaleString('pl-PL')} obserwujących</p>
        </header>
        <div role="tablist" className="flex gap-4 border-b border-gray-200">
          {TABS.map((t) => (
            <button
              key={t.key}
              type="button"
              role="tab"
              aria-selected={tab === t.key}
              onClick={() => setTab(t.key)}
              className={tab === t.key ? 'border-b-2 border-gray-900 pb-2 font-semibold' : 'pb-2 text-gray-500'}
            >
              {t.label}
            </button>
          ))}
        </div>
        {tab === 'about' ? (
          <ul>
            {MEMBERS.map((m) => (
              <li key={m.userId}>{m.name}: {ROLE_LABELS[m.role]}</li>
            ))}
          </ul>
        ) : (
          <ul className="space-y-2">
            {sorted.map((article) => (
              <li key={article.id}>
                <p className="font-semibold">{article.title}</p>
                <p className="text-sm text-gray-500">{article.claps} oklasków · {article.publishedAt}</p>
              </li>
            ))}
          </ul>
        )}
        {submitted.length > 0 && canPublish(role) && (
          <div className="rounded bg-amber-50 p-2 text-sm">
            Zgłoszone: {submitted[0].title}{' '}
            <button type="button" onClick={() => publish('Przycisk')} className="rounded bg-gray-900 px-2 py-1 text-white">
              Publikuj
            </button>
          </div>
        )}
      </div>

      <div className="mx-auto mt-3 max-w-xl space-y-2 rounded-xl bg-gray-900 p-4 text-sm text-white">
        <button type="button" onClick={() => publish('Żądanie z pominięciem przycisku')} className="rounded bg-gray-700 px-3 py-1">
          Wyślij POST /api/articles/a4/publish (jak curl)
        </button>
        {log && <p className="text-amber-300">{log}</p>}
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={lockOnlyInButton} onChange={(e) => setLockOnlyInButton(e.target.checked)} />
          Błąd agenta: zamek tylko w przycisku
        </label>
      </div>

      <div className="mx-auto mt-3 max-w-xl space-y-2 rounded-xl bg-white p-4 text-sm shadow-sm">
        <p className="font-semibold">Dla Ciebie: punkty rekomendacji</p>
        <div className="flex flex-wrap gap-3">
          {TOPICS.map((t) => (
            <label key={t} className="flex items-center gap-1">
              <input type="checkbox" checked={reader.topics.includes(t)} onChange={() => setReader((r) => ({ ...r, topics: toggle(r.topics, t) }))} />
              {t}
            </label>
          ))}
          <label className="flex items-center gap-1">
            <input type="checkbox" checked={reader.authors.includes('u-mary')} onChange={() => setReader((r) => ({ ...r, authors: toggle(r.authors, 'u-mary') }))} />
            obserwuję Mary Read
          </label>
        </div>
        <ol className="list-decimal pl-5">
          {recommended.map(({ article, points }) => (
            <li key={article.id}>
              {article.title} ({AUTHORS[article.authorId]}): <strong>{points} pkt</strong>
            </li>
          ))}
        </ol>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={noCap} onChange={(e) => setNoCap(e.target.checked)} />
          Bez limitu: 1 punkt za każde 10 oklasków
        </label>
      </div>
    </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. Co dajesz Claude jako szkic strony publikacji?

  2. 2. Dlaczego polecenie każe Claude najpierw opisać szkic w kilku zdaniach, a dopiero potem planować?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj drogę tekstu pisarza do zakładki Najnowsze:

  • Edytor kodu

    Publication display

  • Klikanie w kolejności

    Kliknij elementy, aby zbudować punkty za oklaski z górną granicą 3:

  • Edytor kodu

    Feed interface

  • Układanie w pionie

    Uporządkuj linie definicji zakładek, z których TypeScript wyciąga typ TabKey:

  • Układanie w poziomie

    Ułóż w jednej linii obsługę kliknięcia zakładki z typem TabKey:

  • Układanie w pionie

    Uporządkuj role w publikacji od najszerszych do najwęższych uprawnień:

  • Układanie w poziomie

    Ułóż w jednej linii odczyt roli osoby w trasie publikacji:

  • Klikanie w kolejności

    Kliknij elementy, aby zbudować listę Najlepszych bez zmiany tablicy z propsów:

  • Układanie w pionie

    Uporządkuj linie trasy publikacji od odczytu parametrów do zapisu:

  • Układanie w poziomie

    Ułóż w jednej linii nagłówek trasy POST z parametrami jako obietnicą:

  1. PytanieSzkic strony publikacji
  2. PytanieOpis szkicu przed planem
  3. Ułóż w kolejnościDroga tekstu do publikacji
  4. Zadanie z kodemPraktyka: Publication page
  5. PytaniePunktacja do wyjaśnienia
  6. PytaniePunkty jednego artykułu
  7. Kliknij w kolejnościPunkty za oklaski z limitem
  8. Zadanie z kodemPraktyka: Home feed
  9. PytanieKto publikuje w publikacji
  10. PytanieZamek tylko w przycisku
  11. Ułóż w kolejnościZakładki z typem
  12. Ułóż w kolejnościKliknięcie zakładki bez rzutowania
  13. PytanieBłąd typu zakładki i as any
  14. PytanieKlucz elementu listy
  15. Ułóż w kolejnościRole od najszerszych uprawnień
  16. Ułóż w kolejnościRola z ciasteczka na serwerze
  17. Kliknij w kolejnościNajlepsze z kopii listy
  18. PytanieLimit punktów za oklaski
  19. Ułóż w kolejnościKolejność w trasie publikacji
  20. Ułóż w kolejnościNagłówek trasy POST
  21. PytanieTrasa 200, strona bez zmian

Przydatne artykuły