Kurs vibe coding z Claude Code · Moduł 8: Klon Slacka
Dziennik pokładowy: wiadomości, reakcje i wątki
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
- 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. - Liczniki. Szukaj w diffie pól
countalboreplyCount. Jeśli Claude je dodał, poproś o liczenie z danych. - Klawiatura. Przejdź Tabem przez wiadomość: pasek akcji musi się pokazać, a Enter na "Usuń" działać jak kliknięcie.
- 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. Które pola ma typ Message w Ship's Comms?
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):
Zadania po tej lekcji
- PytanieQuiz: Pola typu Message
- PytanieQuiz: Pole editedAt
- Ułóż w kolejnościSortowanie: Adres wątku
- Zadanie z kodemPraktyka: Message item
- PytanieQuiz: Reakcje pod wiadomością
- PytanieQuiz: Pasek akcji bez myszy
- Ułóż w kolejnościSortowanie: Wysyłanie wiadomości
- Zadanie z kodemPraktyka: Message input
- PytanieQuiz: Enter i Shift+Enter
- PytanieQuiz: isComposing w polu wiadomości
- Ułóż w kolejnościSortowanie: Układ wiadomości
- PytanieQuiz: Liczba odpowiedzi
- Ułóż w kolejnościSortowanie: Odświeżenie stron kanałów
- Ułóż w kolejnościSortowanie: Edycja wiadomości
- PytanieQuiz: Klucz pola w wątku
- Ułóż w kolejnościSortowanie: Pasek akcji wiadomości