4-6-suppression-didees-et-donnees-contributeurs-fr38.md 31 KB

Story 4.6 : Suppression d'idées et données contributeurs (FR38)

Status: done

Story

En tant que Transformateur, je veux supprimer des idées et des données contributeurs sur demande, afin de respecter les droits RGPD (droit à l'effacement).

Acceptance Criteria

  1. Given un contributeur ou une autorité demande la suppression d'une idée spécifique When le Transformateur clique "Supprimer cette idée" depuis la fiche détail et confirme dans la modale Then l'idée est supprimée définitivement de la base de données And toutes les pièces jointes associées sont supprimées de Vercel Blob et de la base de données (via Cascade) And les questions de qualification associées sont supprimées (via Cascade)

  2. Given un contributeur ou une autorité demande la suppression de ses données personnelles (RGPD — droit à l'effacement) When le Transformateur clique "Supprimer le contributeur et ses données" depuis la liste des contributeurs et confirme Then toutes les idées soumises par ce contributeur (identifiées par contributorEmail) sont supprimées définitivement And toutes leurs pièces jointes sont supprimées de Vercel Blob et de la base de données And le contributeur est supprimé de la base de données

  3. Given le contributeur à supprimer était le seul dont les idées sont visibles sur le lien partageable actif (i.e. : toutes les idées avec status ≠ NOT_PRIORITY dans le workspace appartiennent à ce contributeur) When la suppression du contributeur est confirmée Then le ShareLink actif du workspace est supprimé (révocation du lien partageable)

  4. Given une suppression de pièces jointes échoue côté Vercel Blob (erreur réseau ou token absent) When l'erreur est interceptée Then la suppression en base de données est maintenue (non-blocage — le RGPD est satisfait) And l'erreur est loggée côté serveur avec console.error And aucune erreur n'est propagée à l'utilisateur pour les échecs blob (toast de succès quand même)

  5. Given le Transformateur est sur la fiche détail d'une idée When il clique le bouton "Supprimer" (destructif, fond #fef2f2, texte #dc2626) Then une modale de confirmation s'affiche avec le titre de l'idée (ou les 60 premiers caractères de problemDescription) And le bouton de confirmation indique "Supprimer définitivement" (jamais "OK") And un avertissement mentionne "Cette action est irréversible. Les pièces jointes seront supprimées."

  6. Given le Transformateur est sur la liste des contributeurs When il clique "Supprimer" sur une ligne de contributeur Then une modale de confirmation affiche l'email du contributeur et le nombre d'idées qui seront supprimées And le bouton de confirmation indique "Supprimer le contributeur et ses X idée(s)" And un avertissement mentionne la conséquence RGPD et l'irréversibilité de l'action

Tasks / Subtasks

  • [x] Task 1 : Ajouter deleteAttachments dans storage.ts (AC: #1, #2, #4)

    • [x] Subtask 1.1 : Dans src/server/services/storage.ts, ajouter la fonction de suppression blob :

      import { del } from "@vercel/blob";
      
      /**
      * Supprime des fichiers de Vercel Blob. Silencieux en mode dev (BLOB_READ_WRITE_TOKEN absent).
      * En cas d'erreur, logge et ne propage pas — la suppression DB est prioritaire (RGPD).
      */
      export async function deleteAttachments(blobPaths: string[]): Promise<void> {
      if (blobPaths.length === 0) return;
      
      const token = process.env.BLOB_READ_WRITE_TOKEN;
      if (!token) {
      console.log("[storage] BLOB_READ_WRITE_TOKEN absent — mode dev, skip blob delete:", blobPaths);
      return;
      }
      
      try {
      await del(blobPaths, { token });
      } catch (error) {
      console.error("[storage] Échec suppression blobs:", blobPaths, error);
      // Ne pas propager — la suppression DB doit continuer
      }
      }
      
    • [x] Subtask 1.2 : Vérifier que @vercel/blob exporte bien del (déjà installé via Story 2.6)

      grep -r "from '@vercel/blob'" "c:\Users\USER\Documents\Intersel - Livinweb\dev\AImpact-Ai_Hub\aimpact-hub\src"
      

      La fonction del est exportée par @vercel/blob — même package que put utilisé dans uploadAttachment.

  • [x] Task 2 : Ajouter deleteIdea dans idea.ts (AC: #1, #4, #5)

    • [x] Subtask 2.1 : Dans src/server/api/routers/idea.ts, ajouter la procédure deleteIdea :

      deleteIdea: createWorkspaceProcedure
      .input(z.object({ ideaId: z.string().cuid() }))
      .mutation(async ({ ctx, input }) => {
      // Vérifier que l'idée appartient au workspace (multi-tenant)
      const idea = await db.idea.findFirst({
        where: { id: input.ideaId, workspaceId: ctx.workspace.id },
        select: {
          id: true,
          attachments: { select: { blobPath: true } },
        },
      });
      
      if (!idea) {
        throw new TRPCError({ code: "NOT_FOUND", message: "Idée introuvable" });
      }
      
      // Supprimer les blobs avant la DB (silencieux si erreur — voir AC #4)
      const blobPaths = idea.attachments.map((a) => a.blobPath);
      await deleteAttachments(blobPaths);
      
      // Supprimer l'idée — Cascade DB : IdeaAttachment[], QualificationQuestion[]
      await db.idea.delete({ where: { id: idea.id } });
      
      return { success: true };
      }),
      
    • [x] Subtask 2.2 : Ajouter l'import deleteAttachments depuis ~/server/services/storage en haut de idea.ts

    • [x] Subtask 2.3 : Ajouter l'import createWorkspaceProcedure s'il n'est pas déjà présent (il l'est déjà dans idea.ts — vérifier)

  • [x] Task 3 : Ajouter deleteContributor dans contributor.ts (AC: #2, #3, #4)

    • [x] Subtask 3.1 : Dans src/server/api/routers/contributor.ts, ajouter la procédure deleteContributor :

      deleteContributor: createWorkspaceProcedure
      .input(z.object({ contributorId: z.string().cuid() }))
      .mutation(async ({ ctx, input }) => {
      const workspaceId = ctx.workspace.id;
      
      // Vérifier que le contributeur appartient au workspace
      const contributor = await db.contributor.findFirst({
        where: { id: input.contributorId, workspaceId },
        select: { id: true, email: true },
      });
      
      if (!contributor) {
        throw new TRPCError({ code: "NOT_FOUND", message: "Contributeur introuvable" });
      }
      
      // Charger toutes les idées du contributeur (par email — source de vérité RGPD)
      const ideas = await db.idea.findMany({
        where: { workspaceId, contributorEmail: contributor.email },
        select: {
          id: true,
          status: true,
          attachments: { select: { blobPath: true } },
        },
      });
      
      // AC #3 : vérifier si ce contributeur est le seul visible sur le lien partageable
      const totalVisible = await db.idea.count({
        where: { workspaceId, status: { not: "NOT_PRIORITY" } },
      });
      const contributorVisible = ideas.filter(
        (i) => i.status !== "NOT_PRIORITY"
      ).length;
      const shouldRevokeShareLink =
        totalVisible > 0 && totalVisible === contributorVisible;
      
      // Supprimer les blobs de toutes les pièces jointes
      const allBlobPaths = ideas.flatMap((i) => i.attachments.map((a) => a.blobPath));
      await deleteAttachments(allBlobPaths);
      
      // Supprimer les idées (Cascade : IdeaAttachment[], QualificationQuestion[])
      await db.idea.deleteMany({
        where: { workspaceId, contributorEmail: contributor.email },
      });
      
      // Révoquer le lien partageable si applicable (AC #3)
      if (shouldRevokeShareLink) {
        await db.shareLink.deleteMany({ where: { workspaceId } });
      }
      
      // Supprimer le contributeur (les idées ont déjà été supprimées — pas de SetNull orphelin)
      await db.contributor.delete({ where: { id: contributor.id } });
      
      return { success: true, ideasDeleted: ideas.length, shareLinkRevoked: shouldRevokeShareLink };
      }),
      
    • [x] Subtask 3.2 : Ajouter l'import deleteAttachments depuis ~/server/services/storage en haut de contributor.ts

    • [x] Subtask 3.3 : Ajouter l'import db si non présent (déjà présent dans contributor.ts)

  • [x] Task 4 : Composant DeleteIdeaButton.tsx (AC: #5)

    • [x] Subtask 4.1 : Créer src/components/idea/DeleteIdeaButton.tsx (Client Component) :

      "use client";
      import { useState } from "react";
      import { Trash2, Loader2 } from "lucide-react";
      import { useRouter } from "next/navigation";
      import { Button } from "~/components/ui/button";
      import {
      Dialog,
      DialogContent,
      DialogDescription,
      DialogFooter,
      DialogHeader,
      DialogTitle,
      DialogTrigger,
      } from "~/components/ui/dialog";
      import { toast } from "sonner";
      import { api } from "~/trpc/react";
      
      interface DeleteIdeaButtonProps {
      workspaceId: string;
      ideaId: string;
      ideaTitle: string; // llmTitle ou problemDescription.slice(0, 60)
      }
      
      export function DeleteIdeaButton({ workspaceId, ideaId, ideaTitle }: DeleteIdeaButtonProps) {
      const [open, setOpen] = useState(false);
      const router = useRouter();
      
      const deleteIdea = api.idea.deleteIdea.useMutation({
      onSuccess: () => {
        setOpen(false);
        toast.success("Idée supprimée définitivement");
        router.push(`/workspace/${workspaceId}/backlog`);
        router.refresh();
      },
      onError: () => toast.error("Impossible de supprimer l'idée. Réessayez."),
      });
      
      return (
      <Dialog open={open} onOpenChange={setOpen}>
        <DialogTrigger asChild>
          <Button
            variant="ghost"
            size="sm"
            className="text-[#dc2626] hover:bg-[#fef2f2] hover:text-[#dc2626]"
          >
            <Trash2 className="mr-2 h-4 w-4" />
            Supprimer
          </Button>
        </DialogTrigger>
        <DialogContent>
          <DialogHeader>
            <DialogTitle>Supprimer cette idée ?</DialogTitle>
            <DialogDescription>
              <strong>"{ideaTitle}"</strong>
              <br />
              Cette action est irréversible. L'idée, ses pièces jointes et ses
              questions de qualification seront supprimées définitivement.
            </DialogDescription>
          </DialogHeader>
          <DialogFooter>
            <Button variant="outline" onClick={() => setOpen(false)}>
              Annuler
            </Button>
            <Button
              className="bg-[#dc2626] hover:bg-[#b91c1c] text-white"
              onClick={() => deleteIdea.mutate({ workspaceId, ideaId })}
              disabled={deleteIdea.isPending}
            >
              {deleteIdea.isPending ? (
                <Loader2 className="mr-2 h-4 w-4 animate-spin" />
              ) : (
                <Trash2 className="mr-2 h-4 w-4" />
              )}
              Supprimer définitivement
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>
      );
      }
      
    • [x] Subtask 4.2 : Vérifier que Dialog de shadcn/ui est installé dans ~/components/ui/dialog.tsx (utilisé par Story 4.x)

  • [x] Task 5 : Composant DeleteContributorButton.tsx (AC: #6)

    • [x] Subtask 5.1 : Créer src/components/workspace/DeleteContributorButton.tsx (Client Component) :

      "use client";
      import { useState } from "react";
      import { Trash2, Loader2 } from "lucide-react";
      import { Button } from "~/components/ui/button";
      import {
      Dialog,
      DialogContent,
      DialogDescription,
      DialogFooter,
      DialogHeader,
      DialogTitle,
      DialogTrigger,
      } from "~/components/ui/dialog";
      import { toast } from "sonner";
      import { api } from "~/trpc/react";
      
      interface DeleteContributorButtonProps {
      workspaceId: string;
      contributorId: string;
      contributorEmail: string;
      ideasCount: number; // _count.ideas passé depuis la liste (Story 2.9)
      }
      
      export function DeleteContributorButton({
      workspaceId,
      contributorId,
      contributorEmail,
      ideasCount,
      }: DeleteContributorButtonProps) {
      const [open, setOpen] = useState(false);
      const utils = api.useUtils();
      
      const deleteContributor = api.contributor.deleteContributor.useMutation({
      onSuccess: (data) => {
        setOpen(false);
        const revokeMsg = data.shareLinkRevoked ? " Le lien partageable a été révoqué." : "";
        toast.success(
          `Contributeur supprimé. ${data.ideasDeleted} idée(s) supprimée(s).${revokeMsg}`
        );
        void utils.contributor.list.invalidate({ workspaceId });
      },
      onError: () => toast.error("Impossible de supprimer le contributeur. Réessayez."),
      });
      
      return (
      <Dialog open={open} onOpenChange={setOpen}>
        <DialogTrigger asChild>
          <Button
            variant="ghost"
            size="sm"
            className="text-[#dc2626] hover:bg-[#fef2f2] hover:text-[#dc2626]"
          >
            <Trash2 className="h-4 w-4" />
          </Button>
        </DialogTrigger>
        <DialogContent>
          <DialogHeader>
            <DialogTitle>Supprimer ce contributeur ?</DialogTitle>
            <DialogDescription>
              <strong>{contributorEmail}</strong>
              <br />
              Cette action est irréversible (RGPD — droit à l'effacement).
              <br />
              <strong>{ideasCount} idée(s)</strong> et leurs pièces jointes seront
              supprimées définitivement.
            </DialogDescription>
          </DialogHeader>
          <DialogFooter>
            <Button variant="outline" onClick={() => setOpen(false)}>
              Annuler
            </Button>
            <Button
              className="bg-[#dc2626] hover:bg-[#b91c1c] text-white"
              onClick={() =>
                deleteContributor.mutate({ workspaceId, contributorId })
              }
              disabled={deleteContributor.isPending}
            >
              {deleteContributor.isPending ? (
                <Loader2 className="mr-2 h-4 w-4 animate-spin" />
              ) : (
                <Trash2 className="mr-2 h-4 w-4" />
              )}
              Supprimer le contributeur et ses {ideasCount} idée(s)
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>
      );
      }
      
  • [x] Task 6 : Intégration dans la fiche détail d'idée (AC: #5)

    • Subtask 6.1 : Dans src/app/(dashboard)/workspace/[workspaceId]/ideas/[ideaId]/page.tsx :
    • Importer DeleteIdeaButton depuis ~/components/idea/DeleteIdeaButton
    • Ajouter <DeleteIdeaButton workspaceId={workspaceId} ideaId={ideaId} ideaTitle={idea.llmTitle ?? idea.problemDescription.slice(0, 60) + "…"} /> dans la zone d'actions de la fiche (en bas ou dans la barre d'actions)
    • Positionner dans la zone destructive (séparée des actions principales par un <Separator /> ou dans un menu "Plus d'actions")
    • [x] Subtask 6.2 : Vérifier le pattern params Next.js 15 pour ideaId :

      // ✅ Next.js 15 — params est une Promise
      const { workspaceId, ideaId } = await params;
      
  • [x] Task 7 : Intégration dans la liste des contributeurs (AC: #6)

    • Subtask 7.1 : Dans src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx :
    • Importer DeleteContributorButton depuis ~/components/workspace/DeleteContributorButton
    • Ajouter <DeleteContributorButton workspaceId={workspaceId} contributorId={c.id} contributorEmail={c.email} ideasCount={c._count.ideas} /> sur chaque ligne de la liste
    • La donnée c._count.ideas est déjà disponible via le contributor.list query (Story 2.9 — inclut _count.ideas)
  • [x] Task 8 : Tests (AC: tous)

    • Subtask 8.1 : Ajouter des tests pour deleteIdea dans src/server/api/routers/idea.test.ts (ou créer le fichier s'il n'existe pas) :
    • Mock ~/server/db et ~/server/services/storage
    • Test A : deleteIdea — idea trouvée + blobs supprimés + idea supprimée → { success: true }
    • Test B : deleteIdea — idea non trouvée → erreur NOT_FOUND
    • Test C : deleteIdea — erreur blob silencieuse → suppression DB maintenue quand même
    • Test D : deleteIdea — workspace mismatch → erreur NOT_FOUND (isolation multi-tenant)
    • Subtask 8.2 : Ajouter des tests pour deleteContributor dans src/server/api/routers/contributor.test.ts (ou créer si inexistant) :
    • Mock ~/server/db et ~/server/services/storage
    • Test E : deleteContributor — contributeur + 2 idées supprimés + blobs supprimés → { success: true, ideasDeleted: 2, shareLinkRevoked: false }
    • Test F : deleteContributor — seul contributeur visible → shareLinkRevoked: true + db.shareLink.deleteMany appelé
    • Test G : deleteContributor — contributeur non trouvé → erreur NOT_FOUND
    • Test H : deleteContributor — 0 idées → ideasDeleted: 0, pas d'appel à deleteAttachments
    • Subtask 8.3 : Créer src/components/idea/DeleteIdeaButton.test.tsx :
    • Mock ~/trpc/react avec api.idea.deleteIdea.useMutation
    • Test I : rendu du bouton "Supprimer" → Dialog fermé initialement
    • Test J : clic "Supprimer" → Dialog ouvert avec titre de l'idée
    • Test K : clic "Supprimer définitivement" → deleteIdea.mutate appelé avec { workspaceId, ideaId }
    • Test L : clic "Annuler" → Dialog fermé, pas de mutation
    • Subtask 8.4 : Créer src/components/workspace/DeleteContributorButton.test.tsx :
    • Mock ~/trpc/react
    • Test M : Dialog affiche email + nombre d'idées
    • Test N : clic confirmer → deleteContributor.mutate appelé
    • Test O : succès avec shareLinkRevoked: true → toast mentionne la révocation

Dev Notes

Contexte RGPD — FR38

FR38 est volontairement minimal dans le PRD : "Le Transformateur peut supprimer des idées et des données contributeurs sur demande". Le PRD précise explicitement "traitable manuellement en MVP". Cette story implémente une UI dédiée pour que le Transformateur puisse effectuer ces suppressions facilement depuis l'interface.

Données personnelles concernées : contributorEmail (sur Idea et Contributor), contenu libre (problemDescription), pièces jointes.

Architecture de la suppression

Idée seule (deleteIdea) :

deleteIdea(ideaId)
  → db.idea.findFirst({ attachments })         — vérif workspace + récup blobPaths
  → deleteAttachments([blobPath1, blobPath2])  — Vercel Blob (silencieux si erreur)
  → db.idea.delete(ideaId)                     — Cascade: IdeaAttachment[], QualificationQuestion[]

Contributeur + données (deleteContributor) :

deleteContributor(contributorId)
  → db.contributor.findFirst                   — vérif workspace + récup email
  → db.idea.findMany({ contributorEmail })     — toutes les idées par email (RGPD)
  → checkShareLinkRevocation()                 — AC #3 (compter idées visibles)
  → deleteAttachments(allBlobPaths)            — Vercel Blob (silencieux si erreur)
  → db.idea.deleteMany({ contributorEmail })   — Cascade IdeaAttachment[], QualificationQuestion[]
  → db.shareLink.deleteMany({ workspaceId })   — si révocation applicable
  → db.contributor.delete(contributorId)       — supprimer le contributeur

Schéma actuel — points critiques

Idea.contributorId → onDelete: SetNull : Si on supprime le Contributor directement sans supprimer ses idées d'abord, les idées persistent avec contributorId = null mais contributorEmail toujours présent. Pour le RGPD, il faut supprimer les idées AVANT de supprimer le contributeur — c'est ce que fait la procédure deleteContributor ci-dessus (via deleteMany par email, puis contributor.delete).

ShareLink.workspaceId @unique : Il n'y a PAS de champ isActive dans le schéma actuel. La révocation du lien = suppression du record ShareLink avec db.shareLink.deleteMany({ where: { workspaceId } }). Ce schéma diffère de ce qui était décrit dans les tâches de Story 4.5 (qui mentionnait isActive) — la migration finale a utilisé @unique workspaceId à la place. Ne pas ajouter isActive — utiliser la suppression du record.

IdeaAttachment.blobPath : Convention stockage définie en Story 2.6 : {workspaceId}/attachments/{ideaId}/{filename}. C'est ce champ qui est passé à deleteAttachments().

Fonction deleteAttachments — détails @vercel/blob

La fonction del de @vercel/blob accepte un seul path ou un tableau :

import { del } from "@vercel/blob";
await del(blobPaths); // string[] supporté en batch

Le package est déjà installé (Story 2.6 utilise put). Pas de nouvelle dépendance à ajouter.

Mode dev sans BLOB_READ_WRITE_TOKEN : retourner sans erreur (même comportement que uploadAttachment existant).

Condition de révocation du lien partageable (AC #3)

// Avant suppression des idées :
const totalVisible = await db.idea.count({
  where: { workspaceId, status: { not: "NOT_PRIORITY" } },
});
const contributorVisible = ideas.filter(
  (i) => i.status !== "NOT_PRIORITY"
).length;
const shouldRevokeShareLink = totalVisible > 0 && totalVisible === contributorVisible;

Cas couverts :

  • Workspace avec 1 seul contributeur et toutes ses idées visibles → révocation ✓
  • Workspace avec plusieurs contributeurs → pas de révocation ✓
  • Workspace dont toutes les idées sont NOT_PRIORITY → totalVisible = 0 → pas de révocation ✓ (edge case : le share link ne montrerait rien de toute façon)

Pattern createWorkspaceProcedure — sécurité multi-tenant

Utiliser exclusivement createWorkspaceProcedure pour toutes les procédures de suppression. Ce pattern, défini en Story 1.2 et utilisé dans tous les routers existants, injecte ctx.workspace après vérification que l'utilisateur est propriétaire du workspace. Ne pas utiliser protectedProcedure seul — risque de fuite multi-tenant.

// ✅ Correct — isolation multi-tenant garantie
deleteIdea: createWorkspaceProcedure
  .input(z.object({ workspaceId: z.string().cuid(), ideaId: z.string().cuid() }))
  .mutation(async ({ ctx, input }) => {
    // ctx.workspace est déjà vérifié — workspaceId = ctx.workspace.id
    const idea = await db.idea.findFirst({
      where: { id: input.ideaId, workspaceId: ctx.workspace.id },
      // ...
    });
    // ...
  });

// ❌ Anti-pattern — pas d'isolation workspace
deleteIdea: protectedProcedure
  .mutation(async ({ ctx, input }) => {
    await db.idea.delete({ where: { id: input.ideaId } }); // fuite multi-tenant
  });

Gestion des erreurs — hiérarchie blob vs DB

Priorité DB sur Blob : En cas d'erreur de suppression Vercel Blob, le droit RGPD à l'effacement est satisfait par la suppression en base de données. Les blobs orphelins peuvent être nettoyés manuellement. Ne jamais faire échouer la mutation tRPC à cause d'une erreur blob.

// ✅ Correct — blob silencieux
try {
  await del(blobPaths);
} catch (error) {
  console.error("[storage] Échec suppression blobs:", error);
  // continuer la suppression DB
}

// ❌ Anti-pattern — blob bloque le RGPD
await del(blobPaths); // si ça throw, la mutation échoue → données non supprimées

Intégration UI — pages existantes

Fiche détail d'idée : La page src/app/(dashboard)/workspace/[workspaceId]/ideas/[ideaId]/page.tsx a été créée en Story 3.4. Vérifier sa structure avant d'y intégrer le bouton. Le bouton "Supprimer" doit être clairement séparé des actions principales (édition des scores, changement de statut). Proposition : dans un menu déroulant "Actions" ou en bas de page avec séparateur.

Liste des contributeurs : La page src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx a été créée en Story 2.9 (FR9). La query contributor.list inclut déjà _count.ideas — utiliser cette valeur pour afficher le nombre d'idées dans la modale de confirmation.

Pattern UI — bouton destructif (UX Spec)

Couleurs imposées par le design system Livinia Chaleureux :

// Bouton déclencheur (discret)
className="text-[#dc2626] hover:bg-[#fef2f2] hover:text-[#dc2626]"

// Bouton de confirmation dans la modale (clair)
className="bg-[#dc2626] hover:bg-[#b91c1c] text-white"

Libellé du bouton de confirmation = action exacte (jamais "OK" — règle UX Spec) :

  • Idée : "Supprimer définitivement"
  • Contributeur : "Supprimer le contributeur et ses X idée(s)"

Pattern params Next.js 15

Tous les segments dynamiques sont des Promise en Next.js 15 :

// ✅ Correct (déjà établi dans tous les pages du projet)
const { workspaceId, ideaId } = await params;

Vérifier le pattern dans src/app/(dashboard)/workspace/[workspaceId]/ideas/[ideaId]/page.tsx avant modification.

Apprentissages des stories précédentes

Story 4.5 (Share Link) :

  • Pattern mock tRPC pour les tests :

    vi.mock("~/trpc/react", () => ({
    api: {
      idea: { deleteIdea: { useMutation: vi.fn() } },
      contributor: { deleteContributor: { useMutation: vi.fn() } },
      useUtils: () => ({ contributor: { list: { invalidate: vi.fn() } } }),
    },
    }));
    
  • Pattern mock DB pour les tests router :

    vi.mock("~/server/db", () => ({
    db: {
      idea: { findFirst: vi.fn(), findMany: vi.fn(), delete: vi.fn(), deleteMany: vi.fn(), count: vi.fn() },
      contributor: { findFirst: vi.fn(), delete: vi.fn() },
      shareLink: { deleteMany: vi.fn() },
    },
    }));
    vi.mock("~/server/services/storage", () => ({
    deleteAttachments: vi.fn().mockResolvedValue(undefined),
    }));
    

Story 2.9 (Liste contributeurs) : contributor.list renvoie _count.ideas — utiliser ce champ dans DeleteContributorButton sans refetch.

Story 3.4 (Fiche détail idée) : Vérifier la structure de la page avant intégration — ne pas casser les fonctionnalités existantes (scores, statuts, questions de qualification).

Tests — 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

Structure des fichiers

Fichier Action Notes
src/server/services/storage.ts Modifier — ajouter deleteAttachments(blobPaths) Import del de @vercel/blob
src/server/api/routers/idea.ts Modifier — ajouter procédure deleteIdea Utilise createWorkspaceProcedure
src/server/api/routers/contributor.ts Modifier — ajouter procédure deleteContributor Supprime idées par email puis contributeur
src/components/idea/DeleteIdeaButton.tsx Créer — Dialog de confirmation suppression idée "use client", Dialog shadcn/ui
src/components/workspace/DeleteContributorButton.tsx Créer — Dialog de confirmation suppression contributeur "use client", affiche nombre d'idées
src/app/(dashboard)/workspace/[workspaceId]/ideas/[ideaId]/page.tsx Modifier — intégrer DeleteIdeaButton Zone actions destructives
src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx Modifier — intégrer DeleteContributorButton par ligne Utilise _count.ideas existant
src/server/api/routers/idea.test.ts Créer ou modifier — tests A–D pour deleteIdea Mock db + storage
src/server/api/routers/contributor.test.ts Créer ou modifier — tests E–H pour deleteContributor Mock db + storage, vérif shareLinkRevoked
src/components/idea/DeleteIdeaButton.test.tsx Créer — tests I–L Mock tRPC
src/components/workspace/DeleteContributorButton.test.tsx Créer — tests M–O Mock tRPC

Références

  • [Source: epics.md#Story 4.6 — Suppression d'idées et données contributeurs (FR38)]
  • [Source: prd.md#FR38 — Le Transformateur peut supprimer des idées et des données contributeurs sur demande]
  • [Source: prd.md#Conformité RGPD — Droits utilisateurs — "traitable manuellement en MVP"]
  • [Source: architecture.md#Implementation Patterns — Multi-tenant, createWorkspaceProcedure sur toutes les procédures]
  • [Source: architecture.md#Error Handling — tRPC: throw new TRPCError; jamais erreur brute exposée]
  • [Source: ux-design-specification.md#UX Consistency Patterns — Bouton Destructif: fond #fef2f2, texte #dc2626, confirmation obligatoire]
  • [Source: ux-design-specification.md#Form Patterns — Modale pour suppression ; libellé = action exacte, jamais "OK"]
  • [Source: prisma/schema.prisma — Idea.contributorId onDelete: SetNull; IdeaAttachment.blobPath; ShareLink.workspaceId @unique]
  • [Source: src/server/services/storage.ts — pattern uploadAttachment, BLOB_READ_WRITE_TOKEN guard, convention blobPath]
  • [Source: src/server/api/routers/contributor.ts — createWorkspaceProcedure, db import, pattern existant]
  • [Source: src/server/api/routers/idea.ts — createWorkspaceProcedure, db import, pattern existant]
  • [Source: implementation-artifacts/4-5-lien-partageable-lecture-seule-fr36.md — pattern mock tRPC pour tests]
  • [Source: implementation-artifacts/2-9-liste-des-contributeurs-et-statut-fr9.md — contributor.list inclut _count.ideas]

Dev Agent Record

Agent Model Used

{{agent_model_name_version}}

Debug Log References

Completion Notes List

  • Implémentation complète : deleteAttachments, deleteIdea, deleteContributor, composants UI, intégrations, tests (A–O).
  • Correction Test J : texte fragmenté par guillemets → getByText(/Mon idée test/).
  • Mocks ajoutés dans IdeaDetailView.test.tsx (deleteIdea, useRouter) et ContributorsList.test.tsx (deleteContributor, useUtils) pour éviter les régressions.

File List

Fichier Action
src/server/services/storage.ts Modifié — deleteAttachments
src/server/api/routers/idea.ts Modifié — deleteIdea
src/server/api/routers/contributor.ts Modifié — deleteContributor
src/components/idea/DeleteIdeaButton.tsx Créé
src/components/workspace/DeleteContributorButton.tsx Créé
src/app/(dashboard)/workspace/[workspaceId]/ideas/[ideaId]/page.tsx Modifié — intégration DeleteIdeaButton
src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx Modifié — intégration DeleteContributorButton
src/server/api/routers/idea.deleteIdea.test.ts Créé
src/server/api/routers/contributor.deleteContributor.test.ts Créé
src/server/services/storage.test.ts Modifié — tests deleteAttachments
src/components/idea/DeleteIdeaButton.test.tsx Créé
src/components/workspace/DeleteContributorButton.test.tsx Créé
src/components/idea/IdeaDetailView.test.tsx Modifié — mocks deleteIdea, useRouter
src/components/workspace/ContributorsList.test.tsx Modifié — mocks deleteContributor, useUtils