Drizzle ORM : le query builder TypeScript léger et performant

Pourquoi le choix d’un ORM TypeScript est devenu stratégique

Dans l’écosystème JavaScript/TypeScript moderne, le choix de la couche d’accès aux données influence directement la performance, la maintenabilité et la vélocité de développement d’un projet. Pendant des années, les développeurs se sont tournés vers des solutions éprouvées comme Sequelize, TypeORM ou Prisma. Mais depuis 2022, un nouveau venu bouscule la donne : Drizzle ORM.

Avec plus de 25 000 étoiles sur GitHub, une croissance fulgurante sur npm (plus de 1,5 million de téléchargements mensuels début 2025) et une philosophie radicalement différente, Drizzle ORM mérite une analyse approfondie. C’est exactement ce que nous allons faire dans cet article.

Drizzle ORM : présentation et philosophie

Un ORM qui pense en SQL, pas contre le SQL

La plupart des ORM traditionnels cherchent à masquer le SQL derrière des abstractions orientées objet. Drizzle ORM prend le parti inverse : il considère que le SQL est un langage puissant que les développeurs connaissent déjà, et propose une API TypeScript qui épouse fidèlement la syntaxe SQL.

Concrètement, si vous savez écrire un SELECT ... FROM ... WHERE ... JOIN, vous savez utiliser Drizzle. La courbe d’apprentissage est quasiment nulle pour un développeur familier avec les bases de données relationnelles.

Les piliers de Drizzle ORM

• TypeScript-first : le schéma est défini en TypeScript pur, pas dans un langage de schéma propriétaire.
• 0 dépendance : le cœur de Drizzle n’embarque aucune bibliothèque tierce.
• ~7,4 Ko en taille de bundle (gzippé), contre ~15 Mo pour le query engine de Prisma.
• SQL-like API : la syntaxe reflète le SQL que vous connaissez.
• Serverless-ready : parfaitement adapté aux environnements edge (Cloudflare Workers, Vercel Edge, AWS Lambda).
• Support multi-bases : PostgreSQL, MySQL, SQLite, Turso, Neon, PlanetScale, Supabase.

Définir son schéma : l’élégance du TypeScript pur

L’une des forces majeures de Drizzle est la définition du schéma directement dans vos fichiers .ts. Pas de fichier .prisma, pas de décorateurs complexes : du TypeScript standard.

Exemple de schéma PostgreSQL

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

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: varchar('name', { length: 255 }).notNull(),
  email: varchar('email', { length: 255 }).notNull().unique(),
  age: integer('age'),
  createdAt: timestamp('created_at').defaultNow().notNull(),
});

export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: varchar('title', { length: 500 }).notNull(),
  content: varchar('content', { length: 10000 }),
  authorId: integer('author_id').references(() => users.id).notNull(),
  publishedAt: timestamp('published_at'),
});

Ce schéma est immédiatement exploitable par le query builder et par le système de migrations. Aucune étape de génération (prisma generate) n’est nécessaire. Le typage est inféré automatiquement : quand vous faites une requête sur la table users, TypeScript connaît les types exacts de chaque colonne.

Le query builder en action

Voici où Drizzle ORM révèle toute sa puissance. La syntaxe est à la fois concise et proche du SQL, ce qui la rend lisible même pour un DBA qui ne connaîtrait pas TypeScript.

Requêtes CRUD classiques

import { db } from './db';
import { users, posts } from './schema';
import { eq, gt, desc } from 'drizzle-orm';

// SELECT — tous les utilisateurs de plus de 25 ans
const adultUsers = await db
  .select()
  .from(users)
  .where(gt(users.age, 25))
  .orderBy(desc(users.createdAt));

// INSERT — créer un utilisateur
const newUser = await db
  .insert(users)
  .values({ name: 'Alice', email: 'alice@example.com', age: 30 })
  .returning();

// UPDATE
await db
  .update(users)
  .set({ age: 31 })
  .where(eq(users.email, 'alice@example.com'));

// DELETE
await db
  .delete(users)
  .where(eq(users.id, 42));

Jointures typées

// INNER JOIN — récupérer les posts avec le nom de l'auteur
const postsWithAuthors = await db
  .select({
    postTitle: posts.title,
    authorName: users.name,
    publishedAt: posts.publishedAt,
  })
  .from(posts)
  .innerJoin(users, eq(posts.authorId, users.id))
  .where(eq(users.name, 'Alice'));

Notez que le résultat est entièrement typé : postsWithAuthors est un tableau d’objets avec les propriétés postTitle: string, authorName: string et publishedAt: Date | null. Zéro assertion, zéro cast.

L’API relationnelle (Relational Queries)

Pour les cas où la syntaxe SQL-like est trop verbeuse, Drizzle propose également une API relationnelle déclarative qui rappelle Prisma :

const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: true,
  },
  where: (users, { gt }) => gt(users.age, 25),
  limit: 10,
});

Vous obtenez le meilleur des deux mondes : la puissance du SQL quand vous en avez besoin, et une API déclarative pour les cas simples.

Drizzle vs Prisma vs TypeORM : le comparatif

Pour éclairer votre choix, voici un tableau comparatif basé sur des critères concrets :

Critère	Drizzle ORM	Prisma	TypeORM
Taille du bundle	~7,4 Ko	~15 Mo (query engine)	~2 Mo
Dépendances	0	Moteur Rust + client JS	Nombreuses
Définition du schéma	TypeScript pur	Fichier .prisma (DSL)	Décorateurs TS
Génération de code	Non nécessaire	Obligatoire (prisma generate)	Non
Serverless / Edge	✅ Natif	⚠️ Complexe (taille)	❌ Peu adapté
Performances (requêtes simples)	~0,2 ms overhead	~0,8 ms overhead	~1,2 ms overhead
Jointures complexes	Excellentes (SQL natif)	Limitées (N+1 fréquent)	Bonnes
TypeSafety	Inférence complète	Bonne (post-génération)	Partielle
Courbe d’apprentissage	Faible (si SQL connu)	Moyenne	Élevée
Maturité	Jeune mais stable	Mature	Mature
Étoiles GitHub (2025)	~25 000	~42 000	~34 000

Ce que disent les benchmarks

Selon les benchmarks publiés par la communauté (notamment ceux de Porsager et des tests internes partagés sur le blog de Drizzle) :

• Drizzle est 2 à 5 fois plus rapide que Prisma sur les requêtes SELECT avec jointures.
• L’overhead par requête est quasiment nul car Drizzle génère directement la chaîne SQL sans passer par un moteur intermédiaire.
• En environnement serverless (cold start), Drizzle démare en quelques millisecondes contre plusieurs centaines pour Prisma (chargement du query engine).

Ces chiffres expliquent pourquoi de nombreuses équipes migrent vers Drizzle pour leurs architectures edge et serverless.

Les migrations avec Drizzle Kit

Drizzle fournit un outil CLI compagnon, Drizzle Kit, qui gère les migrations de manière élégante :

# Générer une migration à partir du diff entre le schéma et la base
npx drizzle-kit generate

# Appliquer les migrations
npx drizzle-kit migrate

# Pousser le schéma directement (mode prototypage)
npx drizzle-kit push

# Ouvrir Drizzle Studio (interface visuelle)
npx drizzle-kit studio

Drizzle Studio est un bonus appréciable : une interface web locale pour explorer vos données, exécuter des requêtes et déboguer votre schéma. Pas besoin d’installer un client SQL séparé.

Les migrations générées sont des fichiers SQL purs, versionnables et lisibles. Pas de fichier JSON obscur ni de format propriétaire.

Cas d’usage idéaux pour Drizzle ORM

Applications serverless et edge

C’est le terrain de prédilection de Drizzle. Avec un bundle minuscule et zéro dépendance, il s’intègre parfaitement avec :

• Cloudflare Workers (avec D1 ou Turso)
• Vercel Edge Functions
• AWS Lambda (réduction drastique du cold start)
• Deno Deploy

Chez Lueur Externe, en tant que partenaire certifié AWS Solutions Architect, nous constatons que Drizzle ORM est devenu un choix naturel pour les architectures serverless que nous déployons pour nos clients. Le gain en temps de démarrage à froid est mesurable et significatif.

Projets Next.js et applications full-stack

Drizzle s’intègre de manière fluide avec Next.js (App Router et Server Components), Nuxt.js, Remix et SvelteKit. La compatibilité avec les Server Actions de Next.js est particulièrement réussie :

// app/actions/users.ts — Next.js Server Action
'use server';

import { db } from '@/lib/db';
import { users } from '@/lib/schema';
import { eq } from 'drizzle-orm';

export async function getUserByEmail(email: string) {
  const result = await db
    .select()
    .from(users)
    .where(eq(users.email, email))
    .limit(1);

  return result[0] ?? null;
}

APIs performantes et microservices

Pour les APIs REST ou GraphQL à fort trafic, Drizzle offre un overhead minimal qui se traduit directement en une meilleure capacité de traitement (throughput). Combiné avec Fastify ou Hono, vous obtenez un stack backend TypeScript d’une efficacité redoutable.

Intégration avec les bases de données modernes

Drizzle ORM ne se contente pas de supporter les bases classiques. Il brille particulièrement avec les bases de données serverless de nouvelle génération :

• Neon (PostgreSQL serverless) : driver natif, connexion via WebSocket.
• PlanetScale (MySQL serverless) : support complet via le driver HTTP.
• Turso (SQLite distribué) : intégration native, idéal pour l’edge.
• Supabase : compatible via le pool de connexions.
• Vercel Postgres : driver natif fourni.

Cette compatibilité étendue en fait un choix stratégique pour les projets qui anticipent une scalabilité horizontale sans se lier à un fournisseur unique.

Limites et points d’attention

Pour être honnête et complet, voici les aspects où Drizzle n’est pas (encore) le meilleur choix :

• Écosystème plus jeune : moins de tutoriels, de plugins et de ressources que Prisma. La documentation s’améliore rapidement mais reste parfois lacunaire sur les cas avancés.
• Pas d’introspection avancée : si vous partez d’une base existante complexe, la génération du schéma TypeScript depuis la base (introspection) est fonctionnelle mais moins complète que celle de Prisma.
• Communauté plus petite : en cas de bug rare, vous trouverez moins de réponses sur Stack Overflow. Le Discord officiel est cependant très actif.
• Requêtes brutes complexes : pour les requêtes SQL très avancées (CTE récursives, fonctions de fenêtrage complexes), vous devrez parfois recourir à la syntaxe sql template literal, ce qui reste tout à fait possible mais moins guidé par le typage.

Ces limites sont à relativiser. Drizzle évolue rapidement, avec des releases fréquentes et une roadmap ambitieuse.

Bonnes pratiques pour adopter Drizzle ORM

Fort de notre expérience chez Lueur Externe sur des projets TypeScript variés, voici nos recommandations pour une adoption réussie :

1. Organisez votre schéma en modules : un fichier par domaine métier (users, products, orders…) plutôt qu’un fichier monolithique.
2. Utilisez les transactions : Drizzle supporte les transactions nativement. Encapsulez vos opérations critiques.
3. Activez le logging en développement : passez { logger: true } à la configuration pour visualiser les requêtes SQL générées.
4. Versionnez vos migrations : committez les fichiers SQL générés par Drizzle Kit dans votre dépôt Git.
5. Testez avec SQLite : pour vos tests unitaires, utilisez le driver SQLite en mémoire. C’est ultra-rapide et ne nécessite aucune infrastructure.
6. Exploitez le mode prepare : pour les requêtes exécutées fréquemment, les prepared statements améliorent les performances.

// Prepared statement réutilisable
const getUserById = db
  .select()
  .from(users)
  .where(eq(users.id, sql.placeholder('id')))
  .prepare('get_user_by_id');

// Exécution
const user = await getUserById.execute({ id: 42 });

L’avenir de Drizzle ORM

Le projet est porté par Drizzle Team, une équipe dédiée financée par des levées de fonds. La roadmap inclut :

• Un support étendu des vues matérialisées.
• Une amélioration continue de Drizzle Studio.
• Des intégrations natives avec davantage de plateformes cloud.
• Un support MongoDB (en cours de discussion).

Avec l’adoption croissante des architectures serverless et edge, Drizzle ORM est idéalement positionné pour devenir le standard de facto des query builders TypeScript dans les années à venir.

Conclusion : faut-il adopter Drizzle ORM ?

Si vous développez en TypeScript et que vous valorisez la performance, la légèreté et le contrôle sur vos requêtes SQL, Drizzle ORM est un excellent choix. Son approche SQL-first, son typage irréprochable et son empreinte minimale en font un outil particulièrement adapté aux architectures modernes — serverless, edge computing, microservices.

Pour les projets existants sur Prisma ou TypeORM, la migration n’est pas toujours nécessaire. Mais pour tout nouveau projet démarré en 2025, Drizzle mérite sérieusement d’être évalué comme première option.

Chez Lueur Externe, agence web experte depuis 2003, nous accompagnons nos clients dans le choix et la mise en œuvre des technologies les plus adaptées à leurs enjeux. Que vous construisiez une application Next.js, une API serverless sur AWS ou un e-commerce Prestashop avec un backend TypeScript moderne, notre équipe maîtrise les outils qui font la différence.

Vous avez un projet web qui nécessite performance et modernité ? Parlons-en ensemble.