Kurs vibe coding z Claude Code · Moduł 9: Klon Discorda

Serwery i kanały: mapa gildii z trybu planowania

8 min czytania
W tej lekcji11

Ahoj! Gildia Black Pearl urosła do stu piratów, a cała rozmowa toczy się w jednym czacie. Ogłoszenia kapitana giną między żartami, plany wypraw mieszają się z handlem, a nowy majtek nie wie, kto tu dowodzi. W tej lokacji budujesz Pirate's Cove, serwer społeczności załogi na wzór Discorda: osobne kanały na osobne sprawy, rangi i lista członków, z której od razu widać, kto jest na pokładzie.

Czego się nauczysz

  • zaplanować z Claude Code model danych serwera, zanim powstanie choć jeden komponent;
  • przeczytać w Cursorze typy jeden po drugim i sprawdzić, czy plan się zgadza;
  • zlecić pasek kanałów, listę serwerów i listę członków osobnymi poleceniami;
  • wyłapać w diffie sortowanie, które po cichu psuje dane, i zapisać zasadę w CLAUDE.md.

Discord a Slack

W Ship's Comms, klonie Slacka, budowałeś przestrzeń roboczą jednej załogi, w której rozmowy toczą się głównie na piśmie. Discord powstał dla społeczności i graczy: zamiast przestrzeni roboczej ma serwery, obok kanałów tekstowych stoją stale otwarte kanały głosowe, a rangi decydują, kto co może. Pirate's Cove idzie drogą Discorda.

Nowy port: projekt pirates-cove

Pirate's Cove to osobna aplikacja, więc zakładasz ją poleceniem z lekcji 1_2, zmieniając tylko nazwę. Zanim klikniesz Yes, porównaj komendę z tą:

npx create-next-app@latest pirates-cove --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npm

Dalej znana pętla: sesja w folderze pirates-cove, CLAUDE.md z importem @AGENTS.md, Vitest z poprawką @types/node z lekcji 4_1 i pierwszy commit. Nic z tego nie jest nowe, więc nie ma tu nic do zgadywania.

Problem: jeden czat na stu piratów

Serwer to mapa. Na górze stoi gildia, w niej kategorie, czyli grupy kanałów, a w kategoriach kanały: tekstowe do pisania, głosowe do rozmowy i kanał ogłoszeń, w którym pisze tylko dowództwo. Obok mapy stoją rangi i członkowie. Jeśli ten model będzie zły, każdy komponent zbudowany na nim odziedziczy błąd, dlatego zaczynasz od planu. Tryb planowania znasz z lekcji 2_1: /plan przed poleceniem sprawia, że Claude bada projekt i układa plan, ale żadnego pliku nie rusza.

Polecenie dla Claude Code:

/plan Budujemy Pirate's Cove, klon Discorda. Zaplanuj model danych
w types/server.ts: serwer z właścicielem, kategorie i kanały (tekstowe,
głosowe, ogłoszeń) z polem position, rangi z kolorem, pozycją, flagą
isHoisted i polem permissions jako liczba, członkowie ze statusem
online, idle, dnd albo offline. Dane testowe w lib/server-data.ts:
gildia Black Pearl i dwa mniejsze serwery. Zalogowany członek z jednej
funkcji w lib/session.ts. Nie pisz jeszcze komponentów. Pokaż typy,
pliki i kolejność kroków. Zadaj pytania, jeśli czegoś brakuje.

W planie sprawdź dwie rzeczy. Po pierwsze kategorie: w API Discorda kategoria to też kanał, typu GUILD_CATEGORY, który mieści do 50 kanałów, a kanał wskazuje swoją kategorię polem parent_id. W klonie wystarczy prostszy zapis: osobny typ kategorii i pole categoryId w kanale. Po drugie uprawnienia: na razie to jedna liczba w randze, a w lekcji 8_3 rozłożysz ją na bity. Gdy plan przejdzie przegląd, wybierz Yes, manually approve edits, żeby zatwierdzać każdą edycję.

Co napisał Claude: model danych

Otwórz w Cursorze types/server.ts i czytaj typ po typie. Na górze stoją unie, czyli zamknięte listy wartości, a pod nimi kanał:

export type ChannelType = "text" | "voice" | "announcement";
export type Status = "online" | "idle" | "dnd" | "offline";

export interface Channel {
  id: string;
  name: string; // "general", "narada-wojenna"
  type: ChannelType;
  categoryId: string | null;
  position: number;
  userLimit?: number; // tylko kanały głosowe
}

Literówka w rodzaju "vocie" nie przejdzie przez kompilator, a categoryId: null oznacza kanał bez kategorii, który stoi na samej górze paska. userLimit ma znak zapytania, czyli jest opcjonalne, bo limit osób ma sens tylko w kanale głosowym. Statusy pochodzą z dokumentacji Discorda: online, idle (zaraz wracam), dnd (nie przeszkadzać) i offline. Piąty, invisible, inni widzą jako offline, więc klon go pomija.

Ranga mówi, jak ktoś wygląda na liście i co wolno mu zrobić:

export interface Role {
  id: string;
  name: string;
  color: string; // "#e11d48"
  position: number; // wyższa liczba = wyższa ranga
  isHoisted: boolean; // osobna grupa na liście członków
  permissions: number; // bity uprawnień, szczegóły w lekcji 8_3
}

position ustawia hierarchię: Kapitan z pozycją 3 stoi nad Oficerem z pozycją 2. isHoisted wyciąga członków tej rangi do osobnej grupy na liście, zamiast mieszać ich z resztą. Pole permissions to na razie zwykła liczba i nic w tej lekcji jej nie czyta.

Na końcu pliku stoją Member i Server. Członek ma username, czyli unikalną nazwę w rodzaju anne, oraz displayName do wyświetlania. Czterocyfrowego tagu w stylu #1234 nie ma: Discord w 2023 roku zaczął usuwać te tagi na rzecz unikalnych nazw, a konto przeniesione na nowy system ma w polu discriminator samo "0". Serwer zbiera wszystko w jednym obiekcie i ma ownerId, bo właściciel będzie miał w lekcji 8_3 specjalne prawa.

Pasek kanałów: osobne polecenie

Każdy komponent zlecasz osobno: mały diff czyta się szybko, a pomyłkę w nim widać od razu.

Polecenie dla Claude Code:

Zrób components/ServerSidebar.tsx dla typów z @types/server.ts:
nazwa serwera, kategorie posortowane po position i zwijane kliknięciem,
w każdej kanały posortowane po position z ikoną typu, aktywny kanał
wyróżniony, na dole panel zalogowanego członka. Pokaż pasek na stronie
app/servers/[serverId]/[channelId]/page.tsx. Na koniec lint, typy i build.

Co napisał Claude: sortowanie

Otwórz components/ServerSidebar.tsx. Najpierw kolejność kategorii i kanałów:

const categories = [...server.categories].sort((a, b) => a.position - b.position);

function channelsOf(categoryId: string) {
  return server.channels
    .filter((c) => c.categoryId === categoryId)
    .sort((a, b) => a.position - b.position);
}

[...server.categories] robi płytką kopię tablicy i dopiero ją sortuje. W channelsOf kopii nie ma, i słusznie: filter zawsze zwraca nową tablicę, więc sort układa tablicę, którą przed chwilą utworzył ten sam kod. Nowsze przeglądarki mają też toSorted, które od razu zwraca posortowaną kopię.

Co napisał Claude: zwijane kategorie

Plik zaczyna się od "use client", bo pasek reaguje na kliknięcia i pamięta stan, a tego Server Component nie potrafi. Zwinięte kategorie żyją w stanie jako zbiór identyfikatorów:

const [collapsed, setCollapsed] = useState<Set<string>>(() => new Set());

function toggle(categoryId: string) {
  setCollapsed((prev) => {
    const next = new Set(prev);
    if (next.has(categoryId)) next.delete(categoryId);
    else next.add(categoryId);
    return next;
  });
}

toggle nie zmienia starego zbioru, tylko buduje nowy i oddaje go Reactowi, więc komponent narysuje się od nowa. Przycisk kategorii ma aria-expanded={!isCollapsed}, które mówi czytnikowi ekranu, czy lista jest rozwinięta, a lista kanałów renderuje się tylko wtedy, gdy kategorii nie ma w zbiorze. Ikona typu kanału (#, nuta albo wykrzyknik) ma obok siebie ukryty napis, na przykład "kanał głosowy", a panel na dole pokazuje kropkę statusu z takim samym ukrytym opisem.

Lista serwerów i lista członków

Dwa kolejne polecenia w tym samym stylu dały components/ServerList.tsx i components/MemberList.tsx. Lista serwerów nie ma "use client": nie ma stanu ani zdarzeń, a aktywny serwer przychodzi z adresu przez props. Każda ikona to Link z inicjałami gildii, title z pełną nazwą i paskiem po lewej przy aktywnym serwerze.

Lista członków grupuje załogę funkcją groupMembers z lib/members.ts. Wszystko zaczyna się od najwyższej rangi członka:

export function getHighestRole(member: Member, roles: Role[]): Role | null {
  const own = roles.filter((role) => member.roleIds.includes(role.id));
  own.sort((a, b) => b.position - a.position);
  return own[0] ?? null;
}

Funkcja bierze rangi członka, układa je malejąco po position i zwraca pierwszą albo null. groupMembers wrzuca każdego członka, który nie jest offline, do grupy jego najwyższej rangi z isHoisted, resztę do grupy "Dostępni", a wszystkich ze statusem offline na koniec, do "Niedostępni". U nas lista pokazała kolejno: KAPITAN - 1, OFICER - 1, DOSTĘPNI - 2 i NIEDOSTĘPNI - 1.

Przegląd kapitana

  1. Kopia przed sortowaniem. Typowy błąd agenta to server.categories.sort(...) bez [...]. MDN mówi wprost, że sort() układa tablicę w miejscu i zwraca tę samą tablicę, a dokumentacja Reacta: propsy są niezmienne, nigdy ich nie zmieniaj. W diffie szukasz więc każdego .sort( i .reverse( na danych z propsów. U nas taka wersja przeszła npm run lint i npx tsc --noEmit bez słowa, dlatego poproś też o test, który zapisuje kolejność kategorii, rysuje pasek i porównuje dane (wynik pod listą).
  2. Unie zamiast napisów. type i status mają być uniami, nie string.
  3. position naprawdę steruje. W danych testowych kategoria głosowa stoi przed tekstową, a position mówi odwrotnie. Na stronie pierwsza ma być KANAŁY TEKSTOWE, i u nas była.
  4. Dowód. Testy, npm run lint, npx tsc --noEmit i npm run build. Przed pierwszym buildem tsc nie zna PageProps<"/servers/[serverId]/[channelId]">; typy tras generuje npx next typegen.

Wynik testu z wersją bez kopii, czyli z server.categories.sort(...), wyglądał u nas tak:

FAIL  components/ServerSidebar.test.tsx > nie zmienia kolejności kategorii w danych serwera
AssertionError: expected [ 'tekstowe', 'glosowe' ] to deeply equal [ 'glosowe', 'tekstowe' ]

Z kopią test przechodzi, bez niej pada. Dane serwera zmieniły się od samego wyświetlenia, a w Server Component taka zmiana trafiłaby do danych wspólnych dla wszystkich żądań.

Następny krok: zasada w CLAUDE.md

Ten błąd wraca, bo sort wygląda niewinnie. Poproś Claude o jedną linię w CLAUDE.md:

- Dane z propsów i z lib/ są tylko do odczytu: sortuj kopię ([...lista].sort), nigdy listę w miejscu.

Według dokumentacji Claude Code CLAUDE.md ładuje się na początku każdej sesji, ale Claude traktuje go jak wskazówkę, a nie twardą regułę, a im konkretniejsza linia, tym pewniej jej słucha. Dlatego zostawiasz też test: linia zapobiega błędowi, test go łapie. Potem poproś o commit, na przykład "Model serwera, pasek kanałów, listy serwerów i członków".

W edytorze poniżej czeka gildia w miniaturze: zwijaj kategorie, przełączaj serwery i włącz błąd agenta, żeby zobaczyć, jak kolejność w danych zmienia się od samego rysowania.

Pamiętaj: kapitan rysuje mapę, zanim załoga zacznie kopać, a dobra mapa nie zmienia się od tego, że ktoś na nią spojrzał.

Kod do tej lekcji: App.jsx
// Pirate's Cove w miniaturze: serwery, zwijane kategorie i lista członków.
// W projekcie dane leżą w lib/server-data.ts, a komponenty w components/.
// Przełącznik "błąd agenta" sortuje kategorie w miejscu, jak server.categories.sort(...).
import { useState } from 'react';

const servers = [
  {
    id: 'black-pearl',
    name: 'Gildia Black Pearl',
    categories: [
      { id: 'glosowe', name: 'KANAŁY GŁOSOWE', position: 1 },
      { id: 'tekstowe', name: 'KANAŁY TEKSTOWE', position: 0 },
    ],
    channels: [
      { id: 'treasure-hunts', name: 'treasure-hunts', type: 'text', categoryId: 'tekstowe', position: 2 },
      { id: 'general', name: 'general', type: 'text', categoryId: 'tekstowe', position: 1 },
      { id: 'ogloszenia', name: 'ogloszenia', type: 'announcement', categoryId: 'tekstowe', position: 0 },
      { id: 'narada-wojenna', name: 'narada-wojenna', type: 'voice', categoryId: 'glosowe', position: 0 },
      { id: 'mesa', name: 'mesa', type: 'voice', categoryId: 'glosowe', position: 1 },
    ],
    roles: [
      { id: 'zaloga', name: 'Załoga', color: '#64748b', position: 1, isHoisted: false },
      { id: 'kapitan', name: 'Kapitan', color: '#e11d48', position: 3, isHoisted: true },
      { id: 'oficer', name: 'Oficer', color: '#2563eb', position: 2, isHoisted: true },
    ],
    members: [
      { id: 'redbeard', displayName: 'Kapitan Redbeard', roleIds: ['kapitan', 'zaloga'], status: 'online' },
      { id: 'anne', displayName: 'Anne Bonny', roleIds: ['oficer', 'zaloga'], status: 'online' },
      { id: 'jack', displayName: 'Jack Rackham', roleIds: ['zaloga'], status: 'idle' },
      { id: 'mary', displayName: 'Mary Read', roleIds: ['oficer', 'zaloga'], status: 'offline' },
      { id: 'blackbeard', displayName: 'Blackbeard', roleIds: ['zaloga'], status: 'dnd' },
    ],
  },
  {
    id: 'tortuga',
    name: 'Targ w Tortudze',
    categories: [{ id: 'handel', name: 'HANDEL', position: 0 }],
    channels: [{ id: 'ceny', name: 'ceny', type: 'text', categoryId: 'handel', position: 0 }],
    roles: [],
    members: [],
  },
  {
    id: 'kraken',
    name: 'Łowcy Krakena',
    categories: [],
    channels: [{ id: 'tropy', name: 'tropy', type: 'text', categoryId: null, position: 0 }],
    roles: [],
    members: [],
  },
];

const icons = { text: '#', voice: '♪', announcement: '!' };
const typeLabels = { text: 'kanał tekstowy', voice: 'kanał głosowy', announcement: 'kanał ogłoszeń' };
const dotColors = { online: 'bg-green-500', idle: 'bg-yellow-400', dnd: 'bg-red-500', offline: 'bg-gray-500' };
const statusLabels = { online: 'dostępny', idle: 'zaraz wracam', dnd: 'nie przeszkadzać', offline: 'niedostępny' };

function getHighestRole(member, roles) {
  const own = roles.filter((role) => member.roleIds.includes(role.id));
  own.sort((a, b) => b.position - a.position);
  return own[0] || null;
}

function groupMembers(members, roles) {
  const hoisted = roles.filter((role) => role.isHoisted);
  const byRole = [...hoisted]
    .sort((a, b) => b.position - a.position)
    .map((role) => ({ id: role.id, label: role.name, members: [] }));
  const online = { id: 'online', label: 'Dostępni', members: [] };
  const offline = { id: 'offline', label: 'Niedostępni', members: [] };
  for (const member of members) {
    const top = getHighestRole(member, hoisted);
    const group = member.status === 'offline' ? offline : byRole.find((g) => top && g.id === top.id) || online;
    group.members.push(member);
  }
  return [...byRole, online, offline].filter((g) => g.members.length > 0);
}

function initials(name) {
  return name.split(' ').map((word) => word[0]).join('').slice(0, 2).toUpperCase();
}

function StatusDot({ status }) {
  return (
    <>
      <span aria-hidden="true" className={'inline-block h-2.5 w-2.5 shrink-0 rounded-full ' + dotColors[status]} />
      <span className="sr-only">({statusLabels[status]})</span>
    </>
  );
}

export default function App() {
  const [serverId, setServerId] = useState('black-pearl');
  const [channelId, setChannelId] = useState('general');
  const [collapsed, setCollapsed] = useState(() => new Set());
  const [buggy, setBuggy] = useState(false);
  const server = servers.find((s) => s.id === serverId);

  const dataBefore = server.categories.map((c) => c.id).join(', ');
  const categories = buggy
    ? server.categories.sort((a, b) => a.position - b.position) // błąd: sortuje dane w miejscu
    : [...server.categories].sort((a, b) => a.position - b.position);
  const dataAfter = server.categories.map((c) => c.id).join(', ');

  function toggle(id) {
    setCollapsed((prev) => {
      const next = new Set(prev);
      if (next.has(id)) next.delete(id);
      else next.add(id);
      return next;
    });
  }

  function resetData() {
    servers[0].categories = [
      { id: 'glosowe', name: 'KANAŁY GŁOSOWE', position: 1 },
      { id: 'tekstowe', name: 'KANAŁY TEKSTOWE', position: 0 },
    ];
    setBuggy(false);
  }

  function renderChannel(channel) {
    const active = channel.id === channelId;
    return (
      <li key={channel.id}>
        <button
          onClick={() => setChannelId(channel.id)}
          aria-current={active ? 'page' : undefined}
          className={'flex w-full items-center gap-2 rounded px-2 py-1 text-left text-sm ' + (active ? 'bg-gray-700 text-white' : 'text-gray-300 hover:bg-gray-700')}
        >
          <span aria-hidden="true" className="w-4 text-center text-gray-400">{icons[channel.type]}</span>
          <span className="sr-only">{typeLabels[channel.type]}</span>
          {channel.name}
        </button>
      </li>
    );
  }

  const loose = server.channels.filter((c) => c.categoryId === null);

  return (
    <div className="min-h-screen bg-gray-700 text-gray-100">
      <div className="flex flex-wrap items-center gap-3 bg-gray-900 p-2 text-xs">
        <label className="flex items-center gap-1">
          <input type="checkbox" checked={buggy} onChange={(e) => setBuggy(e.target.checked)} />
          Błąd agenta: server.categories.sort(...) bez kopii
        </label>
        <span>Dane przed rysowaniem: {dataBefore}</span>
        <span>po rysowaniu: {dataAfter}</span>
        <button onClick={resetData} className="rounded bg-gray-700 px-2 py-1">Przywróć dane</button>
      </div>

      <div className="flex h-[520px]">
        <nav aria-label="Serwery" className="flex w-16 flex-col items-center gap-2 bg-gray-950 py-3">
          {servers.map((s) => (
            <button
              key={s.id}
              title={s.name}
              aria-label={s.name}
              aria-current={s.id === serverId ? 'page' : undefined}
              onClick={() => {
                setServerId(s.id);
                setChannelId(s.channels[0].id);
              }}
              className={'flex h-11 w-11 items-center justify-center font-bold ' + (s.id === serverId ? 'rounded-2xl bg-indigo-500' : 'rounded-full bg-gray-700 hover:rounded-2xl')}
            >
              {initials(s.name)}
            </button>
          ))}
        </nav>

        <nav aria-label="Kanały serwera" className="flex w-56 flex-col bg-gray-800">
          <h2 className="border-b border-gray-900 px-3 py-2 font-bold">{server.name}</h2>
          <div className="flex-1 overflow-y-auto p-2">
            <ul>{loose.map(renderChannel)}</ul>
            {categories.map((category) => {
              const isCollapsed = collapsed.has(category.id);
              const channels = server.channels
                .filter((c) => c.categoryId === category.id)
                .sort((a, b) => a.position - b.position);
              return (
                <section key={category.id} className="mt-2">
                  <button
                    onClick={() => toggle(category.id)}
                    aria-expanded={!isCollapsed}
                    className="flex w-full items-center gap-1 text-xs font-semibold text-gray-400 hover:text-gray-200"
                  >
                    <span aria-hidden="true">{isCollapsed ? '▸' : '▾'}</span>
                    {category.name}
                  </button>
                  {!isCollapsed && <ul className="mt-1">{channels.map(renderChannel)}</ul>}
                </section>
              );
            })}
          </div>
        </nav>

        <main className="flex-1 p-4 text-sm text-gray-300">
          Kanał: <strong>{channelId}</strong>. Zwiń kategorię, przełącz serwer, a potem włącz błąd agenta i przełącz kanał kilka razy.
        </main>

        <aside aria-label="Członkowie" className="w-48 overflow-y-auto bg-gray-800 p-3">
          {groupMembers(server.members, server.roles).map((group) => (
            <section key={group.id} className="mb-3">
              <h3 className="text-xs font-semibold uppercase text-gray-400">{group.label} - {group.members.length}</h3>
              <ul>
                {group.members.map((member) => {
                  const role = getHighestRole(member, server.roles);
                  return (
                    <li key={member.id} className={'flex items-center gap-2 text-sm ' + (member.status === 'offline' ? 'opacity-50' : '')}>
                      <StatusDot status={member.status} />
                      <span style={{ color: role ? role.color : undefined }}>{member.displayName}</span>
                    </li>
                  );
                })}
              </ul>
            </section>
          ))}
          {server.members.length === 0 && <p className="text-xs text-gray-400">Ten serwer nie ma jeszcze załogi.</p>}
        </aside>
      </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 zawiera obiekt Server w modelu danych Pirate's Cove?

  2. 2. Jak w types/server.ts zapisano typ kanału?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kroki pracy nad modelem danych Pirate's Cove w kolejności z lekcji:

  • Edytor kodu

    Discord server navigation

  • Klikanie w kolejności

    Klikaj, aby zbudować sortowanie kategorii bez zmiany danych z propsów: [...server.categories].sort((a, b) => a.position - b.position)

  • Edytor kodu

    Server switcher sidebar

  • Układanie w poziomie

    Ułóż linię, która trzyma zwinięte kategorie w stanie: const [collapsed, setCollapsed] = useState<Set<string>>(() => new Set());

  • Układanie w pionie

    Ułóż grupy listy członków (MemberList) od góry, gdy rangi Kapitan (position 3) i Oficer (position 2) mają isHoisted: true:

  • Układanie w poziomie

    Ułóż ostatnią linię funkcji getHighestRole: return own[0] ?? null;

  • Klikanie w kolejności

    Klikaj, aby zbudować atrybut przycisku kategorii, który mówi czytnikowi ekranu, czy lista jest rozwinięta:

  1. PytanieQuiz: Co zawiera serwer
  2. PytanieQuiz: Typ kanału
  3. PytanieQuiz: Status członka
  4. Ułóż w kolejnościSortowanie: Kolejność pracy nad modelem
  5. Zadanie z kodemPraktyka: Server sidebar
  6. PytanieQuiz: Kanał i kategoria
  7. PytanieQuiz: Pole isHoisted w Role
  8. Kliknij w kolejnościSortowanie: Sortowanie na kopii
  9. PytanieQuiz: Sortowanie danych z propsów
  10. Zadanie z kodemPraktyka: Server list
  11. Ułóż w kolejnościSortowanie: Stan zwiniętych kategorii
  12. PytanieQuiz: getHighestRole
  13. Ułóż w kolejnościSortowanie: Grupy na liście członków
  14. Ułóż w kolejnościSortowanie: Zwrot najwyższej rangi
  15. Kliknij w kolejnościSortowanie: Atrybut aria-expanded

Przydatne artykuły