Fabriquer une procédure

import { router, publicProcedure, protectedProcedure } from "@backend/trpc/core";import { deleteSessionFromCookie } from "@backend/lib/session/session.server";import { loginService } from "@backend/modules/auth/services/auth.service";import {  createPasswordResetToken,  hashResetToken,  RESET_TOKEN_COOLDOWN_MS,  RESET_TOKEN_TTL_MS,} from "@backend/modules/auth/services/passwordReset.service";import { sendPasswordResetEmail } from "@backend/email/services/sendPasswordResetEmail";import { TRPCError } from "@trpc/server";import { hashPassword, verifyPassword } from "@backend/lib/auth/password";import { getToken, verifyJwt } from "@backend/lib/session/session.server";import {  changePasswordSchema,  loginSchema,  requestPasswordResetSchema,  resetPasswordSchema,} from "@contracts/auth/auth.schema";import { assertPasswordOfConnectedUser } from "@backend/lib/security/passwordCheck";/** * Connexion, déconnexion, session courante, mot de passe (changement, oubli, réinitialisation). * `getSession` est appelée en permanence par le front : elle répond à « qui suis-je, maintenant ? ». */export const authRouter = router({  login: publicProcedure    // Même schéma que le formulaire de connexion (packages/contracts) : une seule règle, un seul message.    .input(loginSchema)    .mutation(async ({ input }) => {      const { email, password } = input;      try {        await loginService(email, password);        return {          success: true as const,        };      } catch (error) {        // Un mauvais identifiant fait partie du fonctionnement normal du formulaire : c'est un        // résultat. Tout le reste (base injoignable, bug) est une vraie erreur : elle remonte,        // est journalisée par la route /api/trpc, et le formulaire affiche son message générique.        if (error instanceof TRPCError && error.message === "INVALID_CREDENTIALS") {          return {            success: false as const,            error: "INVALID_CREDENTIALS" as const,          };        }        // Trop d'échecs pour cette adresse : un résultat aussi, que le formulaire explique.        if (error instanceof TRPCError && error.message === "TOO_MANY_ATTEMPTS") {          return {            success: false as const,            error: "TOO_MANY_ATTEMPTS" as const,          };        }        throw error;      }    }),  logout: protectedProcedure.mutation(async () => {    await deleteSessionFromCookie();    return {      success: true,    };  }),  /**   * Changement de mot de passe (utilisateur connecté).   * Vérifie le mot de passe actuel, refuse un nouveau identique, re-hash, et   * DÉCONNECTE LES AUTRES APPAREILS (supprime leurs sessions ; garde la   * courante via le sessionId du cookie).   */  changePassword: protectedProcedure    .input(changePasswordSchema)    .mutation(async ({ ctx, input }) => {      const userId = ctx.sessionClient.user.id;      const user = await ctx.prisma.user.findUnique({        where: { id: userId },        select: { password: true },      });      if (!user) {        throw new TRPCError({ code: "NOT_FOUND", message: "Membre introuvable." });      }      // BAD_REQUEST, pas UNAUTHORIZED : le membre EST connecté ; c'est la saisie qui est fausse.      // UNAUTHORIZED signifie « aucune session », et un client pourrait le traiter comme une déconnexion.      // Essais limités : une session volée ne permet pas d'essayer des mots de passe sans fin.      await assertPasswordOfConnectedUser({        userId,        password: input.currentPassword,        hash: user.password,        wrongMessage: "Mot de passe actuel incorrect.",      });      const same = await verifyPassword(input.newPassword, user.password);      if (same) {        throw new TRPCError({          code: "BAD_REQUEST",          message: "Le nouveau mot de passe doit être différent de l'actuel.",        });      }      const hashed = await hashPassword(input.newPassword);      const payload = verifyJwt(await getToken());      const currentSessionId = payload?.sessionId ?? null;      await ctx.prisma.$transaction(async (tx) => {        await tx.user.update({          where: { id: userId },          data: { password: hashed },        });        await tx.session.deleteMany({          where: {            userId,            ...(currentSessionId ? { NOT: { id: currentSessionId } } : {}),          },        });      });      return { success: true };    }),  getSession: publicProcedure.query(async ({ ctx }) => {    return ctx.sessionClient;  }),  requestPasswordReset: publicProcedure    .input(requestPasswordResetSchema)    .mutation(async ({ input, ctx }) => {      // Déjà nettoyée et mise en minuscules par emailSchema, comme toutes les adresses enregistrées.      const user = await ctx.prisma.user.findUnique({        where: { email: input.email },        select: { id: true, email: true },      });      if (!user) {        return { ok: true as const };      }      const lastToken = await ctx.prisma.passwordResetToken.findFirst({        where: { userId: user.id },        orderBy: { createdAt: "desc" },        select: { createdAt: true },      });      if (lastToken) {        const elapsed = Date.now() - lastToken.createdAt.getTime();        if (elapsed < RESET_TOKEN_COOLDOWN_MS) {          return { ok: true as const };        }      }      const { token, tokenHash } = createPasswordResetToken();      const expiresAt = new Date(Date.now() + RESET_TOKEN_TTL_MS);      await ctx.prisma.passwordResetToken.create({        data: {          userId: user.id,          tokenHash,          expiresAt,          requestIp: ctx.requestIp ?? null,          userAgent: ctx.userAgent ?? null,        },      });      // L'envoi n'est PAS attendu : il prend plusieurs secondes, et une réponse lente pour une      // adresse connue, rapide pour une inconnue, trahirait qui a un compte. Jamais le jeton dans      // les journaux ; un échec d'envoi est journalisé, la réponse reste la même.      void sendPasswordResetEmail({ toEmail: user.email, token }).catch((err: unknown) => {        console.error(          "[auth] e-mail de réinitialisation non envoyé :",          err instanceof Error ? err.message : err,        );      });      return { ok: true as const };    }),  resetPassword: publicProcedure    .input(resetPasswordSchema)    .mutation(async ({ ctx, input }) => {      const token = input.token.trim();      const tokenHash = hashResetToken(token);      const entry = await ctx.prisma.passwordResetToken.findUnique({        where: { tokenHash },        select: {          id: true,          userId: true,          expiresAt: true,          usedAt: true,        },      });      if (!entry) {        throw new TRPCError({ code: "BAD_REQUEST", message: "Ce lien n'est pas valide. Demandez-en un nouveau avec « Mot de passe oublié »." });      }      if (entry.usedAt) {        throw new TRPCError({ code: "BAD_REQUEST", message: "Ce lien a déjà servi. Connectez-vous, ou demandez-en un nouveau avec « Mot de passe oublié »." });      }      if (entry.expiresAt.getTime() < Date.now()) {        throw new TRPCError({ code: "BAD_REQUEST", message: "Ce lien a expiré. Demandez-en un nouveau avec « Mot de passe oublié »." });      }      const hashedPassword = await hashPassword(input.newPassword);      await ctx.prisma.$transaction(async (tx) => {        await tx.user.update({          where: { id: entry.userId },          // `isFirstLogin` n'est pas touché : choisir un mot de passe ne complète pas le profil.          // Un nouveau membre qui passe par « Mot de passe oublié » y reste invité.          data: { password: hashedPassword },        });        // Consommation atomique : la ligne n'est marquée que si elle ne l'était pas encore. Deux        // envois simultanés du même lien passent tous deux les vérifications ci-dessus ; un seul        // obtient ici count === 1, l'autre annule sa transaction.        const consumed = await tx.passwordResetToken.updateMany({          where: { id: entry.id, usedAt: null },          data: { usedAt: new Date() },        });        if (consumed.count !== 1) {          throw new TRPCError({ code: "BAD_REQUEST", message: "Ce lien a déjà servi. Connectez-vous, ou demandez-en un nouveau avec « Mot de passe oublié »." });        }        await tx.session.deleteMany({          where: { userId: entry.userId },        });      });      return { ok: true as const };    }),});

import { Prisma } from "@prisma/client";import { router, protectedProcedure, publicProcedure } from "@backend/trpc/core";import { isAdmin } from "@backend/trpc/middleware";import { z } from "zod";import generateStrongPassword from "@backend/lib/security/generatePassword";import { hashPassword } from "@backend/lib/auth/password";import { sendWelcomeEmail, sendWelcomeNotice } from "@backend/email/templates/welcomeEmailWithPassword";import { isDemoEmail } from "@backend/lib/demoAccounts";import { TRPCError } from "@trpc/server";import type { UserProfile } from "@contracts/users/user-profile.types";import type { ImageConsentProofValue } from "@contracts/legal/imageConsent";import { legalInfoInput, legalInfoData } from "@backend/modules/users/legalInfo";import { emailSchema } from "@contracts/auth/auth.schema";import { syncPageMediaReferences } from "@backend/modules/media/services/syncPageMediaReferences.service";import { pageContentSchemaV1 } from "@contracts/page";import { assertBioMediaAllowed, isInstructorUser } from "@backend/modules/users/instructorBio.service";import { removeAvatarFile } from "@backend/modules/avatar/avatar.service";import { resolvePersoBaseFolder } from "@backend/modules/media/services/resolvePersoBaseFolder.service";import { assertOwnAvatars } from "@backend/modules/media/services/assertOwnAvatars.service";import { byEffectiveDesc } from "@backend/modules/imageConsent/formOrder";/** Les champs du profil, et eux seuls : ni l'empreinte du mot de passe, ni les données légales. */const userProfileSelect = {  id: true,  email: true,  firstName: true,  lastName: true,  pseudo: true,  avatar: true,  aboutMe: true,  phone: true,  birthDate: true,  isFirstLogin: true,} satisfies Prisma.UserSelect;type UserProfileRow = Prisma.UserGetPayload<{ select: typeof userProfileSelect }>;/** * Du membre lu en base au contrat partagé avec le front : la date devient « AAAA-MM-JJ ». * `satisfies` vérifie la conformité à UserProfile sans élargir le type : le front garde * `id: string` (sûr), là où le contrat, plus large, admettrait `null`. */function toUserProfile(user: UserProfileRow) {  return {    ...user,    birthDate: user.birthDate ? user.birthDate.toISOString().split("T")[0] : null,  } satisfies UserProfile;}export const userRouter = router({  getAll: protectedProcedure    .use(isAdmin)    .query(async ({ ctx }) => {      // Jamais l'empreinte du mot de passe vers le navigateur.      const users = await ctx.prisma.user.findMany({        orderBy: { id: "asc" },        omit: { password: true },        include: {          memberGroupMemberships: {            select: { group: { select: { id: true, name: true, isAdminGroup: true } } },          },          // Droit à l'image : voie de la version la plus récente (par date des droits), et demande en          // attente du parent.          imageConsentForms: { select: { source: true, signedAt: true, createdAt: true } },          imageConsentRequest: { select: { expiresAt: true } },        },      });      const now = new Date();      return users.map(({ memberGroupMemberships, imageConsentForms, imageConsentRequest, ...u }) => ({        ...u,        isDemo: isDemoEmail(u.email),        consentProof: (imageConsentForms.sort(byEffectiveDesc)[0]?.source ??          (imageConsentRequest?.expiresAt && imageConsentRequest.expiresAt > now            ? "PENDING_GUARDIAN"            : "NONE")) satisfies ImageConsentProofValue,        // Groupes du membre : Administrateurs d'abord, puis ordre alphabétique.        groups: memberGroupMemberships          .map((m) => m.group)          .sort((a, b) => Number(b.isAdminGroup) - Number(a.isAdminGroup) || a.name.localeCompare(b.name, "fr")),      }));    }),  getById: protectedProcedure    .use(isAdmin)    .input(z.object({ id: z.string() }))    .query(async ({ ctx, input }) => {      const user = await ctx.prisma.user.findUnique({        where: { id: input.id },        omit: { password: true },      });      if (!user) {        throw new TRPCError({          code: "NOT_FOUND",          message: "Membre introuvable.",        });      }      return user;    }),  getByEmail: protectedProcedure    .use(isAdmin)    .input(z.object({ email: emailSchema }))    .query(async ({ ctx, input }) => {      const user = await ctx.prisma.user.findUnique({        where: { email: input.email },        omit: { password: true },      });      if (!user) {        throw new TRPCError({          code: "NOT_FOUND",          message: "Membre introuvable.",        });      }      return user;    }),  create: protectedProcedure    .use(isAdmin)    .input(      z.object({        // Même règle que la connexion : nettoyée, en minuscules (sinon le membre ne retrouverait        // pas son compte en tapant son adresse autrement).        email: emailSchema,        /** Un ou plusieurs groupes (au moins un). */        groupIds: z.array(z.string().min(1)).min(1, "Choisissez au moins un groupe."),        /** Majorité et, pour un mineur, date de naissance et parent référent (tous obligatoires). */        legal: legalInfoInput,      }),    )    .mutation(async ({ ctx, input }) => {      const groupIds = [...new Set(input.groupIds)];      const found = await ctx.prisma.memberGroup.count({ where: { id: { in: groupIds } } });      if (found !== groupIds.length) {        throw new TRPCError({ code: "BAD_REQUEST", message: "Groupe inconnu : rechargez la page." });      }      // Mot de passe généré côté serveur (jamais saisi par l'admin), robuste par      // construction, puis envoyé au SEUL membre (voir welcomeEmailWithPassword.ts).      // isFirstLogin=true (défaut Prisma) : le site lui propose de compléter son profil.      const password = generateStrongPassword();      const hash = await hashPassword(password);      if (input.legal.legalAge === "UNKNOWN") {        throw new TRPCError({ code: "BAD_REQUEST", message: "Indiquez si le membre est majeur ou mineur." });      }      const legal = legalInfoData(input.legal, input.email, { requireComplete: true });      // L'adresse est unique en base (@unique). Plutôt que de vérifier avant d'écrire (deux      // créations simultanées passeraient toutes les deux la vérification), on écrit, et on      // traduit le refus de la base.      let user;      try {        user = await ctx.prisma.user.create({          data: {            email: input.email,            password: hash,            ...legal,            memberGroupMemberships: {              create: groupIds.map((id) => ({                group: { connect: { id } },                access: "EDITOR" as const,              })),            },          },          omit: { password: true },        });      } catch (err) {        if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2002") {          throw new TRPCError({ code: "CONFLICT", message: "Un membre utilise déjà cette adresse e-mail." });        }        throw err;      }      // E-mail de bienvenue au membre, puis avis SANS mot de passe à la boîte du club.      // Un échec d'envoi n'annule pas la création : il est journalisé et signalé au club.      // Compte de démonstration : son adresse ne peut rien recevoir, pas d'e-mail.      if (!isDemoEmail(input.email)) {        let sendError: string | null = null;        try {          await sendWelcomeEmail({ to: input.email, password });        } catch (err) {          sendError = err instanceof Error ? err.message : String(err);          console.error("[user.create] e-mail de bienvenue non envoyé :", sendError);        }        const [groups, admin] = await Promise.all([          ctx.prisma.memberGroup.findMany({ where: { id: { in: groupIds } }, select: { name: true } }),          ctx.prisma.user.findUnique({            where: { id: ctx.sessionClient.user.id },            select: { firstName: true, lastName: true, email: true },          }),        ]);        const adminName = admin          ? [admin.firstName, admin.lastName].filter(Boolean).join(" ").trim() || admin.email          : null;        await sendWelcomeNotice({          kind: sendError ? "send-failed" : "sent",          memberEmail: input.email,          groupNames: groups.map((g) => g.name),          createdBy: adminName,          detail: sendError,        }).catch((err) =>          console.error("[user.create] avis au club non envoyé :", err instanceof Error ? err.message : err),        );      }      return {        success: true,        user,      };    }),  /**   * Majorité, date de naissance et parent référent (admins). Un mineur peut être enregistré avant   * que tout soit connu (tri des comptes existants) : l'envoi au parent reste bloqué tant qu'il   * manque quelque chose. Majeur : les coordonnées du parent sont effacées.   */  setLegalInfo: protectedProcedure    .use(isAdmin)    .input(z.object({ userId: z.string().min(1), legal: legalInfoInput }))    .mutation(async ({ ctx, input }) => {      const u = await ctx.prisma.user.findUnique({ where: { id: input.userId }, select: { email: true } });      if (!u) throw new TRPCError({ code: "NOT_FOUND", message: "Compte introuvable." });      await ctx.prisma.user.update({        where: { id: input.userId },        data: legalInfoData(input.legal, u.email, { requireComplete: false }),        select: { id: true },      });      return { ok: true };    }),  /** Droit à l'image (admins) : autorisation recueillie par le club pour ce membre. */  setImageConsent: protectedProcedure    .use(isAdmin)    .input(z.object({ userId: z.string().min(1), consent: z.enum(["UNKNOWN", "GRANTED", "REFUSED"]) }))    .mutation(async ({ ctx, input }) => {      await ctx.prisma.user.update({        where: { id: input.userId },        data: { imageConsent: input.consent, imageConsentAt: new Date() },        select: { id: true },      });      return { ok: true };    }),  delete: protectedProcedure    .use(isAdmin)    .input(z.object({ id: z.string() }))    .mutation(async ({ ctx, input }) => {      // Règle métier, pas question de droit : l'administrateur a le droit de supprimer un compte,      // mais pas le sien (il perdrait l'accès, et le club pourrait se retrouver sans administrateur).      // L'interface désactive déjà le bouton ; c'est ici que la règle est garantie.      if (input.id === ctx.sessionClient.user.id) {        throw new TRPCError({ code: "FORBIDDEN", message: "Vous ne pouvez pas supprimer votre propre compte." });      }      const avatar = (await ctx.prisma.user.findUnique({ where: { id: input.id }, select: { avatar: true } }))?.avatar;      const deleted = await ctx.prisma.$transaction(async (tx) => {        // Formulaires de droit à l'image signés : gardés 5 ans comme preuve (purge nocturne).        await tx.imageConsentForm.updateMany({ where: { userId: input.id }, data: { detachedAt: new Date() } });        // `pageId` n'a pas de clé étrangère : sans ce nettoyage, les liens de        // la bio bloqueraient pour toujours la suppression de ses images.        await syncPageMediaReferences(tx, {          pageType: "INSTRUCTOR_BIO",          pageId: input.id,          newContent: null,        });        // Seul l'identifiant repart vers le navigateur : la ligne complète contient l'empreinte        // du mot de passe.        return tx.user.delete({          where: { id: input.id },          select: { id: true },        });      });      // Son portrait part avec le compte : un avatar n'est rattaché qu'à lui (aucune ligne      // MediaAsset ne le retient), il resterait sinon dans le stockage sans que rien ne l'atteigne.      // Après la transaction : un fichier ne se restaure pas si la base annule.      if (avatar) await removeAvatarFile(avatar);      return deleted;    }),  getCurrentUserProfile: protectedProcedure.query(async ({ ctx }) => {    const userId = ctx.sessionClient.user.id;    const user = await ctx.prisma.user.findUnique({      where: { id: userId },      select: userProfileSelect,    });    if (!user) {      throw new TRPCError({        code: "NOT_FOUND",        message: "Membre introuvable.",      });    }    return toUserProfile(user);  }),  getProfileById: protectedProcedure    .use(isAdmin)    .input(z.object({ id: z.string() }))    .query(async ({ ctx, input }) => {      const user = await ctx.prisma.user.findUnique({        where: { id: input.id },        select: userProfileSelect,      });      if (!user) {        throw new TRPCError({          code: "NOT_FOUND",          message: "Membre introuvable.",        });      }      return toUserProfile(user);    }),  /**   * L'utilisateur courant est-il titulaire, et quelle est sa bio ?   *   * Alimente l'éditeur du profil : la section n'apparaît que pour un   * titulaire, et se pré-remplit avec ce qu'il a déjà écrit. Le critère de   * titulaire est le MEME OR que `getInstructors` / `listPublicInstructors`.   */  getMyInstructorState: protectedProcedure.query(async ({ ctx }) => {    const userId = ctx.sessionClient.user.id;    const [user, isInstructor] = await Promise.all([      ctx.prisma.user.findUnique({        where: { id: userId },        select: { instructorBio: true, instructorOrder: true },      }),      isInstructorUser(ctx.prisma, userId),    ]);    return {      isInstructor,      bio: user?.instructorBio ?? null,      order: user?.instructorOrder ?? null,      // Où le sélecteur de médias s'ouvre : toute la bibliothèque pour un administrateur, son      // espace personnel pour un autre membre (le seul dont il puisse poser les fichiers).      mediaRoot: ctx.sessionClient.user.isAdmin        ? ctx.appRoot        : await resolvePersoBaseFolder({ prisma: ctx.prisma, appRoot: ctx.appRoot, userId }),    };  }),  /**   * Un instructeur enregistre SA PROPRE présentation.   *   * La cible est toujours `ctx.sessionClient.user.id`, jamais un id reçu en   * entrée : la garde « c'est mon profil » est structurelle. Aucune   * permission d'administration n'entre en jeu — on n'édite que soi.   *   * `bio` est un document du constructeur de pages (validé par son schéma), ou `null`   * pour retirer sa présentation. L'ordre est optionnel.   */  saveMyInstructorBio: protectedProcedure    .input(      z.object({        // Le même contrat que tout contenu du constructeur de pages : un document invalide est        // refusé à l'entrée, au lieu d'être enregistré tel quel.        bio: pageContentSchemaV1.nullable(),        order: z.number().int().nullable().optional(),      }),    )    .mutation(async ({ ctx, input }) => {      assertOwnAvatars(ctx.sessionClient.user.id, input.bio);      const userId = ctx.sessionClient.user.id;      // Seul un titulaire a une présentation publique. Un autre membre pourrait sinon référencer des      // fichiers, et les rendre servis au public, sans qu'aucune page ne les montre.      if (!(await isInstructorUser(ctx.prisma, userId))) {        throw new TRPCError({ code: "FORBIDDEN", message: "La présentation est réservée aux instructeurs." });      }      if (!ctx.sessionClient.user.isAdmin) {        // L'ordre de la page publique est une décision du club : un instructeur ne s'y place pas        // lui-même en tête.        if (input.order !== undefined) {          throw new TRPCError({ code: "FORBIDDEN", message: "L'ordre d'affichage est fixé par un administrateur." });        }        if (input.bio !== null) await assertBioMediaAllowed(ctx.prisma, userId, input.bio);      }      await ctx.prisma.$transaction(async (tx) => {        await tx.user.update({          where: { id: userId },          data: {            instructorBio: input.bio === null ? Prisma.DbNull : (input.bio as Prisma.InputJsonValue),            ...(input.order !== undefined              ? { instructorOrder: input.order }              : {}),          },        });        // Déclare les fichiers de la bibliothèque utilisés par la bio : sans        // ce lien, ils ne sont ni protégés, ni servis aux visiteurs.        await syncPageMediaReferences(tx, {          pageType: "INSTRUCTOR_BIO",          pageId: userId,          newContent: input.bio,        });      });      return { success: true };    }),  /**   * La page publique des instructeurs titulaires.   *   * PUBLIQUE : elle alimente une page ouverte à tous. Deux filtres —   *   1. titulaire : le MEME critere que `getInstructors` (rattachement a   *      une discipline, un cours ou un stage). Reutilise, pas redefini.   *   2. presente : `instructorBio` non nul, sinon on afficherait une carte   *      vide pour un titulaire qui ne s'est pas encore decrit.   *   * Tri par `instructorOrder` (les nuls en dernier), puis par nom.   */  listPublicInstructors: publicProcedure.query(async ({ ctx }) => {    const rows = await ctx.prisma.user.findMany({      where: {        AND: [          { instructorBio: { not: Prisma.DbNull } },          {            OR: [              { disciplinesAsInstructor: { some: {} } },              { coursesAsInstructor: { some: {} } },              { seminarsAsPrimaryAnimator: { some: {} } },              { seminarsAsAnimator: { some: {} } },            ],          },        ],      },      select: {        id: true,        firstName: true,        lastName: true,        pseudo: true,        avatar: true,        instructorBio: true,        instructorOrder: true,      },      orderBy: [        { instructorOrder: { sort: "asc", nulls: "last" } },        { lastName: "asc" },        { firstName: "asc" },      ],    });    return rows;  }),  /**   * Vivier d'AFFECTATION du select instructeur (≠ « titulaires » réels).   * Résout l'œuf-et-la-poule : membres du groupe ADMIN (le staff) OU déjà   * rattachés (pour ne perdre aucun instructeur existant, même non-admin).   * `getInstructors` / `listPublicInstructors` restent la vérité publique.   */  getAssignableInstructors: protectedProcedure.use(isAdmin).query(async ({ ctx }) => {    return ctx.prisma.user.findMany({      where: {        OR: [          { memberGroupMemberships: { some: { group: { isAdminGroup: true } } } },          { disciplinesAsInstructor: { some: {} } },          { coursesAsInstructor: { some: {} } },          { seminarsAsPrimaryAnimator: { some: {} } },          { seminarsAsAnimator: { some: {} } },          // Organisateur d'un évènement : sans cette ligne, un organisateur qui n'est ni admin ni          // instructeur disparaît du sélecteur, et le formulaire d'édition affiche « — Choisir — ».          { eventsAsOrganizer: { some: {} } },        ],      },      select: {        id: true,        firstName: true,        lastName: true,        pseudo: true,        email: true,      },      orderBy: [{ lastName: "asc" }, { firstName: "asc" }],    });  }),  /**   * Liste tous les users qui sont **factuellement** instructeurs — c'est-à-dire   * qui ont au moins une relation d'animation dans le club : ils animent   * une discipline, un cours, ou un stage (en tant qu'animateur principal   * ou secondaire).   *   * Le club n'a pas de rôle "instructor" nominal en schéma ; cette   * définition factuelle permet de peupler les sélecteurs des forms admin   * (Course, Stage, etc.) sans dépendre d'un signal qui n'existe pas.   *   * Si un jour tu veux désigner un nouvel instructeur qui n'anime encore   * rien, il faudra introduire un autre signal (rôle dédié ou flag   * `isInstructor` sur User) — auquel cas cette query devra évoluer.   *   * Sélection minimale (id + nom) suffisante pour l'affichage en dropdown.   * Tri par lastName puis firstName pour l'UX du select.   */  getInstructors: protectedProcedure.use(isAdmin).query(async ({ ctx }) => {    return ctx.prisma.user.findMany({      where: {        OR: [          { disciplinesAsInstructor: { some: {} } },          { coursesAsInstructor: { some: {} } },          { seminarsAsPrimaryAnimator: { some: {} } },          { seminarsAsAnimator: { some: {} } },        ],      },      select: {        id: true,        firstName: true,        lastName: true,        pseudo: true,        email: true,      },      orderBy: [{ lastName: "asc" }, { firstName: "asc" }],    });  }),  /**   * Adresse du club d'un membre (alias @<domaine du club>), saisie par un administrateur.   * Le domaine est celui de l'adresse de contact des Réglages du site (contact@akfc.fr par   * défaut) : on n'attribue pas d'adresse d'un autre domaine. Chaîne vide → adresse retirée.   */  setClubEmail: protectedProcedure    .use(isAdmin)    .input(z.object({ id: z.string().min(1), clubEmail: z.string().trim().max(254) }))    .mutation(async ({ ctx, input }) => {      const value = input.clubEmail.toLowerCase();      if (value !== "") {        if (!z.string().email().safeParse(value).success) {          throw new TRPCError({ code: "BAD_REQUEST", message: "Adresse e-mail invalide." });        }        const settings = await ctx.prisma.siteSettings.findUnique({ where: { id: "site" }, select: { contactEmail: true } });        const domain = (settings?.contactEmail ?? "contact@akfc.fr").split("@")[1]?.toLowerCase() ?? "akfc.fr";        if (!value.endsWith(`@${domain}`)) {          throw new TRPCError({ code: "BAD_REQUEST", message: `L'adresse du club doit se terminer par @${domain}.` });        }      }      await ctx.prisma.user.update({ where: { id: input.id }, data: { clubEmail: value || null } });      return { clubEmail: value || null };    }),  /**   * Les avatars qu'un bloc media-text ou float-text peut montrer (« utiliser l'avatar de X »).   *   * Un membre ne pose que SON avatar, administrateurs compris (`assertOwnAvatars`, vérifié par   * chaque enregistrement de contenu) : la liste ne contient donc que lui. Elle reste une liste   * pour que le sélecteur n'ait rien à changer. Inclut un membre SANS avatar (avatar `null`) :   * l'UI affiche un placeholder. `avatar` est la clé de stockage brute ; l'URL d'affichage est construite côté   * client comme pour l'avatar du header.   */  listAvatarCandidates: protectedProcedure.query(async ({ ctx }) => {    const self = ctx.sessionClient.user.id;    return ctx.prisma.user.findMany({      where: { id: self },      select: {        id: true,        firstName: true,        lastName: true,        pseudo: true,        avatar: true,      },      orderBy: [{ lastName: "asc" }, { firstName: "asc" }],    });  }),});