Overview
Drizzle ORM is a lightweight TypeScript ORM that feels like writing SQL. It provides type-safe schema definitions, automatic migrations, and a query builder that maps 1:1 to SQL.
Capabilities
- Type-safe schema definitions with Drizzle schema language
- Automatic migration generation with Drizzle Kit
- Select, insert, update, delete with full type inference
- Relations API for one-to-one, one-to-many, many-to-many
- Transactions and batch operations
- Support for PostgreSQL, MySQL, SQLite, Turso, D1
When to Use
Trigger phrases:
"drizzle orm"
"Drizzle ORM — type-safe SQL, schema definitions, migrations, queries, relations "
Building TypeScript/Node.js backends with SQL databases
Need type safety without heavy ORM overhead
Want SQL-like syntax instead of Active Record patterns
Working with edge databases (D1, Turso, Neon)
When NOT to Use
- Task is about deployment, not development (use deploy skills)
- Task is about code review, not writing (use review skills)
- You need to understand existing code first (use research skills)
- Task is about testing only (use test skills)
- Requirements are unclear (clarify first)
- Task is trivially simple (single line fix)
Pseudo Code
The drizzle-orm workflow follows a standard pipeline pattern.
Core flow:
# drizzle-orm primary flow
input = prepare(raw_data)
result = process(input, config={definitions, drizzle, migrations, node, orm})
validate(result)
deliver(result)
Error handling:
on error:
log(error_details)
retry_with_backoff(max=3)
if still_failing: alert_and_escalate()
Schema Definition
import { pgTable, serial, text, integer, timestamp } 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(),
authorId: integer('author_id').references(() => users.id),
});
Queries
import { eq, and, desc } from 'drizzle-orm';
import { db } from './db';
import { users, posts } from './schema';
// Select
const allUsers = await db.select().from(users);
const user = await db.select().from(users).where(eq(users.id, 1));
// Insert
await db.insert(users).values({ name: 'Alice', email: 'alice@example.com' });
// Update
await db.update(users).set({ name: 'Bob' }).where(eq(users.id, 1));
// Delete
await db.delete(users).where(eq(users.id, 1));
// Join
const result = await db
.select({ userName: users.name, postTitle: posts.title })
.from(users)
.leftJoin(posts, eq(users.id, posts.authorId))
.orderBy(desc(users.createdAt))
.limit(10);
Relations
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 with relations
const usersWithPosts = await db.query.users.findMany({
with: { posts: true },
});
Migrations
# Generate migration
npx drizzle-kit generate
# Apply migration
npx drizzle-kit migrate
# Push schema directly (dev only)
npx drizzle-kit push
# Open studio
npx drizzle-kit studio
Transactions
await db.transaction(async (tx) => {
const user = await tx.insert(users).values({ name: 'Alice' }).returning();
await tx.insert(posts).values({ title: 'Hello', authorId: user[0].id });
});
Common Patterns
- drizzle.config.ts: Configure schema path, output dir, DB driver
- Connection pooling: Use with Neon serverless, PgBouncer, or Hyperdrive
- Edge deployment: Works with Cloudflare D1, Turso, Neon serverless driver
- Seeding: Create seed scripts using the same schema types
How to Use
- Understand the requirement and existing codebase patterns
- Design the solution with error handling and testability in mind
- Implement incrementally with tests for each change
- Verify against expected outcomes (manual and automated)
- Document usage, edge cases, and integration points
- Review with team before merging to shared branches
Red Flags
- Skipping tests to ship faster: Untested code breaks in production when you least expect it
- No error handling in production code: Unhandled errors crash services and lose user data
- Hardcoded configuration values: Hardcoded values prevent environment switching and leak secrets
- Ignoring security implications: Missing input validation, auth bypasses, and injection vulnerabilities
- Over-engineering simple solutions: Premature abstraction adds complexity without proportional benefit
Verification
Process
- Analyze the task requirements
- Apply domain expertise
- Verify output quality
Anti-Rationalization Table
| Rationalization |
Reality |
| "Tests slow me down" |
Bugs slow you down 10x more. Tests are speed, not overhead. |
| "I will refactor later" |
Technical debt compounds. Refactor as you go. |
| "It works on my machine" |
If it is not in CI, it does not work. Ship proof, not claims. |
1---2name: drizzle-orm3description: Use when drizzle ORM — type-safe SQL, schema definitions, migrations,4 queries, relations for TypeScript/Node.js. Use when working with drizzle orm.5domain: development6author: oyi777license: Apache-2.08subdomain: software-development9tags:10- coding11- drizzle12- orm13- software-engineering14- testing15version: 1.0.016category: development17metadata:18 source: https://skillmd.com/skills/oyi77/drizzle-orm19---20212223## Overview2425Drizzle ORM is a lightweight TypeScript ORM that feels like writing SQL. It provides type-safe schema definitions, automatic migrations, and a query builder that maps 1:1 to SQL.2627## Capabilities2829- Type-safe schema definitions with Drizzle schema language30- Automatic migration generation with Drizzle Kit31- Select, insert, update, delete with full type inference32- Relations API for one-to-one, one-to-many, many-to-many33- Transactions and batch operations34- Support for PostgreSQL, MySQL, SQLite, Turso, D13536## When to Use37**Trigger phrases:**38- "drizzle orm"39- "Drizzle ORM — type-safe SQL, schema definitions, migrations, queries, relations "404142- Building TypeScript/Node.js backends with SQL databases43- Need type safety without heavy ORM overhead44- Want SQL-like syntax instead of Active Record patterns45- Working with edge databases (D1, Turso, Neon)4647## When NOT to Use4849- Task is about deployment, not development (use deploy skills)50- Task is about code review, not writing (use review skills)51- You need to understand existing code first (use research skills)52- Task is about testing only (use test skills)53- Requirements are unclear (clarify first)54- Task is trivially simple (single line fix)555657## Pseudo Code5859The drizzle-orm workflow follows a standard pipeline pattern.6061Core flow:62```63# drizzle-orm primary flow64input = prepare(raw_data)65result = process(input, config={definitions, drizzle, migrations, node, orm})66validate(result)67deliver(result)68```6970Error handling:71```72on error:73 log(error_details)74 retry_with_backoff(max=3)75 if still_failing: alert_and_escalate()76```777879### Schema Definition80```typescript81import { pgTable, serial, text, integer, timestamp } from 'drizzle-orm/pg-core';8283export const users = pgTable('users', {84 id: serial('id').primaryKey(),85 name: text('name').notNull(),86 email: text('email').notNull().unique(),87 createdAt: timestamp('created_at').defaultNow(),88});8990export const posts = pgTable('posts', {91 id: serial('id').primaryKey(),92 title: text('title').notNull(),93 authorId: integer('author_id').references(() => users.id),94});95```9697### Queries98```typescript99import { eq, and, desc } from 'drizzle-orm';100import { db } from './db';101import { users, posts } from './schema';102103// Select104const allUsers = await db.select().from(users);105const user = await db.select().from(users).where(eq(users.id, 1));106107// Insert108await db.insert(users).values({ name: 'Alice', email: 'alice@example.com' });109110// Update111await db.update(users).set({ name: 'Bob' }).where(eq(users.id, 1));112113// Delete114await db.delete(users).where(eq(users.id, 1));115116// Join117const result = await db118 .select({ userName: users.name, postTitle: posts.title })119 .from(users)120 .leftJoin(posts, eq(users.id, posts.authorId))121 .orderBy(desc(users.createdAt))122 .limit(10);123```124125### Relations126```typescript127import { relations } from 'drizzle-orm';128129export const usersRelations = relations(users, ({ many }) => ({130 posts: many(posts),131}));132133export const postsRelations = relations(posts, ({ one }) => ({134 author: one(users, { fields: [posts.authorId], references: [users.id] }),135}));136137// Query with relations138const usersWithPosts = await db.query.users.findMany({139 with: { posts: true },140});141```142143### Migrations144```bash145# Generate migration146npx drizzle-kit generate147148# Apply migration149npx drizzle-kit migrate150151# Push schema directly (dev only)152npx drizzle-kit push153154# Open studio155npx drizzle-kit studio156```157158### Transactions159```typescript160await db.transaction(async (tx) => {161 const user = await tx.insert(users).values({ name: 'Alice' }).returning();162 await tx.insert(posts).values({ title: 'Hello', authorId: user[0].id });163});164```165166## Common Patterns167168- **drizzle.config.ts**: Configure schema path, output dir, DB driver169- **Connection pooling**: Use with Neon serverless, PgBouncer, or Hyperdrive170- **Edge deployment**: Works with Cloudflare D1, Turso, Neon serverless driver171- **Seeding**: Create seed scripts using the same schema types172173## How to Use1741751. Understand the requirement and existing codebase patterns1762. Design the solution with error handling and testability in mind1773. Implement incrementally with tests for each change1784. Verify against expected outcomes (manual and automated)1795. Document usage, edge cases, and integration points1806. Review with team before merging to shared branches181182## Red Flags183184- **Skipping tests to ship faster**: Untested code breaks in production when you least expect it185- **No error handling in production code**: Unhandled errors crash services and lose user data186- **Hardcoded configuration values**: Hardcoded values prevent environment switching and leak secrets187- **Ignoring security implications**: Missing input validation, auth bypasses, and injection vulnerabilities188- **Over-engineering simple solutions**: Premature abstraction adds complexity without proportional benefit189190## Verification191192- [ ] Skill output matches expected behavior193194## Process1951961. Analyze the task requirements1972. Apply domain expertise1983. Verify output quality199200## Anti-Rationalization Table201202| Rationalization | Reality |203|---|---|204| "Tests slow me down" | Bugs slow you down 10x more. Tests are speed, not overhead. |205| "I will refactor later" | Technical debt compounds. Refactor as you go. |206| "It works on my machine" | If it is not in CI, it does not work. Ship proof, not claims. |