Accueil / Articles

Prisma ORM 6.0/7.0 : La révolution du compilateur de requêtes — 3,4 fois

Prisma ORM 6 et 7 remplacent le moteur de requêtes Rust par un compilateur de requêtes TypeScript : pourquoi Rust était lent, la nouvelle architecture et les économies de taille du fichier.

Éditeur : REACTAPP.TOP11 min de lecture2440 mots

Sources: Prisma ORM 6.0/7.0: The Query Compiler Revolution — 3.4x Faster Queries, 90% Smaller Bundles, and TypeScript-First Architecture

Utilisez ceci comme une version révisée destinée aux opérateurs des idées présentées dans « Prisma ORM 6.0/7.0 : La révolution du compilateur de requêtes — des requêtes 3,4 fois plus rapides, des bundles 90 % plus petits et une architecture axée sur TypeScript » : étapes claires, emplacements de code ordonnés et notes de récupération qui survivent au transfert. L’étape « Aperçu » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce du coût évite les factures inattendues lorsque le processus passe de la démonstration aux environnements partagés.

Partie 1 : L’architecture du compilateur de requêtes

Pour la phase 1 « La requête », définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Ajoutez un test de fumée qui exécute le chemin critique dans l’CI en utilisant des fixtures, et non des API payantes en temps réel, chaque fois que le budget le permet.

Pourquoi Rust était lent (malgré sa vitesse)

Pour l’étape « Pourquoi Rust était lent », définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure. Ajoutez un test de fumée qui exerce le parcours critique dans l’CI à l’aide de fichiers de configuration, et non d’API payantes en ligne, chaque fois que le budget le permet.

TypeScript Client
    ↓ (serialize to JSON)
Rust Query Engine (14MB binary)
    ↓ (deserialize JSON)
    ↓ (execute query plan)
    ↓ (serialize results to JSON)
TypeScript Client (deserialize)
    ↓ (use results)

Nouvelle architecture : Compilateur de requêtes (TypeScript + WASM)

Pour l’étape du New Architecture Query Compiler, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Ajoutez un test de base qui exerce le chemin critique dans l’CI à l’aide de fichiers de configuration, et non d’API payantes en ligne, dès que le budget le permet. Pour l’étape du New Architecture Query Compiler, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce du coût évite les factures inattendues lorsque le processus passe de la démonstration à un environnement partagé.

TypeScript Client
    ↓ (Query Compiler compiles query plan)
    ↓ (execute plan in same process)
    ↓ (return results immediately)
TypeScript Client (no deserialization needed)
    ↓ (use results)
Operation: findMany with 25,000 records

Rust Query Engine: 185 ms
Query Compiler: 55 ms
Improvement: 3.4x faster (130ms serialization eliminated)
---
Operation: findMany with take=2000
Rust Query Engine: 6.6 ms
Query Compiler: 3.1 ms
Improvement: 2.1x faster
---
Operation: Complex JOINs
Rust Query Engine: 207 ms
Query Compiler: 130 ms
Improvement: 1.6x faster

Réduction de la taille du paquet : diminution de 85 à 90 %

Lors du traitement de l’étape de réduction de la taille du paquet à 85 %, notez d’abord les éléments requis : entrées nécessaires, signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Rédigez un petit guide d’utilisation : comment rotationner les clés, comment vider la file d’attente, comment revenir en arrière après une dernière ingestion.

Partie 2 : Stabilité de Prisma 6.0/7.0 et changements perturbateurs

Lorsque vous travaillez sur l’étape Partie 2 Prisma 6, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Rédigez un petit manuel opérationnel : comment rotationner les clés, comment vider la file d’attente, comment annuler la dernière ingestion.

Migration depuis v5 : modifications du schéma PostgreSQL

Lors du traitement de l’étape de migration depuis PostgreSQL v5, notez d’abord les exigences : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une responsabilité précise plutôt qu’un processus embrouillé. Rédigez un petit manuel d’utilisation : comment rotationner les clés, vider la file d’attente, annuler la dernière ingestion. Lors du traitement de l’étape de migration depuis PostgreSQL v5, notez d’abord les exigences : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés.

-- Prisma v5
CREATE TABLE "_PostToTag" (
    "A" INTEGER NOT NULL,
    "B" INTEGER NOT NULL
);

CREATE UNIQUE INDEX "_PostToTag_AB_unique" ON "_PostToTag"("A", "B");
-- Prisma v6+
CREATE TABLE "_PostToTag" (
    "A" INTEGER NOT NULL,
    "B" INTEGER NOT NULL,

    CONSTRAINT "_PostToTag_AB_pkey" PRIMARY KEY ("A", "B")
);
ALTER TABLE "_PostToTag"
  DROP CONSTRAINT "_PostToTag_AB_unique",
  ADD CONSTRAINT "_PostToTag_AB_pkey" PRIMARY KEY ("A", "B");

Gestion des erreurs : suppression de NotFoundError

La phase de suppression de NotFoundError dans la gestion des erreurs fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Conservez les configurations en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Fixez les versions des dépendances et enregistrez le digest de l’image utilisée pour exécuter la démonstration. La reproductibilité vaut mieux que les connaissances propres à un groupe.

import { NotFoundError } from '@prisma/client';

try {
  const user = await prisma.user.findUniqueOrThrow({
    where: { id: 'invalid' }
  });
} catch (e) {
  if (e instanceof NotFoundError) {
    // Handle not found
  }
}
import { PrismaClientKnownRequestError } from '@prisma/client';

try {
  const user = await prisma.user.findUniqueOrThrow({
    where: { id: 'invalid' }
  });
} catch (e) {
  if (e instanceof PrismaClientKnownRequestError && e.code === 'P2025') {
    // P2025 = record not found
  }
}
// Codemod-friendly pattern
const isNotFound = (error: unknown) =>
  error instanceof PrismaClientKnownRequestError && error.code === 'P2025';

// Old code
if (e instanceof NotFoundError) { ... }
// New code
if (isNotFound(e)) { ... }

Mots-clés réservés : async, await, using

Les mots-clés réservés async await fonctionnent le mieux lorsqu’ils sont considérés comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de rollback avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité vaut mieux que les connaissances propres à un groupe.

// ❌ Will not compile in v6+
model async {
  id Int @id
}

// ✅ Renamed
model AsyncTask {
  id Int @id
}

Partie 3 : Nouvelles fonctionnalités en v6 et v7

La phase des nouvelles fonctionnalités de la partie 3 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un processus embrouillé. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité vaut mieux que les connaissances internes au groupe.

Recherche plein texte : passer de la version bêta

La recherche de texte intégral issue de la phase pilote fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec ainsi que la note de réversion avant d’élargir le périmètre. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définez des critères de succès et refusez toute mise en œuvre partielle silencieuse. Fixez les versions des dépendances et enregistrez le digest de l’image ayant servi à exécuter la démonstration. La reproductibilité prime sur les connaissances propres à un groupe.

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

model Post {
  id       Int    @id @default(autoincrement())
  title    String
  body     String

  @@fulltext([title, body])
}


// Query using full-text search
const results = await prisma.post.findMany({
  where: {
    OR: [
      { title: { search: 'database' } },
      { body: { search: 'database' } }
    ]
  }
});
generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["fullTextSearchPostgres"]
}

Vues SQL avec relations (v6+)

La phase des vues SQL avec relations fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec ainsi que la note de réversion avant d’élargir le périmètre. Notez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Identifiez les versions nécessaires en raison de dépendances et enregistrez le résumé de l’image ayant servi à exécuter la démonstration. La reproductibilité est supérieure aux connaissances propres à un groupe restreint.

view UserStats {
  id              Int     @id
  userId          Int
  totalPosts      Int
  averageRating   Float

  user            User    @relation(fields: [userId], references: [id])
}

model User {
  id       Int        @id
  name     String
  stats    UserStats?  // Relation from model to view
}
const user = await prisma.user.findUnique({
  where: { id: 1 },
  include: { stats: true }  // Works now!
});

Soutien pgvector (accès anticipé à partir de v6.6+)

La phase d’accès anticipé de pgvector Support fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec ainsi que la note de réversion avant d’élargir le périmètre. Conservez les configurations en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité vaut mieux que les connaissances propres à un groupe.

model Embedding {
  id    Int     @id @default(autoincrement())
  text  String
  vector Unsupported("vector")?  // pgvector type
}
// Query embeddings (requires pgvector extension)
const similar = await prisma.$queryRaw`
  SELECT * FROM "Embedding"
  ORDER BY vector <-> $1
  LIMIT 5
`;

prisma.config.ts (v6.4+)

La configuration Prisma Config TS v6 en mode stage fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de rollback avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité prime sur les connaissances propres à un groupe.

// prisma.config.ts
import { defineConfig } from '@prisma/internals';

export default defineConfig({
  datasources: {
    db: {
      url: process.env.DATABASE_URL,
      directUrl: process.env.DIRECT_DATABASE_URL
    }
  },
  client: {
    skipValidation: false
  },
  accelerate: {
    enabled: true
  }
});

Rédesign de Prisma Studio (v7+)

La phase de redessin de Prisma Studio v7 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts étendus. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un processus embrouillé. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité vaut mieux que les connaissances internes au groupe. La phase de redessin de Prisma Studio v7 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de la démonstration aux environnements partagés.

Partie 4 : Stratégie de migration v5 → v7

Pour l’étape de la Stratégie de migration 4, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Ajoutez un test de fumée qui exécute le chemin critique dans l’environnement CI à l’aide de fichiers de configuration, et non d’API payantes en production, chaque fois que le budget le permet.

Mise à niveau étape par étape

Pendant l’étape de mise à niveau pas à pas, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’améliorations ultérieures. Ajoutez un test de fumée qui exerce le parcours critique dans l’environnement CI à l’aide de fichiers de configuration, et non d’API payantes en production, chaque fois que le budget le permet.

npm install @prisma/client@latest
npm install -D prisma@latest
# Check if you use any deprecated patterns
grep -r "NotFoundError" src/  # Needs updating
grep -r "async\|await\|using" prisma/schema.prisma  # Can't be model names
npx prisma migrate dev --name upgrade_to_v7
// Replace NotFoundError
- if (e instanceof NotFoundError) {
+ if (e instanceof PrismaClientKnownRequestError && e.code === 'P2025') {
npm test
npx prisma db push --preview-features  # Validate schema

Stratégie de rollback

Pour l’étape de la stratégie de rollback, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Ajoutez un test de fumée qui met en œuvre le chemin critique dans les processus CI à l’aide de fichiers de configuration, et non d’API payantes en temps réel, chaque fois que le budget le permet.

# Revert migration
npx prisma migrate resolve --rolled-back upgrade_to_v7

# Downgrade Prisma
npm install @prisma/client@5
npm install -D prisma@5
# Regenerate Prisma Client
npx prisma generate

Partie 5 : Impact sur les performances dans le monde réel

Démarrage en froid des solutions serverless : exemple Lambda

Package size: 250MB
AWS Lambda cold start time: 3.2 seconds
Database query time: 450ms (serialization overhead)
Total latency per request: 3.65 seconds
Package size: 8MB
AWS Lambda cold start time: 0.8 seconds (75% faster)
Database query time: 130ms (70% faster)
Total latency per request: 0.93 seconds (75% faster)

Recherche de produits en e-commerce

Query time: 2.3 seconds
Server CPU: 45%
Memory: 580MB
Cost per request: ~$0.0008
Query time: 640ms (3.6x faster)
Server CPU: 12%
Memory: 145MB (75% reduction)
Cost per request: ~$0.0002 (75% cheaper)

Conclusion

Liste de contrôle opérationnel