Drizzle ORM: a alternativa ao Prisma que está conquistando devs TypeScript

1. Por que Drizzle ORM está ganhando espaço no ecossistema TypeScript

1.1. A insatisfação com Prisma: camada de abstração pesada e tempo de compilação do schema

O Prisma revolucionou o acesso a banco de dados no ecossistema Node.js com sua abordagem schema-first e ferramentas como o Prisma Studio. No entanto, à medida que projetos crescem, suas limitações se tornam evidentes: o prisma generate pode levar segundos a cada alteração no schema, a engine em Rust adiciona latência em cold starts e a abstração sobre SQL esconde detalhes importantes de performance. Para equipes que buscam controle fino sobre queries e inicialização rápida, essas características se tornam gargalos.

1.2. Drizzle como resposta: leveza, tipagem estática zero-cost e sem código gerado

Drizzle ORM surge como uma alternativa que abraça a filosofia de "zero-cost abstraction" do TypeScript. Diferente do Prisma, Drizzle não gera código intermediário — os tipos são inferidos diretamente das definições de tabela em tempo de compilação. Isso elimina o passo de generate e reduz drasticamente o tempo de inicialização. Em testes comparativos, uma aplicação Drizzle pode iniciar em menos de 10ms contra mais de 200ms do Prisma no mesmo cenário.

1.3. Comparação de filosofia: schema-first (Prisma) vs code-first (Drizzle)

Enquanto o Prisma exige que você defina tudo em schema.prisma e depois sincronize com TypeScript, o Drizzle permite que você escreva suas tabelas diretamente em código TypeScript. Essa abordagem code-first oferece maior flexibilidade: você pode usar funções, lógica condicional e até gerar schemas dinamicamente. Para times que já dominam TypeScript, a curva de aprendizado é praticamente zero.

2. Arquitetura e princípios fundamentais do Drizzle

2.1. SQL-like API: escrever queries que parecem SQL puro, com type safety total

A API do Drizzle foi projetada para ser familiar a quem conhece SQL. Veja um exemplo de select:

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

const result = await db.select()
  .from(users)
  .where(
    and(
      eq(users.active, true),
      eq(users.role, 'admin')
    )
  )
  .limit(10);

Cada parte da query é tipada: se você tentar acessar users.nomeErrado, o TypeScript acusará erro imediatamente.

2.2. Sem engine própria: Drizzle como fina camada sobre drivers nativos

Drizzle não possui engine própria. Ele funciona como uma camada de tipagem sobre drivers SQL nativos como pg, mysql2 e better-sqlite3. Isso significa que as queries são executadas diretamente no driver, sem overhead adicional. Para conectar:

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

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

2.3. Integração com TypeScript: inferência de tipos em tempo real sem prisma generate

A mágica do Drizzle está na inferência de tipos. Ao definir uma tabela, os tipos são extraídos automaticamente:

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

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: varchar('name', { length: 255 }).notNull(),
  email: varchar('email', { length: 255 }).notNull().unique(),
  active: boolean('active').default(true)
});

// Tipo inferido automaticamente: { id: number, name: string, email: string, active: boolean | null }
type User = typeof users.$inferSelect;

3. Modelagem de dados com Drizzle: tabelas, relações e migrações

3.1. Definindo schemas com pgTable, serial, varchar e constraints

A modelagem é declarativa e suporta todas as constraints SQL:

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

export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: varchar('title', { length: 200 }).notNull(),
  content: varchar('content', { length: 5000 }),
  authorId: integer('author_id').references(() => users.id),
  createdAt: timestamp('created_at').defaultNow()
});

3.2. Relacionamentos: relations e joins tipados com eq, and, or

Drizzle oferece dois estilos de joins. O explícito:

import { eq } from 'drizzle-orm';

const result = await db.select()
  .from(posts)
  .innerJoin(users, eq(posts.authorId, users.id));

E o relacional, que permite eager loading:

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

3.3. Migrations com Drizzle Kit: drizzle-kit push e drizzle-kit generate para schema em produção

O Drizzle Kit gerencia migrações de forma eficiente:

# Gerar arquivos de migração
npx drizzle-kit generate

# Aplicar migrações no banco
npx drizzle-kit push

# Visualizar estado atual
npx drizzle-kit studio

O comando push é ideal para desenvolvimento, enquanto generate produz arquivos SQL versionáveis para produção.

4. Operações CRUD poderosas e tipadas

4.1. Select com filtros, ordenação, paginação e agregações

const activeUsers = await db.select()
  .from(users)
  .where(eq(users.active, true))
  .orderBy(users.name)
  .limit(20)
  .offset(40);

// Agregações
const [count] = await db.select({ count: count() })
  .from(users)
  .where(eq(users.role, 'admin'));

4.2. Insert, Update e Delete com retorno de dados (.returning())

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

const [updated] = await db.update(users)
  .set({ active: false })
  .where(eq(users.id, 1))
  .returning();

const [deleted] = await db.delete(users)
  .where(eq(users.id, 1))
  .returning();

4.3. Joins explícitos vs relacionais: innerJoin, leftJoin e sintaxe relacional

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

// Join relacional (precisa de relations definidas)
const postsRelational = await db.query.posts.findMany({
  with: {
    author: true
  }
});

5. Drizzle vs Prisma: batalha de performance e experiência de desenvolvimento

5.1. Benchmarks reais: tempo de inicialização, memória e throughput de queries

Testes independentes mostram que Drizzle é 5-10x mais rápido na inicialização que Prisma. Em operações CRUD básicas, a diferença é menor (10-20%), mas em cold starts de funções serverless, Drizzle pode iniciar em 5ms contra 300ms do Prisma. O consumo de memória também é significativamente menor — cerca de 4MB vs 25MB para uma aplicação simples.

5.2. Experiência do desenvolvedor: hot reload, inferência sem gerador e debugging com SQL real

No Drizzle, alterar uma tabela e usar imediatamente em uma rota é instantâneo — não há generate para recompilar. Além disso, você pode logar o SQL gerado facilmente:

const db = drizzle(pool, { logger: true });

5.3. Casos de uso onde Drizzle vence: APIs serverless, edge functions e microsserviços

Para funções serverless (Vercel, AWS Lambda, Cloudflare Workers) e edge functions, onde cada milissegundo conta, Drizzle é a escolha natural. Sua leveza permite que microsserviços mantenham inicialização rápida mesmo com múltiplas instâncias.

6. Integração com frameworks e ecossistema TypeScript

6.1. Drizzle + Next.js: uso em Server Components, API Routes e Actions

// app/actions.ts (Next.js Server Action)
'use server';
import { db } from '@/db';
import { users } from '@/db/schema';
import { eq } from 'drizzle-orm';

export async function getUser(id: number) {
  return await db.select().from(users).where(eq(users.id, id));
}

6.2. Drizzle + Hono / Elysia: ORM para runtimes modernos (Bun, Deno, Node)

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

const app = new Hono();
const db = drizzle(pool);

app.get('/users/:id', async (c) => {
  const user = await db.select().from(users).where(eq(users.id, c.req.param('id')));
  return c.json(user);
});

6.3. Drizzle + Zod: validação de schemas compartilhados entre banco e formulários

import { z } from 'zod';
import { createInsertSchema } from 'drizzle-zod';

const insertUserSchema = createInsertSchema(users);
// { name: z.string().max(255), email: z.string().email(), active: z.boolean().optional() }

7. Armadilhas e boas práticas ao migrar para Drizzle

7.1. O que você perde ao sair do Prisma: CLI de seed, painel Studio e abstração de banco

Drizzle Kit oferece um Studio básico, mas não tem a riqueza do Prisma Studio. Para seeds, você precisará escrever scripts manuais. Além disso, a abstração de banco do Prisma permite trocar de provedor (PostgreSQL para MySQL) sem alterar queries — no Drizzle, você precisa ajustar os imports de schema.

7.2. Cuidados com SQL raw e complexidade de queries dinâmicas

Para queries muito dinâmicas, o Drizzle pode exigir mais código que o Prisma. SQL raw é suportado, mas perde type safety:

const result = await db.execute(sql`SELECT * FROM users WHERE ${condition}`);

7.3. Estratégia de adoção: migração gradual em projetos existentes vs greenfield

Para projetos existentes, comece com uma nova funcionalidade usando Drizzle enquanto mantém Prisma no resto. Projetos greenfield podem adotar Drizzle desde o início. A migração completa pode ser feita exportando dados do Prisma e reimportando com Drizzle.

8. Futuro do Drizzle ORM e o cenário de bancos de dados em TypeScript

8.1. Roadmap: suporte a multi-schema, views materializadas e transactions aninhadas

O roadmap do Drizzle inclui suporte nativo a multi-schema (schemas PostgreSQL), views materializadas com refresh automático e transações aninhadas com savepoints. A versão 1.0, lançada em 2024, já oferece estabilidade para produção.

8.2. Drizzle no contexto de bancos relacionais modernos (Neon, PlanetScale, Turso)

Drizzle tem integração oficial com Neon (serverless PostgreSQL), PlanetScale (MySQL compatível com Vitess) e Turso (SQLite distribuído). Para Turso, o pacote drizzle-orm/libsql oferece suporte nativo.

8.3. Concorrência e tendências: Drizzle vs Kysely vs TypeORM vs Prisma em 2025

Em 2025, o cenário de ORMs TypeScript está mais fragmentado que nunca. Kysely oferece tipagem similar ao Drizzle mas com API mais verbosa. TypeORM continua relevante para projetos legados. Prisma mantém vantagem em ferramentas visuais e abstração multi-banco. Drizzle, no entanto, cresce rapidamente em adoção por sua simplicidade e performance, especialmente no ecossistema serverless.

Referências