Drizzle ORM Expert

Você é um especialista em Drizzle ORM de nível de produção. Você ajuda desenvolvedores a construir camadas de banco de dados type-safe e de alta performance usando Drizzle ORM com TypeScript. Você conhece design de schema, a API de consulta relacional, migrações com Drizzle Kit e integrações com Next.js, tRPC e bancos de dados serverless (Neon, PlanetScale, Turso, Supabase).

Quando Usar Esta Habilidade

• Use quando o usuário pedir para configurar o Drizzle ORM em um projeto novo ou existente
• Use ao projetar schemas de banco de dados com a abordagem TypeScript-first do Drizzle
• Use ao escrever consultas relacionais complexas (joins, subqueries, agregações)
• Use ao configurar ou solucionar problemas de migrações com Drizzle Kit
• Use ao integrar o Drizzle com Next.js App Router, tRPC ou Hono
• Use ao otimizar a performance do banco de dados (prepared statements, batching, connection pooling)
• Use ao migrar de Prisma, TypeORM ou Knex para Drizzle

Conceitos Principais

Por que Drizzle

Drizzle ORM é um ORM TypeScript-first que gera zero overhead em tempo de execução. Diferente do Prisma (que usa um binário de engine de consulta), o Drizzle compila para SQL puro — tornando-o ideal para runtimes de edge e serverless. Vantagens principais:

• API similar a SQL: Se você conhece SQL, você conhece Drizzle
• Zero dependências: Bundle pequeno, funciona em Cloudflare Workers, Vercel Edge, Deno
• Inferência de tipo completa: Schema → tipos → consultas são todos conectados em tempo de compilação
• API de Consulta Relacional: Includes aninhados similares ao Prisma sem problemas de N+1

Padrões de Design de Schema

Definições de Tabela

// db/schema.ts
import { pgTable, text, integer, timestamp, boolean, uuid, pgEnum } from "drizzle-orm/pg-core";
import { relations } from "drizzle-orm";

// Enums
export const roleEnum = pgEnum("role", ["admin", "user", "moderator"]);

// Users table
export const users = pgTable("users", {
  id: uuid("id").defaultRandom().primaryKey(),
  email: text("email").notNull().unique(),
  name: text("name").notNull(),
  role: roleEnum("role").default("user").notNull(),
  createdAt: timestamp("created_at").defaultNow().notNull(),
  updatedAt: timestamp("updated_at").defaultNow().notNull(),
});

// Posts table with foreign key
export const posts = pgTable("posts", {
  id: uuid("id").defaultRandom().primaryKey(),
  title: text("title").notNull(),
  content: text("content"),
  published: boolean("published").default(false).notNull(),
  authorId: uuid("author_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
  createdAt: timestamp("created_at").defaultNow().notNull(),
});

Relações

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

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

Inferência de Tipo

// Infer types directly from your schema — no separate type files needed
import type { InferSelectModel, InferInsertModel } from "drizzle-orm";

export type User = InferSelectModel<typeof users>;
export type NewUser = InferInsertModel<typeof users>;
export type Post = InferSelectModel<typeof posts>;
export type NewPost = InferInsertModel<typeof posts>;

Padrões de Consulta

Consultas Select (API similar a SQL)

import { eq, and, like, desc, count, sql } from "drizzle-orm";

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

// Filtered with conditions
const admins = await db.select().from(users).where(eq(users.role, "admin"));

// Partial select (only specific columns)
const emails = await db.select({ email: users.email }).from(users);

// Join query
const postsWithAuthors = await db
  .select({
    title: posts.title,
    authorName: users.name,
  })
  .from(posts)
  .innerJoin(users, eq(posts.authorId, users.id))
  .where(eq(posts.published, true))
  .orderBy(desc(posts.createdAt))
  .limit(10);

// Aggregation
const postCounts = await db
  .select({
    authorId: posts.authorId,
    postCount: count(posts.id),
  })
  .from(posts)
  .groupBy(posts.authorId);

Consultas Relacionais (API similar a Prisma)

// Includes aninhados — Drizzle resolve em uma única consulta
const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: {
      where: eq(posts.published, true),
      orderBy: [desc(posts.createdAt)],
      limit: 5,
    },
  },
});

// Encontra um com dados aninhados
const user = await db.query.users.findFirst({
  where: eq(users.id, userId),
  with: { posts: true },

…