ORM pour TypeScript : Comparaison de Prisma, TypeORM et Drizzle — exemples de code

ORM pour TypeScript : comparaison et exemples

Dans le développement web moderne avec TypeScript, le choix du bon ORM (Object-Relational Mapping) peut considérablement accélérer le développement et améliorer la fiabilité de l'application. L'ORM permet de travailler avec des bases de données via une approche orientée objet, évitant ainsi l'écriture de requêtes SQL brutes. Dans cet article, nous comparerons trois des ORM les plus populaires pour TypeScript : Prisma, TypeORM et Drizzle, et examinerons des exemples de leur utilisation.

1. Prisma — le standard moderne

Prisma est un ORM de nouvelle génération qui se concentre sur la commodité du développeur et les performances. Il utilise son propre langage de description de schéma (Prisma Schema) et génère un client entièrement typé.

Caractéristiques clés :

• Génération automatique de types TypeScript
• API intuitive pour les requêtes
• Migration de données intégrée (Prisma Migrate)
• Prise en charge de PostgreSQL, MySQL, SQLite, MongoDB et autres

Exemple de code en TypeScript :

// schema.prismamodel User {  id    Int     @id @default(autoincrement())  name  String  email String  @unique  posts Post[]}

model Post {  id        Int     @id @default(autoincrement())  title     String  content   String?  authorId  Int  author    User    @relation(fields: [authorId], references: [id])}

// Utilisation dans le codeimport { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function getUsersWithPosts() {  const users = await prisma.user.findMany({    include: { posts: true }  });  return users;}

2. TypeORM — le classique pour TypeScript

TypeORM est un ORM mature qui prend en charge à la fois les modèles Active Record et Data Mapper. Il est étroitement intégré à TypeScript et utilise des décorateurs pour définir les modèles.

Caractéristiques clés :

• Prise en charge des décorateurs et des classes
• Deux approches : Active Record et Data Mapper
• Migration avancée et abonnements aux événements
• Prise en charge de nombreux SGBD

Exemple de code en TypeScript :

import { Entity, PrimaryGeneratedColumn, Column, OneToMany, createConnection } from "typeorm";

@Entity()export class User {    @PrimaryGeneratedColumn()    id: number;

    @Column()    name: string;

    @Column({ unique: true })    email: string;

    @OneToMany(() => Post, post => post.user)    posts: Post[];}

@Entity()export class Post {    @PrimaryGeneratedColumn()    id: number;

    @Column()    title: string;

    @Column({ nullable: true })    content: string;

    @ManyToOne(() => User, user => user.posts)    user: User;}

// Utilisationasync function getUsersWithPosts() {    const connection = await createConnection();    const userRepository = connection.getRepository(User);    return await userRepository.find({ relations: ["posts"] });}

3. Drizzle — léger et performant

Drizzle est un ORM relativement nouveau qui met l'accent sur les performances et une taille de bundle minimale. Il utilise une syntaxe similaire à SQL et ne nécessite pas de génération de code.

Caractéristiques clés :

• Taille minimale et haute vitesse
• Prise en charge native de TypeScript sans décorateurs
• API de type SQL (query builder)
• Compatibilité avec les bases de données SQL

Exemple de code en TypeScript :

import { drizzle } from 'drizzle-orm/better-sqlite3';import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';import Database from 'better-sqlite3';

const sqlite = new Database('test.db');const db = drizzle(sqlite);

// Définition du schémaconst users = sqliteTable('users', {    id: integer('id').primaryKey(),    name: text('na