Multi-tenant avec Prisma et tRPC : isoler les données par organisation

// ❌ Pattern dangereux : oubliable
export const clientRouter = createTRPCRouter({
  getAll: staffProcedure.query(async ({ ctx }) => {
    return ctx.db.client.findMany({
      // Si cette ligne manque → fuite de données entre tenants
      where: { organizationId: ctx.session.user.organizationId },
    });
  }),
});

// src/lib/prisma-org-scope.ts
 
// Modèles qui portent un organizationId direct
const ORG_SCOPED_MODELS = new Set([
  "client",
  "invoice",
  "quote",
  "project",
  "employee",
  // ... 30+ autres modèles
]);
 
export function createOrgDb(db: PrismaClient, organizationId: string) {
  return db.$extends({
    query: {
      $allModels: {
        async findMany({ model, args, query }) {
          if (ORG_SCOPED_MODELS.has(model.toLowerCase())) {
            args.where = { ...args.where, organizationId };
          }
          return query(args);
        },
 
        async findFirst({ model, args, query }) {
          if (ORG_SCOPED_MODELS.has(model.toLowerCase())) {
            args.where = { ...args.where, organizationId };
          }
          return query(args);
        },
      },
    },
  });
}

// src/server/api/trpc.ts
import { createOrgDb } from "~/lib/prisma-org-scope";
 
async function createTRPCContext({ req }: { req: NextRequest }) {
  const session = await auth();
  const organizationId = session?.user?.organizationId;
 
  return {
    db, // Accès complet (admin, webhooks)
    orgDb: organizationId // Accès scopé (routers normaux)
      ? createOrgDb(db, organizationId)
      : null,
    session,
  };
}

// src/server/api/routers/client.ts
export const clientRouter = createTRPCRouter({
  // ✅ Aucun filtre manual : orgDb s'en charge
  getAll: staffProcedure.query(async ({ ctx }) => {
    return ctx.orgDb.client.findMany({
      orderBy: { createdAt: "desc" },
    });
  }),
 
  getById: staffProcedure
    .input(z.object({ id: z.string() }))
    .query(async ({ ctx, input }) => {
      // findFirst (jamais findUnique) pour que le filtre organizationId s'applique
      const client = await ctx.orgDb.client.findFirst({
        where: { id: input.id },
      });
      if (!client) throw new TRPCError({ code: "NOT_FOUND" });
      return client;
    }),
});

// ❌ Dangereux : findUnique n'est pas couvert par l'extension
const client = await ctx.orgDb.client.findUnique({
  where: { id: input.id },
  // organizationId n'est PAS ajouté automatiquement
});
 
// ✅ Sûr : findFirst est couvert par l'extension
const client = await ctx.orgDb.client.findFirst({
  where: { id: input.id },
  // organizationId est ajouté par $extends
});

// Création : toujours inclure organizationId
create: staffProcedure
  .input(createClientSchema)
  .mutation(async ({ ctx, input }) => {
    return ctx.db.client.create({
      data: {
        ...input,
        organizationId: ctx.session.user.organizationId, // ← obligatoire
      },
    });
  }),
 
// Mise à jour : organizationId dans le WHERE, pas seulement dans les data
update: staffProcedure
  .input(updateClientSchema)
  .mutation(async ({ ctx, input }) => {
    return ctx.db.client.update({
      where: {
        id: input.id,
        organizationId: ctx.session.user.organizationId, // ← protection IDOR
      },
      data: input.data,
    });
  }),

// src/lib/permissions/matrix.ts
export const PERMISSION_MATRIX = {
  ADMIN: ["*"], // Tout
  DIRECTION: ["facturation:*", "crm:*"], // Finance + CRM
  MANAGER: ["crm:read", "crm:create"], // CRM en lecture/création
  CLIENT: ["portal:read"], // Portail client uniquement
} as const;

// Utilisation dans les routers
export const invoiceRouter = createTRPCRouter({
  create: requirePermission("facturation:create")
    .input(createInvoiceSchema)
    .mutation(async ({ ctx, input }) => {
      // Accès garanti : organisation filtrée + permission vérifiée
    }),
});

// InvoiceLine n'a pas organizationId : mais Invoice en a un
const line = await ctx.db.invoiceLine.findFirst({
  where: {
    id: input.id,
    invoice: {
      // ← filtre via le parent
      organizationId: ctx.session.user.organizationId,
    },
  },
});

model Invoice {
  organizationId String
  @@index([organizationId])
}

// src/__tests__/security/tenant-isolation.test.ts
it("ne peut pas lire les clients d'une autre organisation", async () => {
  const clientOrg1 = await createClient({ organizationId: "org-1" });
 
  const caller = createCaller({ organizationId: "org-2" });
 
  // Doit retourner NOT_FOUND, pas les données de org-1
  await expect(
    caller.client.getById({ id: clientOrg1.id }),
  ).rejects.toMatchObject({ code: "NOT_FOUND" });
});