Kurs vibe coding z Claude Code · Moduł 8: Klon Slacka

Dziennik pokładowy: wiadomości, reakcje i wątki

8 min czytania
W tej lekcji10

Kanał bez wiadomości to pusta kajuta. W Slacku rozmowa to coś więcej niż tekst: pod wiadomością ludzie zostawiają reakcje zamiast pisać "zgoda", autor poprawia literówkę, a dłuższa dyskusja schodzi do wątku, czyli osobnego panelu z odpowiedziami pod jedną wiadomością. Dzięki temu kanał zostaje czytelny, a kto chce szczegółów, otwiera panel z boku.

Problem: kto może zmienić wpis w dzienniku

Wiadomość może edytować i usunąć tylko jej autor. Przeglądarka ukryje przyciski przy cudzych wiadomościach, ale dokumentacja Next.js ostrzega, że Server Actions da się wywołać bezpośrednim żądaniem POST, z pominięciem interfejsu. Decyzja należy więc do serwera. Druga pułapka to liczby: licznik reakcji i licznik odpowiedzi łatwo zapisać obok danych, a potem zapomnieć je poprawić.

Polecenie dla Claude Code:

/plan Dodaj do Ship's Comms wiadomości. Typ Message w types/chat.ts:
autor, tekst, data ISO, editedAt, parentId dla odpowiedzi w wątku
i reakcje (krótka nazwa jak "+1" plus lista członków). Liczników nie
zapisuj, licz je z danych. Dane w data/messages.json przez lib/store.ts.
Najpierw testy czystej funkcji toggleReaction w lib/reactions.ts:
nowa reakcja, drugi członek, zdjęcie własnej, pusta reakcja znika,
wejście bez zmian. Potem Server Actions: wysłanie, reakcja, edycja
i usunięcie; autor zawsze z getCurrentMember(), edycja i usunięcie
tylko własnych. Komponenty: lista wiadomości, MessageItem z akcjami
po najechaniu (dostępnymi też z klawiatury i na dotyku), MessageInput
(Enter wysyła, Shift+Enter łamie linię) i panel wątku pod adresem
?thread=<id>. Na koniec testy, lint, typy i build.

O formatowaniu nie piszesz ani słowa: hook z poprzedniej lekcji uporządkuje każdy plik, który Claude zmieni.

Co napisał Claude: wiadomość w typach

Otwórz w Cursorze types/chat.ts. Pod modelem kanałów przybyły dwa typy:

export interface Reaction {
  name: string; // krótka nazwa jak w Slacku: "+1", "eyes", "tada"
  memberIds: string[];
}

export interface Message {
  id: string;
  channelId: string;
  authorId: string;
  text: string;
  createdAt: string; // tekst ISO
  editedAt?: string;
  parentId?: string; // odpowiedź w wątku: id wiadomości, pod którą wisi
  reactions: Reaction[];
}

Wiadomość wskazuje kanał i autora identyfikatorami. Odpowiedź w wątku to zwykła wiadomość z polem parentId, więc panel wątku to po prostu filtr listy. Pól count i replyCount nie ma: liczbę reakcji daje memberIds.length, a liczbę odpowiedzi policzenie wiadomości z danym parentId. Liczba, której nie zapisujesz, nie może rozjechać się z danymi. Reakcje to krótkie nazwy w dwukropkach, :+1:, takie, jakie wpisuje się w Slacku; obrazki dołożysz później jako warstwę wyglądu.

Gdzie leżą wiadomości i jak liczy się czas

Wiadomości trafiają do pliku data/messages.json przez lib/store.ts, tak jak profile w Crew Connections. Plik zaczyna się od import "server-only", więc przypadkowy import w komponencie przeglądarki zakończy build czytelnym błędem, a katalog data Claude dopisał do .gitignore. Lista w components/MessageList.tsx pokazuje tylko wiadomości bez parentId, a przy każdej liczy odpowiedzi filtrem po całej liście kanału. Pusty kanał dostaje zdanie "Na tym kanale jeszcze cisza" zamiast białej plamy. Godzinę wiadomości formatuje lib/format.ts:

const timeFormat = new Intl.DateTimeFormat("pl-PL", {
  day: "numeric",
  month: "short",
  hour: "2-digit",
  minute: "2-digit",
  timeZone: "Europe/Warsaw",
});

Z tekstu ISO powstaje napis w rodzaju "14 lis, 09:00". Strefa czasowa jest podana wprost, bo serwer na hostingu często liczy czas w innej strefie niż Twój komputer. Formatowanie dzieje się na serwerze, a do komponentu przeglądarki trafia gotowy napis, więc godzina nie zależy od tego, gdzie kod akurat działa. Data edycji ląduje w editedAt, a przy takiej wiadomości stoi dopisek "(edytowano)".

Najpierw test: przełącznik reakcji

Otwórz lib/reactions.test.ts. Nazwy przypadków to najszybszy sposób, żeby ocenić, czy Claude zrozumiał zasady:

it("drugi klik zdejmuje własną reakcję, a pustą usuwa z listy", () => {
  const before: Reaction[] = [{ name: "+1", memberIds: ["u1"] }];
  expect(toggleReaction(before, "+1", "u1")).toEqual([]);
});

Obok stoją jeszcze trzy przypadki: nowa reakcja, drugi członek załogi i "nie zmienia tablicy wejściowej". Ostatni pilnuje, żeby funkcja zwracała nową listę, a nie przestawiała starej, bo React zauważa zmianę po nowym obiekcie. Sama funkcja w lib/reactions.ts:

export function toggleReaction(
  reactions: Reaction[],
  name: string,
  memberId: string,
): Reaction[] {
  const current = reactions.find((reaction) => reaction.name === name);
  if (!current) {
    return [...reactions, { name, memberIds: [memberId] }];
  }
  const memberIds = current.memberIds.includes(memberId)
    ? current.memberIds.filter((id) => id !== memberId)
    : [...current.memberIds, memberId];
  return reactions
    .map((reaction) => (reaction === current ? { name, memberIds } : reaction))
    .filter((reaction) => reaction.memberIds.length > 0);
}

Nowa reakcja startuje z jednym członkiem, a kliknięcie istniejącej dopisuje Cię albo zdejmuje z listy. Ostatni filter usuwa reakcję, przy której nikt nie został, więc pod wiadomością nie zawiśnie :+1: 0.

Serwer pilnuje autora

Otwórz app/c/[channel]/actions.ts. Każda akcja zaczyna od zalogowanego członka załogi, nigdy od pola formularza:

export async function deleteMessage(messageId: string) {
  const me = await getCurrentMember();
  const messages = await readMessages();
  const message = messages.find((m) => m.id === messageId);
  if (!message) return;
  if (message.authorId !== me.id) {
    throw new Error("Możesz usunąć tylko własną wiadomość.");
  }
  await writeMessages(
    messages.filter((m) => m.id !== messageId && m.parentId !== messageId),
  );
  revalidatePath("/c/[channel]", "page");
}

editMessage ma to samo sprawdzenie, a reactToMessage odrzuca nazwę spoza listy REACTIONS, więc reakcja z pustą nazwą nie powstanie. Usunięcie wiadomości zabiera też odpowiedzi z jej wątku. revalidatePath dostaje wzór trasy i typ "page", bo dokumentacja Next.js wymaga typu, gdy ścieżka ma segment dynamiczny; tak odświeżają się wszystkie strony kanałów.

Akcje po najechaniu, z klawiatury i na dotyku

Otwórz components/MessageItem.tsx. Wiadomość ma od góry nagłówek z autorem i godziną, treść, reakcje i link z liczbą odpowiedzi. W prawym górnym rogu leży pasek akcji (trzy reakcje, Odpowiedz, a przy własnej wiadomości Edytuj i Usuń). Jest zawsze w kodzie strony, a o tym, czy go widać, decydują klasy:

<div className="absolute right-4 top-1 flex gap-1 rounded-md border border-gray-200 bg-white p-1 text-xs opacity-0 shadow-sm group-hover:opacity-100 group-focus-within:opacity-100 pointer-coarse:opacity-100">

group-hover pokazuje pasek, gdy kursor jest nad wiadomością, a group-focus-within, gdy przycisk w środku dostanie fokus klawiszem Tab. pointer-coarse to wariant Tailwinda dla mało precyzyjnego wskaźnika, czyli palca na ekranie dotykowym: tam pasek widać zawsze, bo hover: w Tailwind 4 działa tylko na urządzeniach z kursorem. Stara wersja ze zdarzeniem onMouseEnter w ogóle nie pokazywała akcji na telefonie. Tryb edycji trzyma w komponencie stan editing, a zapis woła editMessage. Reakcja, którą już dałeś, ma aria-pressed="true": czytnik ekranu powie, że przycisk jest wciśnięty, a klasy aria-pressed:border-blue-600 i aria-pressed:bg-blue-50 podświetlają go na niebiesko.

Pole wiadomości: Enter i Shift+Enter

Otwórz components/MessageInput.tsx. Formularz wysyła tekst przez Server Action, a skrót klawiszowy obsługuje mała funkcja:

function handleKeyDown(event: React.KeyboardEvent<HTMLTextAreaElement>) {
  if (
    event.key === "Enter" &&
    !event.shiftKey &&
    !event.nativeEvent.isComposing
  ) {
    event.preventDefault();
    event.currentTarget.form?.requestSubmit();
  }
}

Sam Enter blokuje nową linię i wysyła formularz przez requestSubmit(), czyli tak, jakby ktoś kliknął "Wyślij". Shift+Enter nie spełnia warunku, więc pole dostaje nową linię. isComposing chroni osoby piszące metodą wprowadzania znaków, w której Enter zatwierdza znak, a nie wiadomość. Po wysłaniu pole się czyści, a przy błędzie, na przykład tekście z samych spacji, zostaje z treścią i komunikatem pod spodem. Nad polem stoi <label> z klasą sr-only, bo sam placeholder znika po pierwszej literze i nie zastąpi opisu dla czytnika ekranu.

Wątek pod adresem

Link "Odpowiedz" prowadzi pod adres w rodzaju /c/general?thread=m1. Strona kanału czyta searchParams, znajduje wiadomość nadrzędną i przekazuje do components/ThreadPanel.tsx jej odpowiedzi. Na dole panelu stoi to samo pole co w kanale:

<MessageInput
  key={parent.id}
  channelId={channel.id}
  parentId={parent.id}
  placeholder="Odpowiedz w wątku"
/>

Wątek w adresie można wysłać komuś z załogi albo otworzyć w nowej karcie, a "Zamknij" to zwykły link do kanału. key={parent.id} ma znaczenie: przejście do innego wątku zmienia tylko parametr adresu, więc React zostawia komponenty na miejscu razem z ich stanem. Sprawdziliśmy to: bez klucza szkic odpowiedzi z jednego wątku zostawał w polu po otwarciu drugiego. Imię autora odpowiedzi panel bierze z authorName(reply.authorId), bo wiadomość zna tylko identyfikator autora.

Przegląd kapitana

  1. Cudza wiadomość. Poprosiliśmy Claude o próbę: wysłał formularz usuwania z identyfikatorem wiadomości Anne. Serwer odpowiedział błędem, w terminalu serwera pojawiło się "Możesz usunąć tylko własną wiadomość.", a wiadomość została. Typowy błąd agenta: sprawdzenie tylko w JSX (isOwn && <button>), a akcja usuwa wszystko, o co ktoś poprosi.
  2. Liczniki. Szukaj w diffie pól count albo replyCount. Jeśli Claude je dodał, poproś o liczenie z danych.
  3. Klawiatura. Przejdź Tabem przez wiadomość: pasek akcji musi się pokazać, a Enter na "Usuń" działać jak kliknięcie.
  4. Dowód. Testy, lint, typy i build. Na koniec npx prettier --check . melduje "All matched files use Prettier code style!", choć w poleceniu nie było słowa o formatowaniu. To praca hooka.

Następny krok

Gdy przegląd przejdzie, poproś o commit, na przykład "Wiadomości, reakcje i wątki". Potem mały krok z testem:

Dopisz do lib/reactions.test.ts przypadek: ten sam członek reaguje
:+1: i :eyes:, obie reakcje zostają. Pokaż wynik testów. Potem dodaj
potwierdzenie przed usunięciem wiadomości.

W edytorze poniżej czeka kanał w miniaturze: reakcje z tym samym przełącznikiem, edycja tylko własnych wiadomości i wątek. Wypróbuj Enter i Shift+Enter, a potem spróbuj usunąć cudzą wiadomość.

Pamiętaj: wpis w dzienniku pokładowym poprawia tylko ten, kto go zrobił, a pilnuje tego kapitan portu, czyli serwer, a nie sam dziennik.

Kod do tej lekcji: App.jsx
// Kanał #general w miniaturze: reakcje, edycja, usuwanie i wątek.
// W projekcie zasady pilnują Server Actions w app/c/[channel]/actions.ts;
// tu ten sam zestaw zasad sprawdzają funkcje "serwera" poniżej.
import { useState } from 'react';

const ME = 'u1';
const REACTIONS = ['+1', 'eyes', 'tada'];
const names = { u1: 'Kapitan Redbeard', u2: 'Anne Bonny', u3: 'Łukasz Sternik' };

const initialMessages = [
  { id: 'm1', authorId: 'u1', text: 'Ahoj, załogo! Jutro o świcie podnosimy kotwicę.', time: '09:00', reactions: [{ name: '+1', memberIds: ['u2', 'u3'] }] },
  { id: 'm2', authorId: 'u2', text: 'Beczki z wodą są już na pokładzie.', time: '09:05', reactions: [] },
  { id: 'm3', authorId: 'u3', text: 'Sprawdzę liny przed wypłynięciem.', time: '09:10', parentId: 'm1', reactions: [] },
];

// Ta sama czysta funkcja co w lib/reactions.ts.
function toggleReaction(reactions, name, memberId) {
  const current = reactions.find((reaction) => reaction.name === name);
  if (!current) return [...reactions, { name, memberIds: [memberId] }];
  const memberIds = current.memberIds.includes(memberId)
    ? current.memberIds.filter((id) => id !== memberId)
    : [...current.memberIds, memberId];
  return reactions
    .map((reaction) => (reaction === current ? { name, memberIds } : reaction))
    .filter((reaction) => reaction.memberIds.length > 0);
}

// "Serwer": autor zawsze z sesji (ME), nigdy z formularza.
function serverEdit(messages, id, text) {
  const message = messages.find((m) => m.id === id);
  if (!message) return { messages, error: '' };
  if (message.authorId !== ME) return { messages, error: 'Możesz edytować tylko własną wiadomość.' };
  const clean = text.trim();
  if (!clean) return { messages, error: 'Wiadomość nie może być pusta.' };
  return { messages: messages.map((m) => (m.id === id ? { ...m, text: clean, edited: true } : m)), error: '' };
}

function serverDelete(messages, id) {
  const message = messages.find((m) => m.id === id);
  if (!message) return { messages, error: '' };
  if (message.authorId !== ME) return { messages, error: 'Możesz usunąć tylko własną wiadomość.' };
  return { messages: messages.filter((m) => m.id !== id && m.parentId !== id), error: '' };
}

function MessageInput({ id, placeholder, onSend }) {
  const [text, setText] = useState('');
  const [error, setError] = useState('');

  function send() {
    if (!text.trim()) {
      setError('Napisz coś przed wysłaniem.');
      return;
    }
    onSend(text.trim());
    setText('');
    setError('');
  }

  return (
    <form
      onSubmit={(e) => {
        e.preventDefault();
        send();
      }}
      className="border-t border-gray-200 p-2"
    >
      <label className="sr-only" htmlFor={id}>Wiadomość</label>
      <textarea
        id={id}
        rows={2}
        value={text}
        placeholder={placeholder}
        onChange={(e) => setText(e.target.value)}
        onKeyDown={(e) => {
          if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing) {
            e.preventDefault();
            send();
          }
        }}
        className="w-full resize-none rounded-md border border-gray-300 p-2 text-sm"
      />
      <div className="flex items-center justify-between">
        <p className="text-xs text-gray-500">Enter wysyła, Shift+Enter łamie linię</p>
        <button className="rounded-md bg-green-700 px-3 py-1 text-sm font-semibold text-white">Wyślij</button>
      </div>
      {error && <p role="alert" className="text-sm text-red-700">{error}</p>}
    </form>
  );
}

function MessageItem({ message, replyCount, onReact, onEdit, onDelete, onOpenThread }) {
  const [editing, setEditing] = useState(false);
  const [draft, setDraft] = useState(message.text);
  const isOwn = message.authorId === ME;

  return (
    <article className="group relative px-3 py-2 hover:bg-gray-50 focus-within:bg-gray-50">
      <p className="text-sm">
        <span className="font-bold">{names[message.authorId]}</span>{' '}
        <span className="text-xs text-gray-500">{message.time}</span>
        {message.edited && <span className="text-xs text-gray-500"> (edytowano)</span>}
      </p>
      {editing ? (
        <form
          onSubmit={(e) => {
            e.preventDefault();
            onEdit(message.id, draft);
            setEditing(false);
          }}
          className="space-y-1"
        >
          <textarea value={draft} onChange={(e) => setDraft(e.target.value)} aria-label="Treść wiadomości" className="w-full rounded-md border border-gray-300 p-1 text-sm" />
          <button className="rounded-md bg-green-700 px-2 py-0.5 text-xs text-white">Zapisz</button>
        </form>
      ) : (
        <p className="whitespace-pre-wrap text-sm">{message.text}</p>
      )}
      {message.reactions.length > 0 && (
        <div className="mt-1 flex gap-1">
          {message.reactions.map((reaction) => (
            <button
              key={reaction.name}
              onClick={() => onReact(message.id, reaction.name)}
              aria-pressed={reaction.memberIds.includes(ME)}
              className="rounded-full border border-gray-300 px-2 text-xs aria-pressed:border-blue-600 aria-pressed:bg-blue-50"
            >
              :{reaction.name}: {reaction.memberIds.length}
            </button>
          ))}
        </div>
      )}
      {onOpenThread && replyCount > 0 && (
        <button onClick={() => onOpenThread(message.id)} className="text-xs font-semibold text-blue-700 hover:underline">
          Odpowiedzi: {replyCount}
        </button>
      )}
      <div className="absolute right-2 top-1 flex gap-1 rounded-md border border-gray-200 bg-white p-0.5 text-xs opacity-0 shadow-sm group-hover:opacity-100 group-focus-within:opacity-100 pointer-coarse:opacity-100">
        {REACTIONS.map((name) => (
          <button key={name} onClick={() => onReact(message.id, name)} className="rounded px-1 hover:bg-gray-100">:{name}:</button>
        ))}
        {onOpenThread && <button onClick={() => onOpenThread(message.id)} className="rounded px-1 hover:bg-gray-100">Odpowiedz</button>}
        {isOwn && !editing && (
          <>
            <button onClick={() => setEditing(true)} className="rounded px-1 hover:bg-gray-100">Edytuj</button>
            <button onClick={() => onDelete(message.id)} className="rounded px-1 text-red-700 hover:bg-red-50">Usuń</button>
          </>
        )}
      </div>
    </article>
  );
}

export default function App() {
  const [messages, setMessages] = useState(initialMessages);
  const [threadId, setThreadId] = useState(null);
  const [serverError, setServerError] = useState('');
  const topLevel = messages.filter((m) => !m.parentId);
  const parent = topLevel.find((m) => m.id === threadId);

  function react(id, name) {
    setMessages(messages.map((m) => (m.id === id ? { ...m, reactions: toggleReaction(m.reactions, name, ME) } : m)));
  }

  function apply(result) {
    setMessages(result.messages);
    setServerError(result.error);
  }

  function send(text, parentId) {
    const id = 'm' + Date.now();
    setMessages([...messages, { id, authorId: ME, text, time: 'teraz', parentId, reactions: [] }]);
  }

  const itemProps = {
    onReact: react,
    onEdit: (id, text) => apply(serverEdit(messages, id, text)),
    onDelete: (id) => apply(serverDelete(messages, id)),
  };

  return (
    <div className="min-h-screen bg-gray-100 p-3 text-gray-900">
      <div className="mb-2 flex flex-wrap items-center gap-2 text-sm">
        <span>Jesteś: {names[ME]}</span>
        <button onClick={() => apply(serverDelete(messages, 'm2'))} className="rounded-md border border-red-600 px-2 py-0.5 text-red-700">
          Wyślij żądanie usunięcia wiadomości Anne z pominięciem przycisku
        </button>
      </div>
      {serverError && <p role="alert" className="mb-2 rounded-md bg-red-50 p-2 text-sm text-red-800">Serwer: {serverError}</p>}
      <div className="flex overflow-hidden rounded-lg border border-gray-200 bg-white">
        <section className="flex min-w-0 flex-1 flex-col">
          <h1 className="border-b border-gray-200 px-3 py-2 font-bold"># general</h1>
          <div className="flex-1">
            {topLevel.map((m) => (
              <MessageItem key={m.id} message={m} replyCount={messages.filter((r) => r.parentId === m.id).length} onOpenThread={setThreadId} {...itemProps} />
            ))}
          </div>
          <MessageInput id="message" placeholder="Napisz na #general" onSend={(text) => send(text)} />
        </section>
        {parent && (
          <aside aria-label="Wątek" className="flex w-64 shrink-0 flex-col border-l border-gray-200">
            <div className="flex items-center justify-between border-b border-gray-200 px-3 py-2">
              <h2 className="font-bold">Wątek</h2>
              <button onClick={() => setThreadId(null)} className="text-sm hover:underline">Zamknij</button>
            </div>
            <div className="flex-1">
              <MessageItem message={parent} replyCount={0} {...itemProps} />
              {messages.filter((r) => r.parentId === parent.id).map((r) => (
                <MessageItem key={r.id} message={r} replyCount={0} {...itemProps} />
              ))}
            </div>
            <MessageInput key={parent.id} id="reply" placeholder="Odpowiedz w wątku" onSend={(text) => send(text, parent.id)} />
          </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. Które pola ma typ Message w Ship's Comms?

  2. 2. Do czego służy pole editedAt w Message?

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

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż w jednej linii adres, pod którym otwiera się wątek wiadomości m1 w kanale general:

  • Edytor kodu

    Chat message component

  • Układanie w pionie

    Uporządkuj wysłanie wiadomości w MessageInput:

  • Edytor kodu

    Chat message input

  • Układanie w pionie

    Ułóż elementy wiadomości w MessageItem od góry do dołu:

  • Układanie w poziomie

    Ułóż w jednej linii wywołanie, które po zmianie odświeża wszystkie strony kanałów:

  • Układanie w pionie

    Uporządkuj kroki edycji własnej wiadomości:

  • Układanie w poziomie

    Ułóż przyciski paska akcji własnej wiadomości (jeden rząd, od lewej):

  1. PytanieQuiz: Pola typu Message
  2. PytanieQuiz: Pole editedAt
  3. Ułóż w kolejnościSortowanie: Adres wątku
  4. Zadanie z kodemPraktyka: Message item
  5. PytanieQuiz: Reakcje pod wiadomością
  6. PytanieQuiz: Pasek akcji bez myszy
  7. Ułóż w kolejnościSortowanie: Wysyłanie wiadomości
  8. Zadanie z kodemPraktyka: Message input
  9. PytanieQuiz: Enter i Shift+Enter
  10. PytanieQuiz: isComposing w polu wiadomości
  11. Ułóż w kolejnościSortowanie: Układ wiadomości
  12. PytanieQuiz: Liczba odpowiedzi
  13. Ułóż w kolejnościSortowanie: Odświeżenie stron kanałów
  14. Ułóż w kolejnościSortowanie: Edycja wiadomości
  15. PytanieQuiz: Klucz pola w wątku
  16. Ułóż w kolejnościSortowanie: Pasek akcji wiadomości

Przydatne artykuły