ORM pour TypeScript : comparaison et exemples

Dans le développement web moderne avec TypeScript, le choix du bon ORM (Object-Relational Mapping) est l'une des décisions clés qui influence l'architecture, les performances et la maintenabilité d'un projet. L'ORM permet de travailler avec une base de données via des objets du langage de programmation, en abstraisant les requêtes SQL. Dans cet article, nous examinerons les trois ORM les plus populaires pour TypeScript : TypeORM, Prisma et MikroORM. Vous découvrirez leurs forces et faiblesses, ainsi que des exemples de code pour chacun.

1. TypeORM

TypeORM est l'un des ORM les plus anciens et les plus matures pour TypeScript et JavaScript. Il prend en charge les modèles Active Record et Data Mapper, ainsi que de nombreuses bases de données : PostgreSQL, MySQL, SQLite, MongoDB et autres.

Caractéristiques de TypeORM :

Prise en charge des décorateurs pour définir les entités
Relations flexibles : OneToOne, OneToMany, ManyToMany
Migrations et synchronisation du schéma
Prise en charge des abonnements et des événements du cycle de vie
Query Builder pour les requêtes complexes

Exemple de code avec TypeORM :

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

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

  @Column()  name: string;

  @Column()  email: string;}

async function main() {  await createConnection({    type: "postgres",    host: "localhost",    port: 5432,    username: "test",    password: "test",    database: "test",    entities: [User],    synchronize: true,  });

  const user = new User();  user.name = "Иван";  user.email = "ivan@example.com";  await user.save();

  const users = await User.find();  console.log(users);}

Avantages : grande communauté, nombreux tutoriels, prise en charge de MongoDB. Inconvénients : configuration complexe, problèmes avec le lazy loading, API parfois non intuitive.

2. Prisma

Prisma est un ORM moderne qui repense l'approche de travail avec une base de données. Au lieu d'un ORM traditionnel, il propose trois composants : Prisma Client (un client typé et généré automatiquement), Prisma Migrate (système de migrations) et Prisma Studio (interface graphique).

Caractéristiques de Prisma :

Schéma de données déclaratif (schema.prisma)
Typage complet basé sur le schéma — aucun type manuel
Génération automatique du client
Prise en charge des transactions et de la pagination
Intégration avec GraphQL (Nexus, TypeGraphQL)

Exemple de code avec Prisma :

// 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])}

// main.tsimport { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {  const user = await prisma.user.create({    data: {      name: 'Мария',      email: 'maria@example.com',      posts: {        create: { title: 'Мой первый пост' }      }    },    include: { posts: true }  });

  const users = await prisma.user.findMany({    include: { posts: true }  });  console.log(users);}

main()  .catch(e => console.error(e))  .finally(() => prisma.$disconnect());

Avantages : meilleur typage de sa catégorie, syntaxe simple, excellente documentation. Inconvénients : dépendance au schéma, complexité avec les requêtes personnalisées, consommation mémoire plus élevée.