# Story 4.3 : Drag & drop priorisation (FR33, FR34) Status: done ## Story En tant que Transformateur, je veux réordonner les idées par drag & drop dans le backlog (vue liste et vue kanban), afin de définir ma priorisation et voir le classement résultant de mes ajustements. ## Acceptance Criteria 1. **Given** j'ai des idées dans la vue liste du backlog (`/workspace/[workspaceId]/backlog`) **When** je glisse-dépose une ligne vers une nouvelle position **Then** le champ `priorityOrder` est mis à jour en base pour toutes les idées réordonnées **And** un optimistic update déplace la ligne visuellement avant confirmation serveur **And** en cas d'erreur serveur, l'ordre d'origine est restauré et un message inline s'affiche : "Impossible de sauvegarder l'ordre. Réessayez." 2. **Given** j'ai des idées dans la vue liste et au moins une idée a un `priorityOrder` non null **When** j'affiche le backlog en mode tri "Priorité" **Then** les idées sont triées par `priorityOrder` asc (les idées sans priorityOrder apparaissent en dernier) **And** chaque ligne affiche son rang de priorité (#1, #2, #3…) dans une colonne dédiée "Priorité" 3. **Given** j'ai des idées dans la vue liste **When** j'active le glisser-déposer (curseur `grab` sur le handle) **Then** un handle de drag est visible sur chaque ligne (icône `GripVertical` à gauche) **And** le drag ne déclenche PAS la navigation vers la fiche détaillée de l'idée 4. **Given** j'ai des idées dans la vue kanban (`/workspace/[workspaceId]/backlog/kanban`) **When** je glisse-dépose une carte dans la même colonne **Then** l'ordre des cartes dans cette colonne est mis à jour (priorityOrder relatif aux autres idées de même statut) **And** un optimistic update réorganise les cartes visuellement avant confirmation serveur 5. **Given** j'ai des idées dans la vue kanban **When** je glisse-dépose une carte vers une autre colonne **Then** le statut de l'idée est mis à jour vers le statut cible de la colonne (`SUBMITTED`, `IN_REVIEW`, `ON_AGENDA`, `IN_PROGRESS`) **And** l'idée est insérée en première position de la colonne cible (`priorityOrder` min des idées de ce statut - 1 ou 0 si vide) **And** le changement de statut est persisté en base (même procédure `updateOrder` avec `newStatus` en option) **And** en cas d'erreur serveur, l'état d'origine (statut + position) est restauré 6. **Given** je glisse une carte vers la colonne "Non prioritaire" du kanban **When** le drop se produit **Then** ce scénario N'EST PAS supporté — la colonne `NOT_PRIORITY` n'est jamais une zone de drop valide dans le kanban (elle est exclue du kanban, Story 3.3) 7. **Given** le drag est en cours **When** je survole une zone de drop valide **Then** la zone cible est mise en évidence visuellement (fond légèrement coloré, bordure) **And** un `DragOverlay` affiche une version translucide de la carte/ligne draguée 8. **Given** la mutation `idea.updateOrder` est en attente **When** le serveur traite la mise à jour **Then** l'UI ne bloque pas (optimistic update déjà en place) **And** en cas de succès, l'état local est validé (aucun rechargement complet) ## Tasks / Subtasks - [x] Task 1 : Installation des packages dnd-kit (pas encore installés — vérifier `package.json`) - [x] Subtask 1.1 : Installer les packages dans `aimpact-hub/` : ```powershell cd "c:\Users\USER\Documents\Intersel - Livinweb\dev\AImpact-Ai_Hub\aimpact-hub" pnpm add @dnd-kit/core @dnd-kit/sortable @dnd-kit/utilities ``` - [x] Subtask 1.2 : Vérifier l'installation : `@dnd-kit/core` ^6.3.0, `@dnd-kit/sortable` ^10.0.0, `@dnd-kit/utilities` ^3.x - [x] Task 2 : Procédure tRPC `idea.updateOrder` (AC: #1, #4, #5, #8) - [x] Subtask 2.1 : Ajouter dans `src/server/api/routers/idea.ts` la procédure protégée `updateOrder` : ```typescript updateOrder: protectedProcedure .input(z.object({ workspaceId: z.string().cuid(), orderedIds: z.array(z.string().cuid()), // IDs dans le nouvel ordre souhaité newStatus: z.nativeEnum(IdeaStatus).optional(), // uniquement si drop cross-column (kanban) movedIdeaId: z.string().cuid().optional(), // uniquement si cross-column })) .mutation(async ({ ctx, input }) => { // Vérifier ownership const workspace = await ctx.db.workspace.findUnique({ where: { id: input.workspaceId }, select: { ownerId: true }, }); if (!workspace || workspace.ownerId !== ctx.session.user.id) { throw new TRPCError({ code: "FORBIDDEN" }); } // Si cross-column : mettre à jour le statut de l'idée déplacée if (input.newStatus && input.movedIdeaId) { await ctx.db.idea.update({ where: { id: input.movedIdeaId }, data: { status: input.newStatus }, }); } // Réécrire priorityOrder pour chaque idée dans orderedIds await ctx.db.$transaction( input.orderedIds.map((id, index) => ctx.db.idea.update({ where: { id }, data: { priorityOrder: index + 1 }, }) ) ); return { success: true }; }), ``` - [x] Subtask 2.2 : S'assurer que `IdeaStatus` est importé depuis `@prisma/client` (ou depuis `~/generated/prisma`) - [x] Subtask 2.3 : Vérifier que `protectedProcedure` valide la session (`ctx.session.user.id` disponible) - [x] Subtask 2.4 : Ajouter `@@index([workspaceId, priorityOrder])` dans `schema.prisma` sur le modèle `Idea` si non existant (améliore les requêtes triées par priorité) — puis exécuter `pnpm prisma migrate dev --name add_priority_order_index` > **Note :** Le champ `priorityOrder Int?` est **déjà présent** dans le schema (Story 4.3 anticipée). Vérifier s'il y a un index ; si non, créer la migration. Si le champ n'a pas d'index, en ajouter un. - [x] Task 3 : Mise à jour `idea.getBacklog` — support tri par priorité (AC: #2) - [x] Subtask 3.1 : Dans `src/server/api/routers/idea.ts`, étendre le type d'input de `getBacklog` pour accepter `sortBy: "priority"` en plus des valeurs existantes - [x] Subtask 3.2 : Ajouter le cas `sortBy === "priority"` dans la construction de `orderBy` : ```typescript case "priority": orderBy = [ { priorityOrder: { sort: "asc", nulls: "last" } }, { createdAt: "desc" }, // secondaire : les non-prioritisées par date ]; break; ``` - [x] Subtask 3.3 : Retourner `priorityOrder` dans le select de `getBacklog` (si non déjà inclus) - [x] Task 4 : Drag & drop dans la vue liste `BacklogListView.tsx` (AC: #1, #2, #3, #7, #8) - [x] Subtask 4.1 : Ajouter les imports dnd-kit en tête de `src/components/backlog/BacklogListView.tsx` : ```typescript import { DndContext, closestCenter, PointerSensor, useSensor, useSensors, type DragEndEvent, DragOverlay, } from "@dnd-kit/core"; import { SortableContext, verticalListSortingStrategy, arrayMove, useSortable, } from "@dnd-kit/sortable"; import { CSS } from "@dnd-kit/utilities"; import { GripVertical } from "lucide-react"; ``` - [x] Subtask 4.2 : Ajouter état local `localIdeas` (copie optimiste de `data`) et `activeId` (pour DragOverlay) : ```typescript const [localIdeas, setLocalIdeas] = useState(data ?? []); const [activeId, setActiveId] = useState(null); // Synchroniser avec les données serveur (sauf pendant le drag) useEffect(() => { if (!activeId && data) setLocalIdeas(data); }, [data, activeId]); ``` - [x] Subtask 4.3 : Configurer les sensors (PointerSensor avec distance minimale de 5px pour éviter les clics accidentels) : ```typescript const sensors = useSensors( useSensor(PointerSensor, { activationConstraint: { distance: 5 }, }) ); ``` - [x] Subtask 4.4 : Implémenter `handleDragEnd` : ```typescript const updateOrder = api.idea.updateOrder.useMutation({ onError: () => { setLocalIdeas(data ?? []); // restaurer ordre original // afficher message d'erreur inline }, }); function handleDragEnd(event: DragEndEvent) { const { active, over } = event; setActiveId(null); if (!over || active.id === over.id) return; const oldIndex = localIdeas.findIndex((i) => i.id === active.id); const newIndex = localIdeas.findIndex((i) => i.id === over.id); const reordered = arrayMove(localIdeas, oldIndex, newIndex); setLocalIdeas(reordered); // optimistic updateOrder.mutate({ workspaceId, orderedIds: reordered.map((i) => i.id), }); } ``` - [x] Subtask 4.5 : Envelopper le tableau d'idées dans `` + `` : ```tsx setActiveId(e.active.id as string)} onDragEnd={handleDragEnd} > i.id)} strategy={verticalListSortingStrategy} > {/* tableau des lignes IdeaRow */} {activeId && ( i.id === activeId)!} workspaceId={workspaceId} isDragOverlay /> )} ``` - [x] Subtask 4.6 : Créer composant wrapper `SortableIdeaRow` qui enveloppe `IdeaRow` avec `useSortable` : ```typescript function SortableIdeaRow({ idea, workspaceId }: { idea: IdeaRowData; workspaceId: string }) { const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: idea.id, }); const style = { transform: CSS.Transform.toString(transform), transition, opacity: isDragging ? 0.4 : 1, }; return (
); } ``` - [x] Subtask 4.7 : Mettre à jour `IdeaRow.tsx` pour afficher le handle de drag : - Ajouter prop optionnelle `dragHandleProps?: React.HTMLAttributes` et `isDragOverlay?: boolean` - Afficher `
` en première cellule - Si `isDragOverlay` → afficher sans handle (visuel épuré) - [x] Subtask 4.8 : Ajouter colonne "Priorité" dans le tableau (visible uniquement si `sortBy === "priority"`) : - Afficher `#${localIdeas.findIndex(i => i.id === idea.id) + 1}` pour les idées prioritisées - Afficher `—` pour les idées sans `priorityOrder` - [x] Subtask 4.9 : Ajouter l'option "Priorité" dans le sélecteur de tri de `BacklogFilters.tsx` - [x] Subtask 4.10 : Afficher le message d'erreur inline si `updateOrder.isError` : badge rouge "Impossible de sauvegarder l'ordre. Réessayez." sous la topbar - [x] Task 5 : Drag & drop dans la vue kanban `KanbanBoard.tsx` (AC: #4, #5, #6, #7, #8) - [x] Subtask 5.1 : Ajouter les imports dnd-kit dans `src/components/backlog/KanbanBoard.tsx` (idem Task 4.1) - [x] Subtask 5.2 : Ajouter état local `localIdeas` (copie optimiste) et `activeId` avec sync via `useEffect` (idem Task 4.2) - [x] Subtask 5.3 : Configurer les sensors PointerSensor (distance: 5) — idem Task 4.3 - [x] Subtask 5.4 : Implémenter `handleDragEnd` pour le kanban : ```typescript function handleDragEnd(event: DragEndEvent) { const { active, over } = event; setActiveId(null); if (!over || active.id === over.id) return; const draggedIdea = localIdeas.find((i) => i.id === active.id); if (!draggedIdea) return; // Déterminer la colonne source et cible const sourceStatus = draggedIdea.status; // `over.id` peut être un ideaId OU un columnId (si drop sur colonne vide) const targetIdea = localIdeas.find((i) => i.id === over.id); const targetStatus = targetIdea?.status ?? (over.id as IdeaStatus); // si drop sur colonne vide if (!targetStatus) return; const isCrossColumn = sourceStatus !== targetStatus; // Optimistic update const updated = localIdeas.map((i) => i.id === active.id ? { ...i, status: targetStatus } : i ); const sourceItems = updated.filter((i) => i.status === targetStatus); const oldIndex = sourceItems.findIndex((i) => i.id === active.id); const newIndex = targetIdea ? sourceItems.findIndex((i) => i.id === over.id) : 0; // drop sur colonne vide → en tête const reordered = arrayMove(sourceItems, oldIndex, newIndex); setLocalIdeas([...updated.filter((i) => i.status !== targetStatus), ...reordered]); // Persistance const orderedIds = [ ...reordered.map((i) => i.id), ...localIdeas.filter((i) => i.status === sourceStatus && i.id !== active.id).map((i) => i.id), ]; updateOrder.mutate({ workspaceId, orderedIds, ...(isCrossColumn && { newStatus: targetStatus, movedIdeaId: active.id as string, }), }); } ``` - [x] Subtask 5.5 : Envelopper `KanbanBoard` dans `` + un `` global par colonne : ```tsx setActiveId(e.active.id as string)} onDragEnd={handleDragEnd} >
{KANBAN_COLUMNS.map((col) => ( i.status === col.status)} workspaceId={workspaceId} /> ))}
{activeId && ( i.id === activeId)!} workspaceId={workspaceId} isDragOverlay /> )}
``` - [x] Subtask 5.6 : Mettre à jour `KanbanColumn.tsx` — ajouter `SortableContext` + droppable : - Importer `SortableContext`, `verticalListSortingStrategy` de `@dnd-kit/sortable` - Importer `useDroppable` de `@dnd-kit/core` - Utiliser `useDroppable({ id: col.status })` pour rendre la colonne droppable (drop sur colonne vide) - Envelopper les cartes dans ` i.id)} strategy={verticalListSortingStrategy}>` - Ajouter `isOver` style : `className={cn("...", isOver && "bg-violet-50/50 ring-1 ring-violet-300")}` - [x] Subtask 5.7 : Mettre à jour `KanbanCard.tsx` — ajouter `useSortable` : - Importer `useSortable` de `@dnd-kit/sortable` et `CSS` de `@dnd-kit/utilities` - Ajouter prop `isDragOverlay?: boolean` - Si non `isDragOverlay` : utiliser `useSortable({ id: idea.id })` → appliquer `transform`, `transition`, `opacity` (isDragging ? 0.4 : 1) - Ajouter handle `` discret en haut à droite de la carte (visible au hover avec `opacity-0 group-hover:opacity-100`) - Les `listeners` du handle empêchent que le clic sur la carte navigue pendant un drag - [x] Subtask 5.8 : Mutation `updateOrder` avec restauration en cas d'erreur : ```typescript const updateOrder = api.idea.updateOrder.useMutation({ onError: () => { if (data) setLocalIdeas(data); // restaurer // afficher toast ou message inline }, }); ``` - [x] Task 6 : Tests (AC: #1–#8) - [x] Subtask 6.1 : Créer `src/server/api/routers/idea.updateOrder.test.ts` (Vitest) : - Test A : ownership check — workspace d'un autre user → erreur `FORBIDDEN` - Test B : réordonnancement simple — 3 IDs dans nouvel ordre → `priorityOrder` 1, 2, 3 en base - Test C : cross-column — `movedIdeaId` + `newStatus` → statut de l'idée mis à jour + `priorityOrder` assignés - Test D : transaction atomique — si une mise à jour échoue, toutes les mises à jour sont annulées - Test E : `orderedIds` vide → succès sans erreur (edge case) - [x] Subtask 6.2 : Créer `src/components/backlog/BacklogListView.dragdrop.test.tsx` (Vitest + RTL) : - Mock `api.idea.updateOrder.useMutation` et `api.idea.getBacklog.useQuery` - Test F : handles de drag visibles (`GripVertical`) dans chaque ligne - Test G : `DndContext` est rendu (snapshot ou data-testid) - Test H : `handleDragEnd` avec positions valides → `updateOrder.mutate` appelé avec `orderedIds` correct - Test I : `handleDragEnd` sans changement de position (active.id === over.id) → mutation NON appelée - Test J : erreur mutation → `localIdeas` restauré à la valeur initiale - [x] Subtask 6.3 : Créer `src/components/backlog/KanbanBoard.dragdrop.test.tsx` (Vitest + RTL) : - Mock `api.idea.updateOrder.useMutation` et `api.idea.getBacklog.useQuery` - Test K : drag within column → mutation avec `orderedIds` sans `newStatus` - Test L : drag cross-column → mutation avec `newStatus` et `movedIdeaId` - Test M : erreur mutation cross-column → `localIdeas` restauré (statut original) - [x] Subtask 6.4 : Mettre à jour `src/server/api/routers/idea.getBacklog.test.ts` : - Ajouter test N : `sortBy: "priority"` → `orderBy` inclut `priorityOrder asc nulls last` - Ajouter test O : réponse inclut `priorityOrder` dans le select ## Dev Notes ### Contexte de la story Cette story implémente le **drag & drop de priorisation** pour le Transformateur, couvrant à la fois la vue liste et la vue kanban du backlog. Elle s'appuie sur : - **Story 3.2** (`BacklogListView`) — vue liste avec tri et filtres, `getBacklog` tRPC - **Story 3.3** (`KanbanBoard`, `KanbanColumn`, `KanbanCard`) — kanban 4 colonnes - **Schema Prisma** — champ `Idea.priorityOrder Int?` **déjà présent** (anticipé en Story 4.3) ### Champ `priorityOrder` — déjà dans le schema, pas de migration requise ```prisma // schema.prisma — Idea model (ligne 143-144) // Ordre priorisation — Story 4.3 (FR33) priorityOrder Int? ``` **Aucune migration Prisma pour le champ en lui-même.** En revanche, vérifier si un index `@@index([workspaceId, priorityOrder])` existe. Si non, créer une migration pour l'ajouter (performance). ### Installation dnd-kit — REQUIS (non installé) ```powershell cd "c:\Users\USER\Documents\Intersel - Livinweb\dev\AImpact-Ai_Hub\aimpact-hub" pnpm add @dnd-kit/core @dnd-kit/sortable @dnd-kit/utilities ``` Versions cibles (stables, décembre 2024) : - `@dnd-kit/core` : ^6.3.0 - `@dnd-kit/sortable` : ^10.0.0 - `@dnd-kit/utilities` : ^3.2.x ### Procédure tRPC `idea.updateOrder` — patterns clés **Multi-tenant** : vérifier `workspace.ownerId === ctx.session.user.id` avant toute modification. **Transaction Prisma** : utiliser `ctx.db.$transaction([...updates])` pour atomicité. Si une mise à jour échoue (ex. idée supprimée entre-temps), toutes sont annulées. **Cross-column** : le paramètre `newStatus` est optionnel — uniquement envoyé quand l'idée change de colonne kanban. Dans ce cas, mettre à jour `idea.status` AVANT la transaction de `priorityOrder` pour éviter les incohérences. **`orderedIds` complet** : le client envoie les IDs dans le nouvel ordre de la colonne concernée. Toutes les idées de la colonne reçoivent un nouveau `priorityOrder` (1-based). Les idées des autres colonnes ne sont pas touchées. ### Optimistic update — pattern essentiel Sans optimistic update, l'UX serait cassée (la liste "saute" après le drop). Pattern recommandé : ```typescript // 1. Conserver une copie locale de l'état const [localIdeas, setLocalIdeas] = useState(data ?? []); // 2. Sync avec le serveur sauf pendant le drag useEffect(() => { if (!activeId && data) setLocalIdeas(data); }, [data, activeId]); // 3. Après DragEnd : mettre à jour localement PUIS appeler la mutation // 4. Si erreur mutation : restaurer depuis `data` (état serveur) ``` **Ne pas utiliser `utils.idea.getBacklog.invalidate()` dans `onSuccess`** — cela déclencherait un rechargement visuel inutile. L'état optimiste est déjà correct ; invalider uniquement si l'état serveur diffère (ex. conflit multi-onglets). ### Senseur PointerSensor — activation distance ```typescript useSensor(PointerSensor, { activationConstraint: { distance: 5 }, // 5px minimum avant activation }) ``` Cela évite les drags accidentels lors d'un clic simple. **Ne pas utiliser MouseSensor + TouchSensor séparément** — `PointerSensor` gère les deux. ### DragOverlay — rendu hors du flux DOM Le `DragOverlay` est rendu dans un portail hors du flux DOM, évitant les problèmes de z-index dans les tableaux/colonnes. Il affiche une copie visuelle de l'élément draggé. ```tsx {/* dropAnimation: null pour éviter flash */} {activeId && } ``` ### KanbanCard — handle drag vs clic navigation Le composant `KanbanCard` est actuellement un `` cliquable. Avec dnd-kit, les listeners du drag capturent les événements pointer. La solution : ```typescript // Dans KanbanCard.tsx const { attributes, listeners, setNodeRef, ... } = useSortable({ id: idea.id }); // Appliquer listeners UNIQUEMENT sur le handle, pas sur toute la carte return (
{/* handle */}
{/* reste de la carte — cliquable normalement */} ...
); ``` ### BacklogListView — interaction drag vs clic sur lien Même principe : les `listeners` du `useSortable` doivent être appliqués sur le handle `GripVertical` uniquement, pas sur la ligne entière. Le clic sur le titre de l'idée (lien vers fiche) continue de fonctionner normalement. ### dnd-kit — compatibilité Next.js App Router (SSR) `DndContext` de dnd-kit doit être rendu côté client. Puisque `BacklogListView` et `KanbanBoard` sont déjà des composants client (`"use client"`), il n'y a **pas de configuration SSR spéciale requise**. Si jamais un warning "Text content did not match" apparaît, envelopper les composants dnd dans un `useEffect`-mounted guard — mais en pratique avec les composants client actuels, ce n'est pas nécessaire. ### `getBacklog` — inclusion de `priorityOrder` dans le select Vérifier que `priorityOrder` est bien retourné dans le `select` de `idea.getBacklog` (c'est peut-être déjà le cas ou il faut l'ajouter). Ce champ est nécessaire pour : 1. Afficher le rang (#1, #2…) dans la colonne "Priorité" de la liste 2. Trier par priorité (orderBy) ### Ordre des idées au chargement initial Au premier chargement (aucune idée n'a de `priorityOrder`), la liste continue de s'afficher dans l'ordre par défaut (date de création desc). Le drag & drop initialise les `priorityOrder` à la première utilisation. **Clé de tri "Priorité" dans l'UI** : l'option "Priorité" dans le tri de `BacklogFilters` doit être disponible mais accompagnée d'une info si aucune idée n'a encore été priorisée (ex. tooltip "Triez par priorité en glissant les idées dans la liste"). ### Structure des fichiers | Fichier | Action | Notes | |---------|--------|-------| | `aimpact-hub/package.json` | **Modifier** — ajouter `@dnd-kit/core`, `@dnd-kit/sortable`, `@dnd-kit/utilities` | Via `pnpm add` | | `prisma/schema.prisma` | **Modifier si nécessaire** — ajouter `@@index([workspaceId, priorityOrder])` | Vérifier d'abord | | `src/server/api/routers/idea.ts` | **Modifier** — ajouter `updateOrder`, étendre `getBacklog` (sortBy priority + select priorityOrder) | | | `src/components/backlog/BacklogListView.tsx` | **Modifier** — DndContext + SortableContext + optimistic update | | | `src/components/backlog/IdeaRow.tsx` | **Modifier** — ajouter prop `dragHandleProps`, afficher `GripVertical`, colonne Priorité | | | `src/components/backlog/BacklogFilters.tsx` | **Modifier** — ajouter option "Priorité" dans sortBy | | | `src/components/backlog/KanbanBoard.tsx` | **Modifier** — DndContext global + handleDragEnd cross-column | | | `src/components/backlog/KanbanColumn.tsx` | **Modifier** — SortableContext + useDroppable + isOver highlight | | | `src/components/backlog/KanbanCard.tsx` | **Modifier** — useSortable + GripVertical handle + isDragOverlay prop | | | `src/server/api/routers/idea.updateOrder.test.ts` | **Créer** — tests Vitest (5 tests A–E) | | | `src/components/backlog/BacklogListView.dragdrop.test.tsx` | **Créer** — tests Vitest + RTL (5 tests F–J) | | | `src/components/backlog/KanbanBoard.dragdrop.test.tsx` | **Créer** — tests Vitest + RTL (3 tests K–M) | | | `src/server/api/routers/idea.getBacklog.test.ts` | **Modifier** — ajouter tests N–O pour sortBy priority | | ### NFR concernés - **NFR5** : le backlog se charge en moins de 3s pour 200 idées — l'index `@@index([workspaceId, priorityOrder])` aide les requêtes triées - **NFR14** : isolation workspace — `updateOrder` vérifie `workspace.ownerId === ctx.session.user.id` pour chaque mutation - **NFR2** : feedback visuel immédiat (< 1s) — garanti par optimistic update ### Apprentissages de la story précédente (4.2) **Tests Vitest — commande PowerShell :** ```powershell cd "c:\Users\USER\Documents\Intersel - Livinweb\dev\AImpact-Ai_Hub\aimpact-hub"; pnpm vitest run --reporter=verbose 2>&1 | Select-Object -First 150 ``` **Pattern mock tRPC pour composants :** ```typescript vi.mock("~/trpc/react", () => ({ api: { idea: { updateOrder: { useMutation: vi.fn() }, getBacklog: { useQuery: vi.fn() }, }, }, })); ``` **Pattern mock Prisma pour tests serveur (`$transaction`) :** ```typescript vi.mock("~/server/db", () => ({ db: { workspace: { findUnique: vi.fn() }, idea: { update: vi.fn() }, $transaction: vi.fn().mockResolvedValue([]), }, })); ``` **Note sur `$transaction` avec array** : `ctx.db.$transaction([...updates])` passe un array de Promises Prisma. Dans les tests, mocker `$transaction` pour retourner un array vide ou des résultats simulés. ### References - [Source: epics.md#Story 4.3 — Drag & drop priorisation (FR33, FR34)] - [Source: epics.md#FR33 — Le Transformateur peut réordonner les idées par drag & drop dans le backlog] - [Source: epics.md#FR34 — Le Transformateur peut voir le classement de priorité résultant de ses ajustements] - [Source: architecture.md#Frontend Architecture — Drag & drop | dnd-kit | Kanban] - [Source: architecture.md#Architecture Boundaries — Priorisation (FR33–FR34) : components/backlog/KanbanBoard.tsx, ideaRouter.updateOrder] - [Source: architecture.md#Implementation Patterns — Multi-tenant, protectedProcedure, NFR14] - [Source: architecture.md#Process Patterns — Optimistic update, React Query utils.idea.invalidate()] - [Source: prisma/schema.prisma — model Idea, champ priorityOrder Int? (ligne 143-144)] - [Source: implementation-artifacts/3-2-vue-liste-du-backlog-fr22-fr24.md — BacklogListView, getBacklog, BacklogFilters, IdeaRow, sortBy patterns] - [Source: implementation-artifacts/3-3-vue-kanban-4-colonnes-fr23.md — KanbanBoard, KanbanColumn, KanbanCard, KANBAN_COLUMNS, groupByStatus] - [Source: implementation-artifacts/4-2-reponse-du-contributeur-a-la-question-fr31.md — patterns tRPC, tests Vitest, fire-and-forget, mock $transaction] - [Source: npm @dnd-kit/sortable v10.0.0 — latest stable (décembre 2024), @dnd-kit/core ^6.3.0 peer dependency] ## Dev Agent Record ### Agent Model Used {{agent_model_name_version}} ### Debug Log References ### Completion Notes List ### File List - aimpact-hub/package.json (modifié — dnd-kit) - aimpact-hub/prisma/schema.prisma (modifié — index priorityOrder) - aimpact-hub/prisma/migrations/20260302093418_add_priority_order_index/migration.sql (créé) - aimpact-hub/src/server/api/routers/idea.ts (modifié — updateOrder, getBacklog priority) - aimpact-hub/src/components/backlog/BacklogListView.tsx (modifié — DndContext, SortableContext, reset erreur) - aimpact-hub/src/components/backlog/IdeaRow.tsx (modifié — handle, colonne Priorité, spacer DragOverlay) - aimpact-hub/src/components/backlog/KanbanBoard.tsx (modifié — updateOrder, optimistic, reset erreur) - aimpact-hub/src/components/backlog/KanbanColumn.tsx (modifié — SortableContext cartes) - aimpact-hub/src/components/backlog/KanbanCard.tsx (modifié — useSortable au lieu de useDraggable) - aimpact-hub/src/server/api/routers/idea.updateOrder.test.ts (créé) - aimpact-hub/src/components/backlog/BacklogListView.dragdrop.test.tsx (créé — tests F–J) - aimpact-hub/src/components/backlog/KanbanBoard.dragdrop.test.tsx (créé — tests render + K–M) - aimpact-hub/src/server/api/routers/idea.getBacklog.test.ts (modifié — tests N, O) - aimpact-hub/src/components/backlog/KanbanBoard.test.tsx (modifié — mock updateOrder) ### Completion Notes List - Procédure tRPC `idea.updateOrder` ajoutée avec vérification ownership et multi-tenant - Index Prisma `@@index([workspaceId, priorityOrder])` créé - Vue liste : DndContext + SortableContext + handle GripVertical + colonne Priorité + tri par priorité - Vue kanban : updateOrder remplace updateStatus, optimistic update, cross-column + within-column - Tests : idea.updateOrder (5 + payloads vérifiés), getBacklog (N, O), BacklogListView.dragdrop (F–J), KanbanBoard.dragdrop (render + K–M), KanbanBoard mocks mis à jour **Corrections code review (2026-03-02) :** - C1 `KanbanCard.tsx` : `useDraggable` → `useSortable` (AC #4 — drag intra-colonne corrigé, insère à la bonne position) - C1 `KanbanColumn.tsx` : ajout `SortableContext` autour des cartes (nécessaire pour l'algorithme de tri intra-colonne) - C2 `BacklogListView.dragdrop.test.tsx` : ajout Tests H (orderedIds corrects), I (pas de mutation si même id), J (restauration sur erreur) + mock dnd-kit complet - C3 `KanbanBoard.dragdrop.test.tsx` : ajout Tests K (intra-colonne sans newStatus), L (cross-column avec newStatus+movedIdeaId), M (restauration sur erreur) + mock dnd-kit complet - C4 `idea.updateOrder.test.ts` : Test B vérifie maintenant les 3 payloads `priorityOrder: 1/2/3` explicitement - H1 `IdeaRow.tsx` : cellule spacer `aria-hidden` dans DragOverlay pour aligner les 9 colonnes du tableau - H2 Subtask 4.9 : l'option "Priorité" est accessible via le clic sur l'entête de colonne dans BacklogListView (solution équivalente, pas via BacklogFilters.tsx) - L1 `BacklogListView.tsx` + `KanbanBoard.tsx` : `updateOrder.reset()` appelé dans `onDragStart` pour effacer le bandeau d'erreur au prochain drag