ORM Prisma avec Node.js et MySQL

npm install -D prisma@7 dotenv
npm install @prisma/client@7 @prisma/adapter-mariadb@7

// prisma.config.ts, à la racine du projet
import 'dotenv/config';
import { defineConfig } from 'prisma/config';

export default defineConfig({
  schema: 'prisma/schema.prisma',
  migrations: { path: 'prisma/migrations' },
  datasource: { url: process.env.DATABASE_URL },
});

# .env : la même base, sous forme d'adresse pour la ligne de commande Prisma
DATABASE_URL="mysql://applifrais_admin:mot-de-passe@localhost:3306/applifrais"

// prisma/schema.prisma
generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "mysql"
}

enum Role {
  visiteur
  comptable
}

enum Etat {
  CR
  CL
  VA
  MP
}

model Utilisateur {
  id         Int          @id @default(autoincrement())
  login      String       @unique @db.VarChar(30)
  nom        String       @db.VarChar(50)
  prenom     String       @db.VarChar(50)
  motDePasse String       @map("mot_de_passe") @db.VarChar(255)
  role       Role         @default(visiteur)
  fiches     FicheFrais[]

  @@map("utilisateur")
}

model FicheFrais {
  id               Int                 @id @default(autoincrement())
  visiteurId       Int                 @map("id_visiteur")
  mois             String              @db.Char(7)
  etat             Etat                @default(CR)
  montantValide    Decimal?            @map("montant_valide") @db.Decimal(8, 2)
  dateModification DateTime            @default(now()) @updatedAt @map("date_modification") @db.DateTime(0)
  visiteur         Utilisateur         @relation(fields: [visiteurId], references: [id])
  lignesForfait    LigneFraisForfait[]
  fraisHorsForfait FraisHorsForfait[]

  @@unique([visiteurId, mois])
  @@map("fiche_frais")
}

model FraisForfait {
  code    String              @id @db.Char(3)
  libelle String              @db.VarChar(50)
  montant Decimal             @db.Decimal(6, 2)
  lignes  LigneFraisForfait[]

  @@map("frais_forfait")
}

model LigneFraisForfait {
  ficheId     Int          @map("id_fiche")
  codeForfait String       @map("code_forfait") @db.Char(3)
  quantite    Int          @default(0)
  fiche       FicheFrais   @relation(fields: [ficheId], references: [id], onDelete: Cascade)
  forfait     FraisForfait @relation(fields: [codeForfait], references: [code])

  @@id([ficheId, codeForfait])
  @@map("ligne_frais_forfait")
}

model FraisHorsForfait {
  id           Int        @id @default(autoincrement())
  ficheId      Int        @map("id_fiche")
  date         DateTime   @map("date_frais") @db.Date
  libelle      String     @db.VarChar(100)
  montant      Decimal    @db.Decimal(8, 2)
  justificatif String?    @db.VarChar(255)
  fiche        FicheFrais @relation(fields: [ficheId], references: [id], onDelete: Cascade)

  @@map("frais_hors_forfait")
}

npx prisma generate

✔ Generated Prisma Client (7.10.1) to ./src/generated/prisma

// src/prisma.js
import { PrismaMariaDb } from '@prisma/adapter-mariadb';
import { PrismaClient } from './generated/prisma/client.ts';
import { config } from './config.js';

const adapter = new PrismaMariaDb({ ...config.db, connectionLimit: 10 });

export const prisma = new PrismaClient({ adapter });

// Les fiches clôturées de Lucas, les plus récentes d'abord, 20 par page
const fiches = await prisma.ficheFrais.findMany({
  where: { visiteurId: 7, etat: 'CL' },
  orderBy: [{ mois: 'desc' }, { id: 'desc' }],
  skip: 0,
  take: 20,
});

// Une fiche par sa clé primaire, ou null
const fiche = await prisma.ficheFrais.findUnique({ where: { id: 12 } });

// Une fiche avec son visiteur (trois champs seulement) et ses lignes
const detail = await prisma.ficheFrais.findUnique({
  where: { id: 12 },
  include: {
    visiteur: { select: { id: true, nom: true, prenom: true } },
    lignesForfait: { include: { forfait: true } },
  },
});

// Compter
const nb = await prisma.ficheFrais.count({ where: { etat: 'CL' } });

// Créer une fiche et ses quatre lignes en une seule opération (écriture imbriquée)
const forfaits = await prisma.fraisForfait.findMany({ select: { code: true } });
const nouvelle = await prisma.ficheFrais.create({
  data: {
    visiteurId: 7,
    mois: '2026-11',
    lignesForfait: { create: forfaits.map(({ code }) => ({ codeForfait: code, quantite: 0 })) },
  },
});

// Modifier une ligne précise (clé primaire composée)
await prisma.ligneFraisForfait.update({
  where: { ficheId_codeForfait: { ficheId: 12, codeForfait: 'KM' } },
  data: { quantite: 420 },
});

// Modifier sous condition : renvoie le nombre de lignes modifiées
const { count } = await prisma.ficheFrais.updateMany({
  where: { id: 12, etat: 'CR' },
  data: { etat: 'CL' },
});

// Supprimer
await prisma.fraisHorsForfait.delete({ where: { id: 58 } });

const [total, fiches] = await prisma.$transaction([
  prisma.ficheFrais.count({ where }),
  prisma.ficheFrais.findMany({ where, skip, take }),
]);

await prisma.$transaction(async (tx) => {
  const fiche = await tx.ficheFrais.findUnique({ where: { id } });
  if (fiche?.etat !== 'CL') {
    throw new ErreurApi(409, 'transition-interdite', "Changement d'état interdit", "La fiche n'est pas clôturée.");
  }
  return tx.ficheFrais.update({ where: { id }, data: { etat: 'VA', montantValide } });
});

montantUnitaire: Number(ligne.forfait.montant),            // Decimal → nombre
date: frais.date.toISOString().slice(0, 10),               // Date → "2026-10-14"

// src/depots/fiches.depot.prisma.js (extrait)
import { Prisma } from '../generated/prisma/client.ts';
import { prisma } from '../prisma.js';
import { ErreurApi } from '../erreurs.js';

function versFiche(fiche) {
  return {
    id: fiche.id,
    visiteurId: fiche.visiteurId,
    mois: fiche.mois,
    etat: fiche.etat,
    montantValide: fiche.montantValide === null ? null : Number(fiche.montantValide),
    dateModification: fiche.dateModification.toISOString(),
  };
}

export async function lister({ visiteurId, mois, etat, page, limite }) {
  const where = { visiteurId, mois, etat }; // une condition undefined est ignorée
  const [total, fiches] = await prisma.$transaction([
    prisma.ficheFrais.count({ where }),
    prisma.ficheFrais.findMany({
      where,
      orderBy: [{ mois: 'desc' }, { id: 'desc' }],
      skip: (page - 1) * limite,
      take: limite,
    }),
  ]);
  return { donnees: fiches.map(versFiche), pagination: { page, limite, total, pages: Math.ceil(total / limite) } };
}

export async function creer(visiteurId, mois) {
  const forfaits = await prisma.fraisForfait.findMany({ select: { code: true } });
  try {
    const fiche = await prisma.ficheFrais.create({
      data: {
        visiteurId,
        mois,
        lignesForfait: { create: forfaits.map(({ code }) => ({ codeForfait: code, quantite: 0 })) },
      },
    });
    return fiche.id;
  } catch (erreur) {
    if (erreur instanceof Prisma.PrismaClientKnownRequestError && erreur.code === 'P2002') {
      throw new ErreurApi(409, 'fiche-existante', 'Fiche déjà créée', `Une fiche existe déjà pour le mois ${mois}.`);
    }
    throw erreur;
  }
}

export async function changerEtat(id, etatAttendu, nouvelEtat, montantValide = null) {
  const { count } = await prisma.ficheFrais.updateMany({
    where: { id, etat: etatAttendu },
    data: { etat: nouvelEtat, ...(montantValide !== null && { montantValide }) },
  });
  return count === 1;
}

// N+1 : 1 requête pour les fiches, puis 1 par fiche
const fiches = await prisma.ficheFrais.findMany();
for (const fiche of fiches) {
  fiche.lignes = await prisma.ligneFraisForfait.findMany({ where: { ficheId: fiche.id } });
}

// Chargement anticipé : Prisma regroupe les lectures
const fichesAvecLignes = await prisma.ficheFrais.findMany({ include: { lignesForfait: true } });

// Sûr : gabarit étiqueté, ${7} devient un paramètre de requête préparée
const lignes = await prisma.$queryRaw`SELECT COUNT(*) AS n FROM fiche_frais WHERE id_visiteur = ${7}`;