tech
Defaultdeesfrzh

Drizzle ORM

ORM TypeScript avec syntaxe SQL-like - type-safe, zero dependance, pret pour serverless

TL;DR

Quoi : ORM TypeScript avec syntaxe SQL-like et zéro dépendance.

Pourquoi : Type-safe, léger, API similaire à SQL, excellente DX, prêt pour serverless.

Quick Start

Installation :

npm install drizzle-orm
npm install -D drizzle-kit
npm install pg  # ou better-sqlite3, mysql2

Définir le schéma (src/db/schema.ts) :

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

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
});

Connecter et requêter :

import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import { users } from './schema';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(pool);

const allUsers = await db.select().from(users);

Cheatsheet

CommandeDescription
npx drizzle-kit generateGénérer les migrations
npx drizzle-kit migrateExécuter les migrations
npx drizzle-kit pushPousser le schéma (sans migration)
npx drizzle-kit studioOuvrir Drizzle Studio

Gotchas

Schema definition

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

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
  age: integer('age'),
  isActive: boolean('is_active').default(true),
  createdAt: timestamp('created_at').defaultNow(),
});

export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  content: text('content'),
  authorId: integer('author_id').references(() => users.id),
});

CRUD operations

import { eq, and, or, like } from 'drizzle-orm';

// Créer
await db.insert(users).values({
  name: 'John',
  email: '[email protected]'
});

// Lire
const allUsers = await db.select().from(users);
const user = await db.select().from(users).where(eq(users.id, 1));

// Mettre à jour
await db.update(users)
  .set({ name: 'Johnny' })
  .where(eq(users.id, 1));

// Supprimer
await db.delete(users).where(eq(users.id, 1));

Filtering and joins

import { eq, and, or, like, gt } from 'drizzle-orm';

// Where complexe
const results = await db.select()
  .from(users)
  .where(
    and(
      gt(users.age, 18),
      like(users.email, '%@example.com')
    )
  );

// Join
const postsWithAuthors = await db.select()
  .from(posts)
  .leftJoin(users, eq(posts.authorId, users.id));

// Sélectionner des champs spécifiques
const userNames = await db.select({
  id: users.id,
  name: users.name,
}).from(users);

Relations

import { relations } from 'drizzle-orm';

export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));

export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
}));

// Requêter avec les relations
const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: true,
  },
});

Configuration (drizzle.config.ts)

import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  schema: './src/db/schema.ts',
  out: './drizzle',
  dialect: 'postgresql',
  dbCredentials: {
    url: process.env.DATABASE_URL!,
  },
});

Next Steps