2-11-relance-manuelle-transformateur-fr11-fr12-fr13.md 34 KB

Story 2.11 : Relance manuelle Transformateur (FR11, FR12, FR13)

Status: done

Story

En tant que Transformateur, je veux envoyer une relance manuelle à tous les contributeurs de mon workspace avec un message personnalisable, afin de relancer l'engagement et de communiquer directement avec les contributeurs.

Acceptance Criteria

  1. Given j'ai au moins 1 contributeur dans mon workspace When je clique sur le bouton "Envoyer une relance" depuis la page contributeurs Then un dialogue s'ouvre avec un formulaire de personnalisation (objet et corps pré-remplis avec un message par défaut)

  2. Given j'ai personnalisé le message (objet et corps du mail) When je clique sur "Suivant" Then une étape de confirmation s'affiche : "Vous allez contacter X contributeurs. Confirmer ?" And un aperçu du message est visible And le bouton de confirmation libelle l'action exacte : "Envoyer la relance à X contributeurs" And un bouton "Modifier" permet de revenir à l'étape de rédaction

  3. Given j'ai confirmé l'envoi de la relance When le système traite l'envoi Then un email avec le message personnalisé est envoyé à tous les contributeurs du workspace And chaque email inclut un lien direct vers le formulaire de soumission /submit/[workspaceSlug] And un toast confirme le succès : "Relance envoyée à X contributeurs"

  4. Given la relance a été envoyée When je consulte la page contributeurs Then un log d'envoi (date, nombre de destinataires, objet) est visible dans une section "Historique des relances"

  5. Given je n'ai aucun contributeur dans mon workspace When j'essaie d'envoyer une relance Then le bouton "Envoyer une relance" est désactivé avec un tooltip explicatif

  6. Given un ou plusieurs envois échouent When la relance est traitée Then le système envoie à chaque contributeur individuellement (pas de blocage en cascade) And le résumé indique le nombre d'envois réussis et échoués And le log enregistre sentCount et failedCount séparément

Tasks / Subtasks

  • [x] Task 1 : Migration Prisma — modèle ManualRelanceLog (AC: #4)

    • 1.1 : Ajouter le modèle ManualRelanceLog dans schema.prisma
    • 1.2 : Ajouter la relation manualRelanceLogs ManualRelanceLog[] sur Workspace
    • 1.3 : Générer et appliquer la migration : npx prisma migrate dev --name add_manual_relance_log
  • [x] Task 2 : Service email — sendManualRelanceEmail() (AC: #3)

    • 2.1 : Ajouter l'interface SendManualRelanceEmailParams et la fonction sendManualRelanceEmail dans src/server/services/email.ts
    • 2.2 : Même pattern que sendInvitationEmail — escaping HTML, mock dev, Resend
  • [x] Task 3 : tRPC — mutation sendManualRelance + query relanceLogs (AC: #1–#6)

    • 3.1 : Ajouter le schéma d'input Zod sendManualRelanceInputSchema dans contributor.ts
    • 3.2 : Implémenter la mutation sendManualRelance : compter les destinataires, boucle d'envoi individuelle avec try/catch, créer le log
    • 3.3 : Implémenter la query relanceLogs : lister les 10 derniers logs triés par date desc
    • 3.4 : Importer sendManualRelanceEmail depuis email.ts
  • [x] Task 4 : UI — composant ManualRelanceDialog (AC: #1, #2, #3, #5)

    • 4.1 : Créer src/components/workspace/ManualRelanceDialog.tsx
    • 4.2 : Étape 1 : formulaire de rédaction (objet + corps) avec valeurs par défaut
    • 4.3 : Étape 2 : confirmation avec aperçu du message et compteur de destinataires
    • 4.4 : État loading pendant l'envoi, toast de confirmation, invalidation du cache
  • [x] Task 5 : UI — composant RelanceHistory + intégration page contributeurs (AC: #4)

    • 5.1 : Créer src/components/workspace/RelanceHistory.tsx — table avec date, objet, compteur
    • 5.2 : Modifier contributors/page.tsx — ajouter ManualRelanceDialog et RelanceHistory
  • [x] Task 6 : Tests (AC: #1–#6)

    • 6.1 : Tests unitaires sendManualRelanceEmail dans email.test.ts (mock Resend, même pattern que tests existants)
    • 6.2 : Tests unitaires pour la mutation sendManualRelance (envoi réussi, envoi partiel avec échecs, 0 contributeurs)
    • 6.3 : Test composant ManualRelanceDialog (rendu, étapes compose/confirm, bouton désactivé si 0 contributeurs)

Dev Notes

Analyse de l'état existant — ce qui est DÉJÀ implémenté (NE PAS refaire)

email.ts — service email existant (Stories 2.1, 2.7) :

  • Provider : Resend (import { Resend } from "resend")
  • Helper getResend() : retourne null si RESEND_API_KEY absent → log console en dev
  • Helper getBaseUrl() : NEXT_PUBLIC_APP_URL > VERCEL_URL > localhost:3000
  • Fonctions existantes : sendInvitationEmail(), sendSubmissionConfirmationEmail()
  • Pattern HTML escaping anti-XSS sur workspaceName :

    const escapedName = params.workspaceName
    .replace(/&/g, "&amp;").replace(/</g, "&lt;")
    .replace(/>/g, "&gt;").replace(/"/g, "&quot;");
    
  • Variable EMAIL_FROM : process.env.EMAIL_FROM ?? "onboarding@resend.dev"

  • NE PAS modifier getResend() ni getBaseUrl() — les réutiliser tels quels

contributor.ts (router) — procédures existantes :

  • invite (mutation) : crée contributeurs, envoie emails, vérifie limites tier, utilise createWorkspaceProcedure
  • list (query) : findMany avec include: { _count: { select: { ideas: true } } }, tri invitedAt: "desc"
  • Import existant : import { sendInvitationEmail } from "~/server/services/email";
  • Étendre ce router avec les nouvelles procédures (pas créer un nouveau router)

ContributorsList.tsx — composant existant :

  • Table : Email | Statut | Invité le
  • Badges : SUBMITTED (vert bg-green-100), NOT_SUBMITTED (ambre bg-amber-100), INVITED (secondary)
  • Compteurs en header : X contributeurs · Y ont soumis · Z en attente
  • NE PAS modifier ce composant — la relance est un composant séparé

Page contributeurs (contributors/page.tsx) — structure existante :

  • Server component : auth() + db.workspace.findFirst() + db.contributor.count()
  • Layout : <main> avec max-w-2xl space-y-6
  • Sections actuelles : titre+description → InviteContributorsForm → ContributorsList → bouton retour
  • À modifier pour intégrer le bouton de relance et l'historique

Schéma Prisma actuel — Contributor :

id, workspaceId, email, status (enum INVITED/SUBMITTED/NOT_SUBMITTED), invitedAt, createdAt, ideas[]
@@unique([workspaceId, email])
  • NE PAS modifier le modèle Contributor dans cette story

Schéma Prisma actuel — Workspace :

id, name, slug, sector, companySize, contactEmail, tier, llmCallsThisMonth, llmCallsResetAt, ownerId
Relations: owner, contributors[], ideas[]
  • À modifier : ajouter la relation manualRelanceLogs

Modifications précises — Task 1 : Migration Prisma

Ajouter le modèle ManualRelanceLog :

model ManualRelanceLog {
  id             String   @id @default(cuid())
  workspaceId    String
  subject        String
  recipientCount Int
  sentCount      Int
  failedCount    Int      @default(0)
  sentAt         DateTime @default(now())

  workspace Workspace @relation(fields: [workspaceId], references: [id], onDelete: Cascade)

  @@index([workspaceId])
}

Ajouter la relation dans le modèle Workspace :

model Workspace {
  // ... champs existants — NE PAS toucher ...
  manualRelanceLogs ManualRelanceLog[]
  // ... relations existantes (owner, contributors, ideas) ...
}

Commande migration :

cd aimpact-hub
npx prisma migrate dev --name add_manual_relance_log

Modifications précises — Task 2 : sendManualRelanceEmail()

Ajouter dans src/server/services/email.ts — MÊME pattern que sendInvitationEmail :

export interface SendManualRelanceEmailParams {
  email: string;
  subject: string;
  body: string;
  workspaceSlug: string;
  workspaceName: string;
}

export async function sendManualRelanceEmail(
  params: SendManualRelanceEmailParams
): Promise<void> {
  const baseUrl = getBaseUrl();
  const submitUrl = `${baseUrl}/submit/${params.workspaceSlug}`;
  const from = process.env.EMAIL_FROM ?? "onboarding@resend.dev";

  const escapedName = params.workspaceName
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;");

  const escapedBody = params.body
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/\n/g, "<br>");

  const html = `
    <p>Bonjour,</p>
    <p>${escapedBody}</p>
    <p><a href="${submitUrl}">Soumettre une idée →</a></p>
    <p>— L'équipe ${escapedName}</p>
  `;

  const resend = getResend();
  if (!resend) {
    console.log("[email] Manual relance (mock):", {
      to: params.email,
      subject: params.subject,
      submitUrl,
    });
    return;
  }

  const { error } = await resend.emails.send({
    from,
    to: params.email,
    subject: params.subject,
    html,
  });

  if (error) {
    throw new Error(`Échec envoi relance manuelle: ${error.message}`);
  }
}

Points critiques :

  • Le body du CDO est échappé HTML (anti-XSS) puis \n → <br>
  • Le lien formulaire /submit/[workspaceSlug] est toujours ajouté automatiquement en fin d'email
  • Le subject vient du CDO tel quel (pas de préfixe automatique)
  • Le mock dev log le même format que les emails existants

Modifications précises — Task 3 : tRPC mutation + query

Ajouter dans contributor.ts — schéma d'input :

const sendManualRelanceInputSchema = z.object({
  workspaceId: z.string().cuid(),
  subject: z.string().min(1, "L'objet est requis").max(200, "Objet trop long"),
  body: z.string().min(1, "Le corps du message est requis").max(2000, "Message trop long"),
});

Ajouter la mutation dans contributorRouter :

sendManualRelance: createWorkspaceProcedure
  .input(sendManualRelanceInputSchema)
  .mutation(async ({ ctx, input }) => {
    const workspace = ctx.workspace;

    const contributors = await db.contributor.findMany({
      where: { workspaceId: input.workspaceId },
      select: { email: true },
    });

    if (contributors.length === 0) {
      throw new TRPCError({
        code: "BAD_REQUEST",
        message: "Aucun contributeur dans ce workspace",
      });
    }

    let sent = 0;
    let failed = 0;

    for (const contributor of contributors) {
      try {
        await sendManualRelanceEmail({
          email: contributor.email,
          subject: input.subject,
          body: input.body,
          workspaceSlug: workspace.slug,
          workspaceName: workspace.name,
        });
        sent++;
      } catch (error) {
        console.error(
          `[contributor.sendManualRelance] Échec pour ${contributor.email}:`,
          error
        );
        failed++;
      }
    }

    await db.manualRelanceLog.create({
      data: {
        workspaceId: input.workspaceId,
        subject: input.subject,
        recipientCount: contributors.length,
        sentCount: sent,
        failedCount: failed,
      },
    });

    return { sent, failed, total: contributors.length };
  }),

Ajouter la query dans contributorRouter :

relanceLogs: createWorkspaceProcedure.query(async ({ ctx }) => {
  return db.manualRelanceLog.findMany({
    where: { workspaceId: ctx.workspace.id },
    orderBy: { sentAt: "desc" },
    take: 10,
  });
}),

Import à ajouter en haut de contributor.ts :

import { sendManualRelanceEmail } from "~/server/services/email";

Points critiques :

  • Le try/catch individuel par contributeur empêche qu'un échec bloque les autres (pattern Story 2-10)
  • Le log est créé APRÈS la boucle d'envoi, avec le décompte réel sent/failed
  • La requête findMany cible TOUS les contributeurs sans filtre de statut (FR11)
  • relanceLogs est limité à 10 entrées pour la performance

Modifications précises — Task 4 : ManualRelanceDialog

Créer src/components/workspace/ManualRelanceDialog.tsx :

Le composant utilise un dialogue shadcn en 2 étapes :

  1. Rédaction : formulaire avec Input (objet) + Textarea (corps) pré-remplis
  2. Confirmation : aperçu du message + compteur de destinataires + bouton d'envoi libellé avec l'action exacte

    "use client";
    
    import { useState } from "react";
    import { api } from "~/trpc/react";
    import {
    Dialog,
    DialogContent,
    DialogDescription,
    DialogFooter,
    DialogHeader,
    DialogTitle,
    DialogTrigger,
    } from "~/components/ui/dialog";
    import { Button } from "~/components/ui/button";
    import { Input } from "~/components/ui/input";
    import { Label } from "~/components/ui/label";
    import { Textarea } from "~/components/ui/textarea";
    import { useToast } from "~/hooks/use-toast";
    
    interface ManualRelanceDialogProps {
    workspaceId: string;
    workspaceName: string;
    contributorsCount: number;
    }
    
    const DEFAULT_SUBJECT_PREFIX = "Rappel : partagez vos idées";
    const DEFAULT_BODY = `Nous souhaitons vous rappeler que vous pouvez à tout moment partager vos idées pour la transformation de notre entreprise.
    
    Votre expérience terrain est précieuse. Si vous avez un problème récurrent ou une opportunité d'amélioration, n'hésitez pas à le partager.
    
    2 minutes suffisent pour décrire un problème ou une opportunité.`;
    
    export function ManualRelanceDialog({
    workspaceId,
    workspaceName,
    contributorsCount,
    }: ManualRelanceDialogProps) {
    const [open, setOpen] = useState(false);
    const [step, setStep] = useState<"compose" | "confirm">("compose");
    const [subject, setSubject] = useState(
    `${DEFAULT_SUBJECT_PREFIX} — ${workspaceName}`
    );
    const [body, setBody] = useState(DEFAULT_BODY);
    const { toast } = useToast();
    const utils = api.useUtils();
    
    const sendRelance = api.contributor.sendManualRelance.useMutation({
    onSuccess: (data) => {
      const desc =
        data.failed > 0
          ? `${data.sent} envoyé${data.sent > 1 ? "s" : ""}, ${data.failed} échec${data.failed > 1 ? "s" : ""}`
          : `${data.sent} email${data.sent > 1 ? "s" : ""} envoyé${data.sent > 1 ? "s" : ""}`;
      toast({ title: "Relance envoyée", description: desc });
      void utils.contributor.relanceLogs.invalidate();
      setOpen(false);
      setStep("compose");
    },
    onError: (error) => {
      toast({
        title: "Erreur",
        description: error.message,
        variant: "destructive",
      });
    },
    });
    
    const handleSend = () => {
    sendRelance.mutate({ workspaceId, subject, body });
    };
    
    const handleOpenChange = (newOpen: boolean) => {
    setOpen(newOpen);
    if (!newOpen) setStep("compose");
    };
    
    const plural = contributorsCount > 1 ? "s" : "";
    
    return (
    <Dialog open={open} onOpenChange={handleOpenChange}>
      <DialogTrigger asChild>
        <Button
          variant="outline"
          disabled={contributorsCount === 0}
          title={
            contributorsCount === 0
              ? "Aucun contributeur à contacter"
              : undefined
          }
        >
          Envoyer une relance
        </Button>
      </DialogTrigger>
      <DialogContent className="sm:max-w-lg">
        {step === "compose" ? (
          <>
            <DialogHeader>
              <DialogTitle>Relance manuelle</DialogTitle>
              <DialogDescription>
                Personnalisez le message qui sera envoyé à vos{" "}
                {contributorsCount} contributeur{plural}.
              </DialogDescription>
            </DialogHeader>
            <div className="space-y-4">
              <div>
                <Label htmlFor="relance-subject">Objet</Label>
                <Input
                  id="relance-subject"
                  value={subject}
                  onChange={(e) => setSubject(e.target.value)}
                  maxLength={200}
                />
              </div>
              <div>
                <Label htmlFor="relance-body">Message</Label>
                <Textarea
                  id="relance-body"
                  value={body}
                  onChange={(e) => setBody(e.target.value)}
                  rows={8}
                  maxLength={2000}
                />
                <p className="mt-1 text-xs text-muted-foreground">
                  Un lien vers le formulaire de soumission sera automatiquement
                  ajouté en fin de message.
                </p>
              </div>
            </div>
            <DialogFooter>
              <Button variant="outline" onClick={() => setOpen(false)}>
                Annuler
              </Button>
              <Button
                onClick={() => setStep("confirm")}
                disabled={!subject.trim() || !body.trim()}
              >
                Suivant
              </Button>
            </DialogFooter>
          </>
        ) : (
          <>
            <DialogHeader>
              <DialogTitle>Confirmer l'envoi</DialogTitle>
              <DialogDescription>
                Vous allez contacter {contributorsCount} contributeur{plural}.
                Confirmer ?
              </DialogDescription>
            </DialogHeader>
            <div className="rounded-md border bg-muted/30 p-3 text-sm">
              <p className="font-medium">Objet : {subject}</p>
              <p className="mt-2 whitespace-pre-wrap text-muted-foreground">
                {body}
              </p>
            </div>
            <DialogFooter>
              <Button variant="outline" onClick={() => setStep("compose")}>
                Modifier
              </Button>
              <Button onClick={handleSend} disabled={sendRelance.isPending}>
                {sendRelance.isPending
                  ? "Envoi en cours…"
                  : `Envoyer la relance à ${contributorsCount} contributeur${plural}`}
              </Button>
            </DialogFooter>
          </>
        )}
      </DialogContent>
    </Dialog>
    );
    }
    

Vérification import useToast : Le hook useToast peut être à ~/hooks/use-toast ou ~/components/ui/use-toast selon la version de shadcn installée. Vérifier le chemin exact dans le projet avant d'implémenter. Si le hook n'existe pas, installer le composant Toast : npx shadcn@latest add toast.

Patterns UX critiques :

  • Le bouton de confirmation libelle l'action exacte : "Envoyer la relance à X contributeurs" — JAMAIS "OK" ni "Confirmer" seul (UX spec Step 12)
  • Le bouton est disabled pendant l'envoi avec texte "Envoi en cours…"
  • Le bouton "Envoyer une relance" est disabled + tooltip si 0 contributeurs
  • Les valeurs par défaut du message sont neutres et non-intrusives (UX spec J2b)
  • Le lien formulaire est ajouté côté serveur — pas par le CDO

Modifications précises — Task 5 : RelanceHistory + intégration page

Créer src/components/workspace/RelanceHistory.tsx :

"use client";

import { api } from "~/trpc/react";

export function RelanceHistory({ workspaceId }: { workspaceId: string }) {
  const { data: logs, isLoading } = api.contributor.relanceLogs.useQuery({
    workspaceId,
  });

  if (isLoading) {
    return (
      <div className="rounded-md border p-4">
        <p className="text-sm text-muted-foreground">Chargement…</p>
      </div>
    );
  }

  if (!logs || logs.length === 0) {
    return (
      <div className="rounded-md border p-4">
        <p className="text-sm text-muted-foreground">
          Aucune relance envoyée pour le moment.
        </p>
      </div>
    );
  }

  return (
    <div className="rounded-md border">
      <table className="w-full text-sm">
        <thead>
          <tr className="border-b bg-muted/50">
            <th className="px-4 py-2 text-left font-medium">Date</th>
            <th className="px-4 py-2 text-left font-medium">Objet</th>
            <th className="px-4 py-2 text-left font-medium">Envoyés</th>
          </tr>
        </thead>
        <tbody>
          {logs.map((log) => (
            <tr key={log.id} className="border-b last:border-0">
              <td className="px-4 py-2 text-muted-foreground">
                {new Date(log.sentAt).toLocaleDateString("fr-FR", {
                  day: "numeric",
                  month: "short",
                  year: "numeric",
                  hour: "2-digit",
                  minute: "2-digit",
                })}
              </td>
              <td className="px-4 py-2">{log.subject}</td>
              <td className="px-4 py-2">
                {log.sentCount}/{log.recipientCount}
                {log.failedCount > 0 && (
                  <span className="ml-1 text-destructive">
                    ({log.failedCount} échec
                    {log.failedCount > 1 ? "s" : ""})
                  </span>
                )}
              </td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

Modifier src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx :

Ajouter les imports :

import { ManualRelanceDialog } from "~/components/workspace/ManualRelanceDialog";
import { RelanceHistory } from "~/components/workspace/RelanceHistory";

Modifier le JSX — remplacer la section actuelle "Liste des contributeurs" par :

<div className="flex items-center justify-between">
  <h2 className="font-semibold">Liste des contributeurs</h2>
  <ManualRelanceDialog
    workspaceId={workspace.id}
    workspaceName={workspace.name}
    contributorsCount={contributorsCount}
  />
</div>
<ContributorsList workspaceId={workspace.id} />

<div>
  <h2 className="mb-3 font-semibold">Historique des relances</h2>
  <RelanceHistory workspaceId={workspace.id} />
</div>

Structure résultante de la page :

  1. Titre "Contributeurs" + description
  2. Section "Inviter par email" — InviteContributorsForm
  3. Titre "Liste des contributeurs" + bouton "Envoyer une relance" (alignés)
  4. ContributorsList — table des contributeurs
  5. Titre "Historique des relances" + RelanceHistory
  6. Bouton retour au workspace

Structure des fichiers

Fichier Action
aimpact-hub/prisma/schema.prisma Modifier — ajouter modèle ManualRelanceLog + relation Workspace
aimpact-hub/prisma/migrations/YYYYMMDDHHMMSS_add_manual_relance_log/migration.sql Créer — migration auto-générée
aimpact-hub/src/server/services/email.ts Modifier — ajouter SendManualRelanceEmailParams + sendManualRelanceEmail()
aimpact-hub/src/server/api/routers/contributor.ts Modifier — ajouter sendManualRelance mutation + relanceLogs query + import
aimpact-hub/src/components/workspace/ManualRelanceDialog.tsx Créer — dialogue 2 étapes (compose → confirm)
aimpact-hub/src/components/workspace/RelanceHistory.tsx Créer — table historique des relances
aimpact-hub/src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx Modifier — intégrer ManualRelanceDialog + RelanceHistory
aimpact-hub/src/server/services/email.test.ts Modifier — tests sendManualRelanceEmail
aimpact-hub/src/components/workspace/ManualRelanceDialog.test.tsx Créer — tests composant

Décision de design : destinataires de la relance manuelle

FR11 spécifie "tous les contributeurs du workspace". La relance manuelle est un outil de communication CDO → contributeurs. Le CDO personnalise le message (FR12), donc le contenu peut être pertinent pour tous les contributeurs — pas seulement ceux qui n'ont pas soumis.

Implémentation retenue : envoi à TOUS les contributeurs du workspace, sans filtre de statut. La requête Prisma utilise where: { workspaceId } sans filtre sur status.

Conventions architecture à respecter

  • Router tRPC : étendre contributorRouter existant (pas créer un nouveau router)
  • createWorkspaceProcedure : obligatoire pour toutes les procédures accédant à des données workspace
  • Nommage : sendManualRelanceEmail (camelCase), ManualRelanceLog (PascalCase Prisma), ManualRelanceDialog (PascalCase composant)
  • Composant UI : un composant par fichier, dans src/components/workspace/
  • Erreurs : TRPCError côté tRPC, console.error côté serveur pour logs — jamais d'erreur brute exposée au CDO
  • Tests : Vitest, mock Resend, mock Prisma — pattern email.test.ts
  • Validation Zod : sur les inputs tRPC — subject et body avec min/max

Dépendances inter-stories

  • Dépend de Story 2.1 : modèle Contributor, sendInvitationEmail (pattern email), contributorRouter, createWorkspaceProcedure
  • Dépend de Story 2.7 : sendSubmissionConfirmationEmail (pattern email à suivre)
  • Dépend de Story 2.9 : page contributeurs (contributors/page.tsx), ContributorsList
  • Indépendante de Story 2-10 (relance automatique J+21) : la relance manuelle est un flux séparé
    • Si Story 2-10 est implémentée avant : lastRemindedAt et autoRelanceEnabled existeront dans le schéma — aucun conflit
    • Si Story 2-11 est implémentée en premier : aucune dépendance sur ces champs
  • Sans impact sur les stories 3.x (backlog) et 4.x (priorisation)

NFR concernés

  • NFR7 : Disponibilité 99% — le try/catch individuel empêche qu'un échec email bloque les autres envois
  • NFR8 : Pas d'appel LLM dans cette story — pas concerné
  • NFR13 : Hébergement EU — Resend et Vercel sont configurés EU
  • NFR14 : Isolation workspace — createWorkspaceProcedure assure que seul le propriétaire du workspace peut déclencher la relance

Apprentissages des stories précédentes

  • Story 2.1 : Pattern sendInvitationEmail → COPIER exactement ce pattern pour sendManualRelanceEmail (même structure, même escaping HTML, même fallback mock en dev)
  • Story 2.7 : Pattern sendSubmissionConfirmationEmail → même structure avec CTA "Soumettre une idée →"
  • Story 2.9 : ContributorsList.tsx — table avec badges et compteurs → réutiliser ce pattern pour RelanceHistory
  • Story 2-10 (fichier story, pas nécessairement implémenté) : pattern try/catch individuel dans les boucles d'envoi email + résumé { sent, failed, total } → COPIER ce pattern
  • Tests : Mock Resend avec vi.mock("resend", ...) — pattern dans email.test.ts
  • Pattern env.js : Aucune nouvelle variable d'environnement requise

UX — Flux relance manuelle (spec J2b)

  • Message personnalisable — le CDO rédige objet et corps via formulaire dans le dialogue
  • Confirmation avant envoi — 2e étape du dialogue avec aperçu du message et compteur exact de destinataires (UX spec Step 12 : "Modale pour relance manuelle")
  • Bouton = action : "Envoyer la relance à X contributeurs" — JAMAIS "OK" ni "Confirmer" seul (UX spec)
  • Log visible — table "Historique des relances" sous la liste des contributeurs
  • Toast de confirmation — retour immédiat après envoi réussi (bas à droite, 4s, fond vert)
  • Ton par défaut : neutre, non-intrusif, valorisant la contribution (UX spec J2b : « jamais de harcèlement »)
  • Lien formulaire automatique : le lien /submit/[workspaceSlug] est ajouté automatiquement en fin d'email — le CDO n'a pas à le saisir

Composants shadcn nécessaires

Vérifier la présence des composants suivants avant de créer ManualRelanceDialog.tsx. Si un composant manque, l'installer avec npx shadcn@latest add [nom] :

Composant Import depuis
Dialog (+ DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, DialogTrigger) ~/components/ui/dialog
Button ~/components/ui/button
Input ~/components/ui/input
Label ~/components/ui/label
Textarea ~/components/ui/textarea
Toast / useToast ~/hooks/use-toast ou ~/components/ui/use-toast — vérifier le chemin

Variables d'environnement

Aucune nouvelle variable requise. Les variables existantes sont suffisantes :

Variable Déjà configurée Utilisée par
RESEND_API_KEY Oui (Stories 2.1, 2.7) sendManualRelanceEmail via getResend()
EMAIL_FROM Oui Adresse d'envoi (fallback onboarding@resend.dev)
NEXT_PUBLIC_APP_URL Oui Construction du lien formulaire

Limites tier Free — vérification

La relance manuelle n'est PAS soumise aux limites du tier Free (pas un appel LLM, pas une soumission d'idée). Aucune vérification checkWorkspaceLimits n'est nécessaire pour cette fonctionnalité.

Contraintes de volume email Resend

  • Plan gratuit Resend : 100 emails/jour, 3 000/mois
  • Si le workspace a > 100 contributeurs et que le CDO envoie une relance → risque de dépassement de la limite quotidienne
  • Mitigation MVP : log le nombre d'échecs, le CDO voit le résultat
  • V2 : considérer un batch avec rate limiting ou utiliser Resend Batch API (resend.batch.send)

Project Structure Notes

  • Tous les fichiers respectent l'arborescence architecture : src/components/workspace/ pour les composants workspace, src/server/api/routers/ pour les routers tRPC, src/server/services/ pour les services
  • Pas de nouveau dossier créé — tout s'insère dans la structure existante
  • Les tests sont co-localisés avec les fichiers source (pattern *.test.ts / *.test.tsx)

Références sources

  • [Source: epics.md#Story 2.11 — Relance manuelle Transformateur (FR11, FR12, FR13)]
  • [Source: prd.md#FR11 — relance manuelle tous contributeurs]
  • [Source: prd.md#FR12 — personnalisation message relance]
  • [Source: prd.md#FR13 — confirmation avant envoi avec nombre de destinataires]
  • [Source: ux-design-specification.md#J2b — Relance contributeur silencieux : relance manuelle CDO]
  • [Source: ux-design-specification.md#Step 12 — Confirmation avant action lourde : modale pour relance manuelle]
  • [Source: ux-design-specification.md#Step 12 — Libellé du bouton = action exacte, jamais "OK"]
  • [Source: architecture.md#Services — services/email.ts]
  • [Source: architecture.md#API Naming Conventions — camelCase tRPC procedures]
  • [Source: architecture.md#Security Conventions — createWorkspaceProcedure obligatoire]
  • [Source: src/server/services/email.ts — pattern sendInvitationEmail / sendSubmissionConfirmationEmail]
  • [Source: src/server/api/routers/contributor.ts — router existant, createWorkspaceProcedure]
  • [Source: src/components/workspace/ContributorsList.tsx — table UI pattern, badges, compteurs]
  • [Source: src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx — page structure actuelle]
  • [Source: implementation-artifacts/2-10-relance-automatique-j21-fr10.md — patterns try/catch email, résumé sent/failed/total]

Dev Agent Record

Agent Model Used

claude-4.6-sonnet-medium-thinking

Senior Developer Review (AI) — 28/02/2026

Outcome : Approuvé avec corrections appliquées

Issues trouvés et corrigés automatiquement :

Sévérité Issue Fichier Fix
🔴 HIGH Aucune migration SQL pour ManualRelanceLog — db push utilisé, déploiement production cassé — Créé 20260228110000_add_manual_relance_log/migration.sql
🔴 HIGH AC#1 violé : dialogue ne remet pas subject/body aux valeurs par défaut à la réouverture ManualRelanceDialog.tsx Ajout resetForm() appelé dans handleOpenChange et onSuccess
🟡 MEDIUM toast.success() même si data.sent === 0 (échec total — toast vert trompeur) ManualRelanceDialog.tsx toast.error() si data.sent === 0
🟡 MEDIUM Mutation utilise input.workspaceId au lieu de ctx.workspace.id (incohérence avec pattern établi) contributor.ts Remplacé par workspace.id dans findMany et create
🟡 MEDIUM RelanceHistory sans état d'erreur — affiche "Aucune relance" si la query échoue RelanceHistory.tsx Ajout bloc isError avec message d'erreur

Issues LOW documentés (non corrigés, non bloquants) :

  • L1 : Pas de compteur de caractères sur le Textarea (corps)
  • L2 : Tooltip du bouton désactivé via title uniquement (accessibilité)
  • L3 : Aucun test pour la query relanceLogs
  • L4 : Libellé toast légèrement différent du wording exact de l'AC#3

Debug Log References

Completion Notes List

  • Migration Prisma : modèle ManualRelanceLog + relation Workspace. Schéma appliqué via prisma db push (drift existant). Migration SQL créée manuellement dans 20260228110000_add_manual_relance_log/migration.sql. ⚠️ Sur le DB dev existant, marquer la migration comme déjà appliquée : npx prisma migrate resolve --applied 20260228110000_add_manual_relance_log.
  • Service email : sendManualRelanceEmail avec escaping HTML, mock dev, lien formulaire automatique.
  • tRPC : mutation sendManualRelance (try/catch individuel, log sent/failed, utilise ctx.workspace.id) + query relanceLogs.
  • UI : ManualRelanceDialog (2 étapes compose/confirm, sonner toast, réinitialisation formulaire à fermeture, toast.error si 0 envoyés), RelanceHistory (table avec état erreur), intégration page contributeurs.
  • Tests : 4 email.test.ts, 3 contributor.sendManualRelance.test.ts, 6 ManualRelanceDialog.test.tsx. Tous les 213 tests passent.
  • Code Review (AI) : 2 HIGH + 3 MEDIUM corrigés automatiquement. Voir "Senior Developer Review (AI)" ci-dessous.

File List

  • aimpact-hub/prisma/schema.prisma (modifié)
  • aimpact-hub/prisma/migrations/20260228110000_add_manual_relance_log/migration.sql (créé)
  • aimpact-hub/src/server/services/email.ts (modifié)
  • aimpact-hub/src/server/api/routers/contributor.ts (modifié)
  • aimpact-hub/src/components/workspace/ManualRelanceDialog.tsx (créé)
  • aimpact-hub/src/components/workspace/RelanceHistory.tsx (créé)
  • aimpact-hub/src/app/(dashboard)/workspace/[workspaceId]/contributors/page.tsx (modifié)
  • aimpact-hub/src/server/services/email.test.ts (modifié)
  • aimpact-hub/src/server/api/routers/contributor.sendManualRelance.test.ts (créé)
  • aimpact-hub/src/components/workspace/ManualRelanceDialog.test.tsx (créé)