Drizzle ORM - ORM ligero hecho en TypeScript

¿Qué es Drizzle ORM?

Drizzle ORM es un ORM ligero diseñado con TypeScript como prioridad. Permite escribir consultas intuitivamente con una sintaxis cercana a SQL y proporciona seguridad de tipos completa.

Características

✓ TypeScript first
✓ Sintaxis cercana a SQL
✓ Cero dependencias (ligero)
✓ Compatible con Edge
✓ Optimizado para serverless

Definición de esquemas

Definición de tablas

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

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
  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),
  published: boolean('published').default(false),
  createdAt: timestamp('created_at').defaultNow()
});

Definición de relaciones

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

Query Builder

CRUD básico

import { drizzle } from 'drizzle-orm/node-postgres';
import { eq, and, or, gt, like } from 'drizzle-orm';
import * as schema from './schema';

const db = drizzle(pool, { schema });

// INSERT
const newUser = await db.insert(users).values({
  name: 'Alice',
  email: 'alice@example.com'
}).returning();

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

// WHERE
const activeUsers = await db.select()
  .from(users)
  .where(eq(users.isActive, true));

// UPDATE
await db.update(users)
  .set({ name: 'Bob' })
  .where(eq(users.id, 1));

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

Consultas complejas

// Múltiples condiciones
const results = await db.select()
  .from(users)
  .where(
    and(
      gt(users.age, 18),
      or(
        like(users.email, '%@company.com'),
        eq(users.role, 'admin')
      )
    )
  );

// ORDER BY, LIMIT, OFFSET
const pagedUsers = await db.select()
  .from(users)
  .orderBy(desc(users.createdAt))
  .limit(10)
  .offset(20);

// JOIN
const postsWithAuthors = await db.select({
  postTitle: posts.title,
  authorName: users.name
})
  .from(posts)
  .leftJoin(users, eq(posts.authorId, users.id));

Consultas relacionales

// Obtener datos anidados
const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: {
      where: eq(posts.published, true),
      limit: 5
    }
  }
});

// Resultado
// [
//   {
//     id: 1,
//     name: 'Alice',
//     posts: [
//       { id: 1, title: 'First Post', ... },
//       { id: 2, title: 'Second Post', ... }
//     ]
//   }
// ]

Transacciones

await db.transaction(async (tx) => {
  const user = await tx.insert(users)
    .values({ name: 'Alice', email: 'alice@example.com' })
    .returning();

  await tx.insert(posts).values({
    title: 'My First Post',
    authorId: user[0].id
  });
});

Migraciones

Drizzle Kit

# Generar migración
npx drizzle-kit generate

# Aplicar migración
npx drizzle-kit migrate

# Push del esquema a la BD (para desarrollo)
npx drizzle-kit push

# Drizzle Studio (GUI)
npx drizzle-kit studio

Archivo de configuración

// drizzle.config.ts
import type { Config } from 'drizzle-kit';

export default {
  schema: './src/schema.ts',
  out: './drizzle',
  dialect: 'postgresql',
  dbCredentials: {
    url: process.env.DATABASE_URL!
  }
} satisfies Config;

Soporte para diversas bases de datos

// PostgreSQL
import { drizzle } from 'drizzle-orm/node-postgres';

// MySQL
import { drizzle } from 'drizzle-orm/mysql2';

// SQLite
import { drizzle } from 'drizzle-orm/better-sqlite3';

// Planetscale
import { drizzle } from 'drizzle-orm/planetscale-serverless';

// Neon
import { drizzle } from 'drizzle-orm/neon-http';

// Turso
import { drizzle } from 'drizzle-orm/libsql';

Comparación con Prisma

Resumen

Drizzle ORM es un ORM ligero que combina sintaxis cercana a SQL con seguridad de tipos completa. Está optimizado para entornos edge y serverless, siendo ideal para proyectos TypeScript modernos.