Introdução ao Drizzle ORM - ORM leve para TypeScript

O que você aprenderá neste tutorial

✓ Configuração do Drizzle
✓ Definição de schema
✓ Migrations
✓ Operações CRUD
✓ Relacionamentos

Step 1: Configuração

npm install drizzle-orm postgres
npm install -D drizzle-kit

Step 2: Definição de Schema

// src/db/schema.ts
import { pgTable, serial, text, timestamp, integer } 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),
  createdAt: timestamp('created_at').defaultNow(),
});

Step 3: Conexão com o Banco de Dados

// src/db/index.ts
import { drizzle } from 'drizzle-orm/postgres-js';
import postgres from 'postgres';
import * as schema from './schema';

const client = postgres(process.env.DATABASE_URL!);
export const db = drizzle(client, { schema });

Step 4: Migrations

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

export default {
  schema: './src/db/schema.ts',
  out: './drizzle',
  driver: 'pg',
  dbCredentials: {
    connectionString: process.env.DATABASE_URL!,
  },
} satisfies Config;

# Gerar migration
npx drizzle-kit generate:pg

# Executar migration
npx drizzle-kit push:pg

# Drizzle Studio
npx drizzle-kit studio

Step 5: Operações CRUD

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

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

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

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

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

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

Step 6: Query Builder

// Query com condições
const activePosts = await db.select()
  .from(posts)
  .where(eq(posts.authorId, userId))
  .orderBy(desc(posts.createdAt))
  .limit(10);

// JOIN
const postsWithAuthors = await db.select({
  post: posts,
  author: users,
})
.from(posts)
.leftJoin(users, eq(posts.authorId, users.id));

// Agregação
import { count, avg } from 'drizzle-orm';

const stats = await db.select({
  total: count(),
})
.from(posts);

Step 7: Queries com Relacionamentos

// Definição de relacionamentos em schema.ts
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
const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: true,
  },
});

Resumo

Drizzle ORM é um ORM leve e type-safe. Sua API próxima ao SQL tem baixa curva de aprendizado, e as migrations são simples.