Cours Vibe coding avec Claude Code · Module 8: Clone de Slack
Le journal de bord : messages, réactions et fils de discussion
Dans cette leçon10
Un canal sans messages est une cabine vide. Dans Slack, une conversation, c'est plus que du texte : sous un message, on laisse une réaction au lieu d'écrire « d'accord », l'auteur corrige une faute de frappe, et une discussion plus longue descend dans un fil, c'est-à-dire un panneau séparé avec les réponses sous un seul message. Le canal reste lisible, et celui qui veut les détails ouvre le panneau sur le côté.
Problème : qui peut modifier une entrée du journal
Seul l'auteur d'un message peut le modifier et le supprimer. Le navigateur cachera les boutons sous les messages des autres, mais la documentation de Next.js avertit qu'une Server Action peut être appelée par une requête POST directe, en contournant l'interface. La décision appartient donc au serveur. Le second piège, ce sont les nombres : le compteur de réactions et le compteur de réponses s'écrivent facilement à côté des données, et on oublie ensuite de les corriger.
Demande pour Claude Code :
/plan Ajoute les messages à Ship's Comms. Un type Message dans
types/chat.ts : auteur, texte, date ISO, editedAt, parentId pour
les réponses dans un fil et les réactions (un nom court comme "+1"
plus la liste des membres). N'enregistre pas les compteurs, calcule-
les à partir des données. Données dans data/messages.json via
lib/store.ts. D'abord les tests de la fonction pure toggleReaction
dans lib/reactions.ts : nouvelle réaction, deuxième membre, retrait
de la sienne, une réaction vide disparaît, l'entrée n'est pas
modifiée. Ensuite les Server Actions : envoi, réaction, modification
et suppression ; l'auteur vient toujours de getCurrentMember(),
modification et suppression seulement de ses propres messages. Les
composants : la liste des messages, MessageItem avec des actions au
survol (accessibles aussi au clavier et au toucher), MessageInput
(Entrée envoie, Maj+Entrée passe à la ligne) et le panneau du fil à
l'adresse ?thread=<id>. Pour finir, tests, lint, types et build.Tu ne dis pas un mot du formatage : le hook de la leçon précédente rangera chaque fichier que Claude modifiera.
Ce que Claude a écrit : le message dans les types
Ouvre types/chat.ts dans Cursor. Sous le modèle des canaux, deux types sont apparus :
export interface Reaction {
name: string; // nom court comme dans Slack : "+1", "eyes", "tada"
memberIds: string[];
}
export interface Message {
id: string;
channelId: string;
authorId: string;
text: string;
createdAt: string; // texte ISO
editedAt?: string;
parentId?: string; // réponse dans un fil : id du message auquel elle est rattachée
reactions: Reaction[];
}Le message désigne le canal et l'auteur par des identifiants. Une réponse dans un fil est un message ordinaire avec le champ parentId, donc le panneau du fil n'est qu'un filtre sur la liste. Il n'y a pas de champs count ni replyCount : le nombre de réactions vient de memberIds.length, et le nombre de réponses du comptage des messages ayant ce parentId. Un nombre que tu n'enregistres pas ne peut pas se désynchroniser des données. Les réactions sont de courts noms entre deux-points, :+1:, tels qu'on les tape dans Slack ; les images viendront plus tard comme une couche d'apparence.
Où vivent les messages et comment on compte le temps
Les messages vont dans le fichier data/messages.json via lib/store.ts, comme les profils dans Crew Connections. Le fichier commence par import "server-only", donc un import accidentel dans un composant du navigateur fait échouer le build avec une erreur lisible, et Claude a ajouté le dossier data au .gitignore. La liste de components/MessageList.tsx n'affiche que les messages sans parentId et, pour chacun, compte les réponses en filtrant toute la liste du canal. Un canal vide reçoit la phrase « Silence radio sur ce canal pour l'instant » au lieu d'une tache blanche. L'heure d'un message est formatée par lib/format.ts :
const timeFormat = new Intl.DateTimeFormat("fr-FR", {
day: "numeric",
month: "short",
hour: "2-digit",
minute: "2-digit",
timeZone: "Europe/Paris",
});Du texte ISO naît une chaîne du genre « 14 nov., 09:00 ». Le fuseau horaire est indiqué explicitement, car un serveur d'hébergement compte souvent le temps dans un autre fuseau que ton ordinateur. Le formatage se fait sur le serveur, et le composant du navigateur reçoit une chaîne toute prête : l'heure ne dépend donc pas de l'endroit où le code tourne. La date de modification va dans editedAt, et un tel message porte la mention « (modifié) ».
D'abord un test : le commutateur de réaction
Ouvre lib/reactions.test.ts. Les noms des cas sont le moyen le plus rapide de juger si Claude a compris les règles :
it("un second clic retire sa propre réaction et supprime la réaction vide de la liste", () => {
const before: Reaction[] = [{ name: "+1", memberIds: ["u1"] }];
expect(toggleReaction(before, "+1", "u1")).toEqual([]);
});À côté se trouvent trois autres cas : une nouvelle réaction, un deuxième membre de l'équipage et « ne modifie pas le tableau d'entrée ». Le dernier veille à ce que la fonction renvoie une nouvelle liste au lieu de réarranger l'ancienne, car React remarque un changement grâce à un nouvel objet. La fonction elle-même, dans 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);
}Une nouvelle réaction démarre avec un seul membre, et un clic sur une réaction existante t'ajoute ou te retire de la liste. Le dernier filter supprime la réaction où il ne reste personne, donc aucun :+1: 0 ne restera accroché sous un message.
Le serveur surveille l'auteur
Ouvre app/c/[channel]/actions.ts. Chaque action commence par le membre connecté de l'équipage, jamais par un champ de formulaire :
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("Tu ne peux supprimer que ton propre message.");
}
await writeMessages(
messages.filter((m) => m.id !== messageId && m.parentId !== messageId),
);
revalidatePath("/c/[channel]", "page");
}editMessage fait la même vérification, et reactToMessage rejette un nom absent de la liste REACTIONS, donc une réaction au nom vide ne naîtra pas. Supprimer un message emporte aussi les réponses de son fil. revalidatePath reçoit un motif de route et le type "page", car la documentation de Next.js exige le type quand le chemin a un segment dynamique ; c'est ainsi que toutes les pages de canaux se rafraîchissent.
Actions au survol, au clavier et au toucher
Ouvre components/MessageItem.tsx. Le message a en haut un en-tête avec l'auteur et l'heure, puis le contenu, les réactions et un lien avec le nombre de réponses. Dans le coin supérieur droit se trouve la barre d'actions (trois réactions, Répondre et, sur son propre message, Modifier et Supprimer). Elle est toujours dans le code de la page, et ce sont les classes qui décident si on la voit :
<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 montre la barre quand le curseur est au-dessus du message, et group-focus-within quand un bouton à l'intérieur reçoit le focus avec la touche Tab. pointer-coarse est une variante de Tailwind pour un pointeur peu précis, c'est-à-dire un doigt sur un écran tactile : là, la barre est toujours visible, car hover: dans Tailwind 4 ne fonctionne que sur les appareils avec un curseur. L'ancienne version avec l'événement onMouseEnter ne montrait jamais les actions sur un téléphone. Le mode édition garde dans le composant l'état editing, et l'enregistrement appelle editMessage. Une réaction que tu as déjà donnée a aria-pressed="true" : le lecteur d'écran annoncera que le bouton est enfoncé, et les classes aria-pressed:border-blue-600 et aria-pressed:bg-blue-50 le colorent en bleu.
Le champ de message : Entrée et Maj+Entrée
Ouvre components/MessageInput.tsx. Le formulaire envoie le texte par une Server Action, et le raccourci clavier est géré par une petite fonction :
function handleKeyDown(event: React.KeyboardEvent<HTMLTextAreaElement>) {
if (
event.key === "Enter" &&
!event.shiftKey &&
!event.nativeEvent.isComposing
) {
event.preventDefault();
event.currentTarget.form?.requestSubmit();
}
}Entrée seule bloque le saut de ligne et envoie le formulaire via requestSubmit(), comme si quelqu'un avait cliqué sur « Envoyer ». Maj+Entrée ne remplit pas la condition, donc le champ reçoit une nouvelle ligne. isComposing protège les personnes qui écrivent avec une méthode de saisie où Entrée valide un caractère et non le message. Après l'envoi, le champ se vide ; en cas d'erreur, par exemple un texte fait seulement d'espaces, il garde son contenu et affiche un message en dessous. Au-dessus du champ se trouve un <label> avec la classe sr-only, car le seul placeholder disparaît dès la première lettre et ne remplace pas une description pour le lecteur d'écran.
Le fil à son adresse
Le lien « Répondre » mène à une adresse du genre /c/general?thread=m1. La page du canal lit searchParams, retrouve le message parent et transmet ses réponses à components/ThreadPanel.tsx. En bas du panneau se trouve le même champ que dans le canal :
<MessageInput
key={parent.id}
channelId={channel.id}
parentId={parent.id}
placeholder="Répondre dans le fil"
/>Un fil dans l'adresse peut être envoyé à quelqu'un de l'équipage ou ouvert dans un nouvel onglet, et « Fermer » est un simple lien vers le canal. key={parent.id} compte : passer à un autre fil ne change que le paramètre de l'adresse, donc React laisse les composants en place avec leur état. Nous l'avons vérifié : sans clé, le brouillon d'une réponse d'un fil restait dans le champ après l'ouverture d'un autre. Le nom de l'auteur d'une réponse, le panneau le prend dans authorName(reply.authorId), car le message ne connaît que l'identifiant de son auteur.
La revue du capitaine
- Le message d'un autre. Nous avons demandé à Claude un essai : il a envoyé le formulaire de suppression avec l'identifiant d'un message d'Anne. Le serveur a répondu par une erreur, le terminal du serveur a affiché « Tu ne peux supprimer que ton propre message. », et le message est resté. Erreur typique d'un agent : une vérification seulement dans le JSX (
isOwn && <button>), alors que l'action supprime tout ce qu'on lui demande. - Les compteurs. Cherche dans le diff des champs
countoureplyCount. Si Claude les a ajoutés, demande de les calculer à partir des données. - Le clavier. Parcours un message avec Tab : la barre d'actions doit apparaître, et Entrée sur « Supprimer » doit agir comme un clic.
- La preuve. Tests, lint, types et build. À la fin,
npx prettier --check .annonce « All matched files use Prettier code style! », alors que la demande ne disait pas un mot de formatage. C'est le travail du hook.
Étape suivante
Quand la revue passe, demande un commit, par exemple « Messages, réactions et fils ». Ensuite un petit pas avec un test :
Ajoute à lib/reactions.test.ts un cas : le même membre réagit
:+1: et :eyes:, les deux réactions restent. Montre le résultat des
tests. Ensuite ajoute une confirmation avant la suppression d'un
message.Dans l'éditeur ci-dessous t'attend un canal en miniature : les réactions avec le même commutateur, la modification de tes seuls messages et le fil. Essaie Entrée et Maj+Entrée, puis tente de supprimer le message d'un autre.
Retiens : seul celui qui a fait une entrée du journal de bord peut la corriger, et c'est le capitaine du port, c'est-à-dire le serveur, qui y veille, et non le journal lui-même.
Code de cette leçon : App.jsx
// Le canal #general en miniature : réactions, modification, suppression et fil.
// Dans le projet, ce sont les Server Actions de app/c/[channel]/actions.ts qui gardent les règles ;
// ici, les fonctions « serveur » ci-dessous vérifient le même ensemble de règles.
import { useState } from 'react';
const ME = 'u1';
const REACTIONS = ['+1', 'eyes', 'tada'];
const names = { u1: 'Capitaine Barbe-Rousse', u2: 'Anne Bonny', u3: 'Étienne Sternik' };
const initialMessages = [
{ id: 'm1', authorId: 'u1', text: 'Ohé, l’équipage ! Demain à l’aube, on lève l’ancre.', time: '09:00', reactions: [{ name: '+1', memberIds: ['u2', 'u3'] }] },
{ id: 'm2', authorId: 'u2', text: 'Les tonneaux d’eau sont déjà à bord.', time: '09:05', reactions: [] },
{ id: 'm3', authorId: 'u3', text: 'Je vérifierai les cordages avant l’appareillage.', time: '09:10', parentId: 'm1', reactions: [] },
];
// La même fonction pure que dans 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);
}
// « Serveur » : l’auteur vient toujours de la session (ME), jamais du formulaire.
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: 'Tu ne peux modifier que ton propre message.' };
const clean = text.trim();
if (!clean) return { messages, error: 'Le message ne peut pas être vide.' };
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: 'Tu ne peux supprimer que ton propre message.' };
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('Écris quelque chose avant d’envoyer.');
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}>Message</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">Entrée envoie, Maj+Entrée passe à la ligne</p>
<button className="rounded-md bg-green-700 px-3 py-1 text-sm font-semibold text-white">Envoyer</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"> (modifié)</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="Contenu du message" 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">Enregistrer</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">
Réponses : {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">Répondre</button>}
{isOwn && !editing && (
<>
<button onClick={() => setEditing(true)} className="rounded px-1 hover:bg-gray-100">Modifier</button>
<button onClick={() => onDelete(message.id)} className="rounded px-1 text-red-700 hover:bg-red-50">Supprimer</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: 'à l’instant', 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>Tu es : {names[ME]}</span>
<button onClick={() => apply(serverDelete(messages, 'm2'))} className="rounded-md border border-red-600 px-2 py-0.5 text-red-700">
Envoyer une requête de suppression du message d’Anne en contournant le bouton
</button>
</div>
{serverError && <p role="alert" className="mb-2 rounded-md bg-red-50 p-2 text-sm text-red-800">Serveur : {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="Écris sur #general" onSend={(text) => send(text)} />
</section>
{parent && (
<aside aria-label="Fil" 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">Fil</h2>
<button onClick={() => setThreadId(null)} className="text-sm hover:underline">Fermer</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="Répondre dans le fil" onSend={(text) => send(text, parent.id)} />
</aside>
)}
</div>
</div>
);
}Tu as repéré une erreur dans cette leçon ?
Teste tes connaissances
Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.
1. Quels champs a le type Message dans Ship's Comms ?
2. À quoi sert le champ editedAt dans Message ?
Voici 2 des 8 questions de cette leçon. Réponds aux autres dans le jeu.
Tâches pratiques dans le jeu
- Tri horizontal
Place sur une seule ligne l'adresse où s'ouvre le fil du message m1 dans le canal general :
- Éditeur de code
Composant message de chat
- Tri vertical
Ordonne l'envoi d'un message dans MessageInput :
- Éditeur de code
Champ de saisie du chat
- Tri vertical
Ordonne les éléments d'un message dans MessageItem, de haut en bas :
- Tri horizontal
Place sur une seule ligne l'appel qui, après un changement, rafraîchit toutes les pages des canaux :
- Tri vertical
Ordonne les étapes de modification de ton propre message :
- Tri horizontal
Ordonne les boutons de la barre d'actions de ton propre message (une seule rangée, depuis la gauche) :
Exercices après cette leçon
- QuestionQuiz : les champs du type Message
- QuestionQuiz : le champ editedAt
- Remets dans l'ordreTri : l'adresse d'un fil
- Exercice de codePratique : Élément de message
- QuestionQuiz : les réactions sous un message
- QuestionQuiz : la barre d'actions sans souris
- Remets dans l'ordreTri : l'envoi d'un message
- Exercice de codePratique : champ de message
- QuestionQuiz : Entrée et Maj+Entrée
- QuestionQuiz : isComposing dans le champ de message
- Remets dans l'ordreTri : la disposition d'un message
- QuestionQuiz : le nombre de réponses
- Remets dans l'ordreTri : rafraîchir les pages des canaux
- Remets dans l'ordreTri : modifier un message
- QuestionQuiz : la clé du champ dans le fil
- Remets dans l'ordreTri : la barre d'actions d'un message