Drizzle vs Prisma : choisir un ORM TypeScript sans tout le bruit autour

Drizzle ORM et Prisma sont les deux noms qui reviennent le plus souvent lors du choix d’un ORM pour un projet TypeScript. Ils résolvent le même problème, à savoir transformer l’accès à la base de données en code typé, mais ils partent d’idées opposées quant au degré de proximité vis-à-vis de SQL. Aucun des deux n’est une mauvaise option. Si votre équipe maîtrise déjà l’un d’eux, continuez à l’utiliser et consacrez votre temps au produit. La comparaison devient plus importante lorsque vous commencez quelque chose de nouveau ou que vous devez expliquer une configuration existante à vos collègues.

Les deux outils

Drizzle est apparu en 2022 et a rapidement gagné en popularité auprès des développeurs qui souhaitent un contrôle sans surcharge. Il privilégie TypeScript : les tables, les relations et les requêtes sont toutes déclarées en TypeScript. On peut le décrire comme une couche légère et typée par-dessus SQL. Les types sont inférés nativement, le SQL brut reste sécurisé en termes de types, et sa conception convient aux codes exigeants en termes de performance. PostgreSQL, MySQL, SQLite et SQL Server sont pris en charge.

Prisma est apparu plus tôt, en 2018, et a bâti sa réputation sur l’expérience des développeurs, la productivité et les outils mis à leur disposition. Le modèle de données se trouve dans un fichier .prisma écrit en Prisma Schema Language (PSL), et prisma generate le transforme en un client entièrement typé doté d’une API de haut niveau. Les relations sont gérées automatiquement, et l’écosystème est plus vaste et plus mature, incluant Prisma Studio, un navigateur et éditeur visuel pour vos données. Les bases de données prises en charge comprennent PostgreSQL, MySQL, SQLite et MongoDB, entre autres.

Définition du schéma

C’est ici que les philosophies diffèrent le plus visiblement, et le choix influencie le travail quotidien ainsi que la sécurité des types.

Drizzle : le code en premier

Un schéma Drizzle est simplement du TypeScript. Les tables, les colonnes et les relations utilisent le même langage que l’application, il n’y a donc pas d’étape de génération et les modifications apparaissent immédiatement dans votre éditeur.

import { pgTable, serial, varchar, text, integer, timestamp } from "drizzle-orm/pg-core";

// Authors table
export const authors = pgTable("authors", {
  id: serial("id").primaryKey(),
  name: varchar("name", { length: 100 }).notNull(),
  bio: text("bio"),
});

// Books table referencing Authors
export const books = pgTable("books", {
  id: serial("id").primaryKey(),
  title: varchar("title", { length: 150 }).notNull(),
  summary: text("summary"),
  authorId: integer("author_id")
    .notNull()
    .references(() => authors.id),
  publishedAt: timestamp("published_at").defaultNow(),
});

Comme les types sont déduits automatiquement, le résultat d’une requête possède une structure bien définie sans aucun fichier de schéma supplémentaire. Cela réduit les surprises en temps de exécution.

Prisma : le schéma en premier

Prisma conserve le modèle dans un fichier séparé .prisma :

model Author {
  id    Int     @id @default(autoincrement())
  name  String
  bio   String?
  books Book[]
}

model Book {
  id          Int      @id @default(autoincrement())
  title       String
  summary     String?
  publishedAt DateTime @default(now())
  authorId    Int
  author      Author   @relation(fields: [authorId], references: [id])
}

Le schéma est clairement séparé du code de l’application. Après chaque modification, prisma generate reconstruit le client afin que les types soient compatibles. Pour ceux qui ont peu d’expérience en SQL, cette abstraction est plus conviviale, car on travaille avec un client de haut niveau généré plutôt qu’avec une logique de type SQL. Le prix à payer est l’ajout d’une couche supplémentaire entre votre code et la base de données.

Rédaction des requêtes

Les deux solutions permettent d’écrire des requêtes vérifiées au niveau des types, mais leur syntaxe est différente.

Drizzle

Le constructeur de requêtes est délibérément simple et prévisible, et il ressemble à du SQL. Si vous êtes à l’aise avec les jointures et les clauses WHERE, il vous semble naturel, et ce que vous écrivez correspond étroitement à ce qui s’exécute dans la base de données. Cet exemple joint des livres à des auteurs, puis filtre et trie les résultats :

const results = await db
  .select({
    bookId: books.id,
    title: books.title,
    publishedAt: books.publishedAt,
    authorName: authors.name,
  })
  .from(books)
  .leftJoin(authors, eq(books.authorId, authors.id))
  .where(eq(authors.id, authorId))
  .orderBy(books.publishedAt);

Vous bénéficiez d’un contrôle fin et d’instructions SQL hautement prévisibles. L’écart notable par rapport à Prisma apparaît lors de la création de lignes liées. Drizzle ne permet pas d’écritures imbriquées, de sorte que chaque insertion relationnelle est gérée manuellement, généralement au sein d’une transaction afin que les éléments restent cohérents :

const result = await db.transaction(async (tx) => {
  const [newAuthor] = await tx.insert(authors).values({
    name: "Alice",
    bio: "Fantasy author",
  }).returning({ id: authors.id });

  const [newBook] = await tx.insert(books).values({
    title: "The Dream Forest",
    authorId: newAuthor.id,
  }).returning();

  return { newAuthor, newBook };
});

La transparence totale est l’avantage. Plus de code générique en est le inconvénient.

Prisma

Prisma emprunte une approche inverse. Vous appelez des méthodes sur un client généré automatiquement, tandis que la base de données reste accessible via des méthodes de style objet. La même recherche devient :

const results = await prisma.book.findMany({
  where: { authorId },
  select: {
    id: true,
    title: true,
    publishedAt: true,
    author: {
      select: { name: true },
    },
  },
  orderBy: { publishedAt: "asc" },
});

Personne n’a besoin de penser en SQL ici, ce qui explique en grande partie la popularité de Prisma. Il se distingue également lors de la création de données liées, car les écritures imbriquées sont prises en charge. Un livre et son auteur peuvent être créés en une seule requête :

const newBook = await prisma.book.create({
  data: {
    title: "The Dream Forest",
    summary: "A surreal adventure.",
    author: {
      create: {
        name: "Alice",
        bio: "Fantasy author",
      },
    },
  },
});

Aucune clé étrangère n’a besoin d’être configurée manuellement. Ce que vous perdez, c’est la visibilité, car le SQL qui s’exécute réellement reste caché, ce qui vous donne moins de contrôle que avec Drizzle.

Migrations

Changer le schéma au fil du temps est important dans tout projet réel, et les deux outils gèrent bien cette tâche.

Drizzle

Puisque le schéma est en TypeScript, il constitue la source de vérité, et la CLI (drizzle-kit) génère des migrations à partir des différences entre vos définitions. Dans un flux de travail basé sur les migrations, vous commencez par générer :

npx drizzle-kit generate

Cela compare l’état actuel avec votre schéma TypeScript et génère un fichier de migration contenant les modifications SQL, que vous pouvez modifier manuellement avant de l’utiliser. Son application se fait via une commande distincte :

npx drizzle-kit migrate

Pour un prototypage rapide, il existe également un raccourci :

npx drizzle-kit push

Celui-ci envoie directement le schéma TypeScript dans la base de données sans créer de fichier de migration. C’est rapide et pratique au début, mais en l’absence d’historique des migrations, il ne convient pas pour un environnement de production.

Prisma

Avec Prisma, le fichier .prisma est la source de vérité, et l’outil génère le SQL correspondant à chaque modification. L’application des migrations enregistrées dans une base de données utilise :

npx prisma migrate deploy

Pendant le développement, prisma migrate dev est la commande qui crée un nouveau dossier de migration contenant des scripts SQL, l’applique et met à jour la table d’historique. Cela permet un flux de travail ordonné et largement automatisé.

Il existe également un raccourci pour la création de prototypes :

npx prisma db push

Il met à jour la base de données directement, comme le mécanisme push de Drizzle, sans fichiers de migration, ce qui en fait un outil destiné uniquement à un usage non productionnel.

Transactions

Les deux prennent en charge les transactions, avec de légères différences de style.

Drizzle utilise db.transaction avec une fonction de rappel. Chaque requête à l’intérieur fonctionne ou échoue ensemble, et comme vous restez proche du SQL, vous contrôlez précisément ce qui se passe dans le bloc :

await db.transaction(async (tx) => {
  const newAuthor = await tx.insert(authors).values({
    name: "Alice Walker",
    bio: "Pulitzer Prize-winning author",
  }).returning();

  await tx.insert(books).values({
    title: "Journey to the Mountains",
    summary: "A story about adventure and discovery.",
    authorId: newAuthor[0].id,
  });
});

Prisma propose prisma.$transaction, qui accepte soit un tableau de requêtes, soit une fonction de rappel asynchrone. Les validations et les annulations sont automatiques :

await prisma.$transaction(async (tx) => {
  const newAuthor = await tx.author.create({
    data: {
      name: "Alice Walker",
      bio: "Pulitzer Prize-winning author",
    },
  });

  await tx.book.create({
    data: {
      title: "Journey to the Mountains",
      summary: "A story about adventure and discovery.",
      authorId: newAuthor.id,
    },
  });
});

Performance

C’est ici que les philosophies sous-jacentes ont le plus d’importance.

Drizzle est léger, et ses requêtes correspondent presque directement aux opérations de base de données, ce qui réduit considérablement les coûts d’abstraction. Cela est utile pour les requêtes complexes, les opérations en masse et les codes à fort débit. Avec un contrôle total sur les jointures, les transactions et la structure des requêtes, l’optimisation pour la vitesse devient plus facile, mais cela suppose que vous maîtrisez SQL et la conception de bases de données.

Le client généré par Prisma cache SQL derrière une API de haut niveau. Cela entraîne une légère perte de performance, bien que dans la plupart des applications ordinaires la différence soit négligeable. Les relations, les requêtes imbriquées et les résultats typés sont fournis gratuitement, ce qui accélère le développement. Cette commodité peut parfois entraîner des requêtes SQL moins optimisées que celles écrites manuellement avec soin.

Choix entre les deux

Tous deux sont des ORM modernes compatibles avec TypeScript, offrant sécurité des types, migrations, relations et transactions ; la décision dépend donc des priorités.

Choisissez Drizzle si vous souhaitez rester proche de SQL, conserver le contrôle sur les requêtes et les migrations, et obtenir des performances prévisibles même avec des charges de travail lourdes ou complexes. TypeScript sert de source unique de vérité, et rien n’est caché.

Choisissez Prisma si l’équipe veut avancer rapidement, se concentrer sur les fonctionnalités et s’appuyer sur l’automatisation pour les migrations, les requêtes et les relations. Le modèle basé sur le schéma et le client généré fournissent une API claire et de haut niveau, facile à utiliser pour les débutants.

En bref :

• Schéma : code TypeScript (Drizzle) contre un fichier .prisma accompagné de génération (Prisma).
• Requêtes : de type SQL et explicites contre un style objet et abstrait.
• Écritures imbriquées : manuelles dans Drizzle, intégrées dans Prisma.

Performance : plus léger et plus facile à contrôler, contre un léger surcoût pour plus de commodité.