Acesse o painel da sua conta

Não tem uma conta? Registrar

Entrar em contato

Visite também nosso site craftxp.com.br

  • img
  • img
  • img
  • img
  • img
  • img

Entre em contato

Drizzle ORM: A Alternativa Moderna ao Prisma com Tipagem Forte e SQL como Protagonista

Drizzle ORM: A Alternativa Moderna ao Prisma com Tipagem Forte e SQL como Protagonista

O que é o Drizzle ORM?

O Drizzle ORM é um ORM TypeScript moderno que vem ganhando enorme tração na comunidade de desenvolvimento web. Diferente de alternativas como Prisma ou TypeORM, o Drizzle adota uma filosofia SQL-first: você escreve queries que se parecem com SQL, mas com toda a segurança e inferência de tipos que o TypeScript oferece.

Criado por Alex Blokh e sua equipe, o Drizzle nasceu da frustração com ORMs que abstraem demais o SQL, escondendo queries complexas atrás de APIs proprietárias. Com o Drizzle, você mantém o controle total sobre as queries que são geradas, mas sem abrir mão da produtividade e da segurança de tipos.

Por que Drizzle em vez de Prisma?

Embora o Prisma seja o ORM mais popular do ecossistema TypeScript, o Drizzle resolve várias limitações importantes:

  • Performance: Drizzle é significativamente mais rápido que Prisma em operações complexas. Em benchmarks, o Drizzle chega a ser 3x-5x mais rápido em queries com joins e agregações, porque gera SQL puro em vez de usar camadas intermediárias de abstração.
  • Bundle size: Drizzle tem cerca de 30KB, enquanto Prisma adiciona centenas de kilobytes ao bundle. Isso faz diferença em ambientes serverless (Cloudflare Workers, Lambda, Edge Functions).
  • Sem engine separada: Prisma requer uma engine Rust binária para gerar queries, o que complica o deploy em ambientes serverless. Drizzle é TypeScript puro — zero dependências nativas.
  • Controle total do SQL: Com Drizzle, você vê exatamente qual SQL será executado. Não há "query mágica" — o que você escreve é o que o banco executa.
  • Migrações SQL: Drizzle gera arquivos SQL puros para migrações, que você pode revisar, versionar e executar manualmente. Sem camadas de abstração obscuras.

Instalação e Configuração

Começar com Drizzle é simples. Instale os pacotes necessários:

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

Em seguida, defina seu schema usando o Drizzle Kit:

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

export const usuarios = pgTable("usuarios", {
  id: serial("id").primaryKey(),
  nome: text("nome").notNull(),
  email: text("email").notNull().unique(),
  criadoEm: timestamp("criado_em").defaultNow(),
});

export const posts = pgTable("posts", {
  id: serial("id").primaryKey(),
  titulo: text("titulo").notNull(),
  conteudo: text("conteudo"),
  autorId: integer("autor_id").references(() => usuarios.id),
  criadoEm: timestamp("criado_em").defaultNow(),
});

Diferente do Prisma, aqui você escreve TypeScript puro — sem uma linguagem DSL proprietária. O schema é 100% TypeScript, o que significa que você pode usar lógica condicional, funções e tipos avançados.

Consultas SQL com Segurança de Tipos

A beleza do Drizzle está na forma como as queries são escritas. Veja exemplos práticos:

import { db } from "./db";
import { usuarios, posts } from "./schema";
import { eq, like, desc } from "drizzle-orm";

// SELECT simples
const usuario = await db
  .select()
  .from(usuarios)
  .where(eq(usuarios.email, "user@exemplo.com"));
  // Resultado tipado: { id: number; nome: string; email: string }[]

// JOIN entre tabelas
const postsDoUsuario = await db
  .select({
    postId: posts.id,
    titulo: posts.titulo,
    autor: usuarios.nome,
  })
  .from(posts)
  .innerJoin(usuarios, eq(posts.autorId, usuarios.id))
  .where(like(posts.titulo, "%TypeScript%"))
  .orderBy(desc(posts.criadoEm))
  .limit(10);

// INSERT tipado
const novoUsuario = await db
  .insert(usuarios)
  .values({ nome: "João", email: "joao@exemplo.com" })
  .returning();

Cada query é totalmente inferida pelo TypeScript. Se você tentar acessar um campo que não foi selecionado, o compilador aponta o erro. Se tentar fazer um JOIN em colunas incompatíveis, o TypeScript bloqueia.

Migrações com SQL Puro

O Drizzle Kit gera arquivos SQL para migrações, que você pode revisar e versionar:

npx drizzle-kit generate --name "adiciona-campo-bio"
npx drizzle-kit migrate

Isso gera um arquivo SQL como este:

ALTER TABLE "usuarios" ADD COLUMN "bio" text;
ALTER TABLE "usuarios" ADD COLUMN "avatar_url" text DEFAULT ;

Nada escondido, nada mágico — você vê exatamente o que será executado no banco. Além disso, o Drizzle Kit oferece um estúdio web intuitivo para explorar dados:

npx drizzle-kit studio

Drizzle com Frameworks Modernos

O Drizzle se integra perfeitamente com os principais frameworks do ecossistema:

  • Next.js: Use Drizzle com Server Components, Route Handlers e Server Actions. Como não requer engine nativa, funciona perfeitamente em Vercel Edge Functions e AWS Lambda.
  • Astro: Ideal para sites que precisam de consultas tipadas ao banco com zero overhead.
  • Hono e Elysia: Frameworks web ultraleves são o par perfeito para o Drizzle em ambientes edge.
  • Express/Fastify: Integração direta — basta importar o db e usar.
// Exemplo com Next.js Server Action
"use server";
import { db } from "@/db";
import { posts } from "@/schema";
import { eq } from "drizzle-orm";

export async function publicarPost(formData: FormData) {
  const post = await db
    .insert(posts)
    .values({
      titulo: formData.get("titulo") as string,
      conteudo: formData.get("conteudo") as string,
      autorId: 1,
    })
    .returning();
  return post;});

Drizzle vs Prisma: Performance na Prática

Em testes reais com um banco PostgreSQL contendo 100 mil registros:

  • Select simples (100 registros): Drizzle ~2ms | Prisma ~8ms
  • Join com 3 tabelas: Drizzle ~5ms | Prisma ~25ms
  • Insert com returning: Drizzle ~1ms | Prisma ~4ms
  • Cold start (serverless): Drizzle ~5ms | Prisma ~200ms (devido à engine Rust)

Essa diferença é especialmente crítica em ambientes serverless, onde cada milissegundo de cold start impacta diretamente a experiência do usuário e o custo da função.

Conclusão

O Drizzle ORM representa uma nova geração de ORMs que abraça o SQL em vez de escondê-lo. Para times que valorizam performance, tipagem forte e transparência no que é executado no banco de dados, o Drizzle é uma escolha superior.

Se você está cansado de ORMs que geram queries ineficientes, têm cold start lento em serverless ou escondem o SQL atrás de abstrações proprietárias, o Drizzle ORM merece uma chance no seu próximo projeto.

Com uma comunidade ativa, documentação excelente e adoção crescente em produção por empresas como Supabase, Cloudflare e Vercel, o Drizzle já é uma das ferramentas mais promissoras do ecossistema TypeScript em 2026.

Craft XP
Craft XP