4-3-drag-drop-priorisation-fr33-fr34.md 31 KB

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/ :

      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 :

      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)

    • 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 :

      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 :

      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) :

      const [localIdeas, setLocalIdeas] = useState(data ?? []);
      const [activeId, setActiveId] = useState<string | null>(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) :

      const sensors = useSensors(
      useSensor(PointerSensor, {
      activationConstraint: { distance: 5 },
      })
      );
      
    • [x] Subtask 4.4 : Implémenter handleDragEnd :

      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 <DndContext> + <SortableContext> :

      <DndContext
      sensors={sensors}
      collisionDetection={closestCenter}
      onDragStart={(e) => setActiveId(e.active.id as string)}
      onDragEnd={handleDragEnd}
      >
      <SortableContext
      items={localIdeas.map((i) => i.id)}
      strategy={verticalListSortingStrategy}
      >
      {/* tableau des lignes IdeaRow */}
      </SortableContext>
      <DragOverlay>
      {activeId && (
        <IdeaRow
          idea={localIdeas.find((i) => i.id === activeId)!}
          workspaceId={workspaceId}
          isDragOverlay
        />
      )}
      </DragOverlay>
      </DndContext>
      
    • [x] Subtask 4.6 : Créer composant wrapper SortableIdeaRow qui enveloppe IdeaRow avec useSortable :

      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 (
      <div ref={setNodeRef} style={style}>
        <IdeaRow
          idea={idea}
          workspaceId={workspaceId}
          dragHandleProps={{ ...attributes, ...listeners }}
        />
      </div>
      );
      }
      
    • [x] Subtask 4.7 : Mettre à jour IdeaRow.tsx pour afficher le handle de drag :

    • Ajouter prop optionnelle dragHandleProps?: React.HTMLAttributes<HTMLDivElement> et isDragOverlay?: boolean

    • Afficher <div className="cursor-grab touch-none" {...dragHandleProps}><GripVertical className="h-4 w-4 text-muted-foreground" /></div> 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)

    • Subtask 5.1 : Ajouter les imports dnd-kit dans src/components/backlog/KanbanBoard.tsx (idem Task 4.1)
    • Subtask 5.2 : Ajouter état local localIdeas (copie optimiste) et activeId avec sync via useEffect (idem Task 4.2)
    • Subtask 5.3 : Configurer les sensors PointerSensor (distance: 5) — idem Task 4.3
    • [x] Subtask 5.4 : Implémenter handleDragEnd pour le kanban :

      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 <DndContext> + un <SortableContext> global par colonne :

      <DndContext sensors={sensors} collisionDetection={closestCenter}
      onDragStart={(e) => setActiveId(e.active.id as string)}
      onDragEnd={handleDragEnd}
      >
      <div className="grid grid-cols-4 gap-4">
      {KANBAN_COLUMNS.map((col) => (
        <KanbanColumn
          key={col.status}
          {...col}
          ideas={localIdeas.filter((i) => i.status === col.status)}
          workspaceId={workspaceId}
        />
      ))}
      </div>
      <DragOverlay>
      {activeId && (
        <KanbanCard
          idea={localIdeas.find((i) => i.id === activeId)!}
          workspaceId={workspaceId}
          isDragOverlay
        />
      )}
      </DragOverlay>
      </DndContext>
      
    • [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 <SortableContext items={ideas.map(i => 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 <GripVertical> 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 :

      const updateOrder = api.idea.updateOrder.useMutation({
      onError: () => {
      if (data) setLocalIdeas(data); // restaurer
      // afficher toast ou message inline
      },
      });
      
  • [x] Task 6 : Tests (AC: #1–#8)

    • 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)
    • 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
    • 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)
    • 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

// 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é)

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é :

// 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

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é.

<DragOverlay dropAnimation={null}> {/* dropAnimation: null pour éviter flash */}
  {activeId && <KanbanCard idea={...} workspaceId={workspaceId} isDragOverlay />}
</DragOverlay>

KanbanCard — handle drag vs clic navigation

Le composant KanbanCard est actuellement un <Link> cliquable. Avec dnd-kit, les listeners du drag capturent les événements pointer. La solution :

// Dans KanbanCard.tsx
const { attributes, listeners, setNodeRef, ... } = useSortable({ id: idea.id });

// Appliquer listeners UNIQUEMENT sur le handle, pas sur toute la carte
return (
  <div ref={setNodeRef} style={style}>
    <div {...listeners} {...attributes} className="cursor-grab"> {/* handle */}
      <GripVertical />
    </div>
    <Link href={...}> {/* reste de la carte — cliquable normalement */}
      ...
    </Link>
  </div>
);

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 :

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 :

vi.mock("~/trpc/react", () => ({
  api: {
    idea: {
      updateOrder: { useMutation: vi.fn() },
      getBacklog: { useQuery: vi.fn() },
    },
  },
}));

Pattern mock Prisma pour tests serveur ($transaction) :

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