{"id":"drizzle","kind":"sdk","name":"Drizzle ORM","slug":"drizzle","description":"Lightweight TypeScript ORM with SQL-like schema and queries.","vendor":"Drizzle Team","languages":["typescript","javascript","nodejs"],"categories":["database","devtools"],"homepage":"https://orm.drizzle.team","docsUrl":"https://orm.drizzle.team/docs/overview","githubUrl":"https://github.com/drizzle-team/drizzle-orm","packages":[{"registry":"npm","name":"drizzle-orm","url":"https://www.npmjs.com/package/drizzle-orm"}],"tags":["orm","sql"],"skills":[{"name":"drizzle-orm","url":"https://skills.sh/bobmatnyc/claude-mpm-skills/drizzle-orm","install":"npx skills add bobmatnyc/claude-mpm-skills --skill drizzle-orm","sdk":"drizzle","key":"drizzle/drizzle-orm","description":"Type-safe SQL ORM for TypeScript with zero runtime overhead","hasContent":true,"content":"---\nname: drizzle-orm\ndescription: \"Type-safe SQL ORM for TypeScript with zero runtime overhead\"\nuser-invocable: false\ndisable-model-invocation: true\nprogressive_disclosure:\n  entry_point:\n    summary: \"Type-safe SQL ORM for TypeScript with zero runtime overhead\"\n    when_to_use: \"When working with drizzle-orm or related functionality.\"\n    quick_start: \"1. Review the core concepts below. 2. Apply patterns to your use case. 3. Follow best practices for implementation.\"\n  references:\n    - advanced-schemas.md\n    - performance.md\n    - query-patterns.md\n    - vs-prisma.md\n---\n# Drizzle ORM\n\nModern TypeScript-first ORM with zero dependencies, compile-time type safety, and SQL-like syntax. Optimized for edge runtimes and serverless environments.\n\n## Quick Start\n\n### Installation\n\n```bash\n# Core ORM\nnpm install drizzle-orm\n\n# Database driver (choose one)\nnpm install pg            # PostgreSQL\nnpm install mysql2        # MySQL\nnpm install better-sqlite3 # SQLite\n\n# Drizzle Kit (migrations)\nnpm install -D drizzle-kit\n```\n\n### Basic Setup\n\n```typescript\n// db/schema.ts\nimport { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';\n\nexport const users = pgTable('users', {\n  id: serial('id').primaryKey(),\n  email: text('email').notNull().unique(),\n  name: text('name').notNull(),\n  createdAt: timestamp('created_at').defaultNow(),\n});\n\n// db/client.ts\nimport { drizzle } from 'drizzle-orm/node-postgres';\nimport { Pool } from 'pg';\nimport * as schema from './schema';\n\nconst pool = new Pool({ connectionString: process.env.DATABASE_URL });\nexport const db = drizzle(pool, { schema });\n```\n\n### First Query\n\n```typescript\nimport { db } from './db/client';\nimport { users } from './db/schema';\nimport { eq } from 'drizzle-orm';\n\n// Insert\nconst newUser = await db.insert(users).values({\n  email: 'user@example.com',\n  name: 'John Doe',\n}).returning();\n\n// Select\nconst allUsers = await db.select().from(users);\n\n// Where\nconst user = await db.select().from(users).where(eq(users.id, 1));\n\n// Update\nawait db.update(users).set({ name: 'Jane Doe' }).where(eq(users.id, 1));\n\n// Delete\nawait db.delete(users).where(eq(users.id, 1));\n```\n\n## Schema Definition\n\n### Column Types Reference\n\n| PostgreSQL | MySQL | SQLite | TypeScript |\n|------------|-------|--------|------------|\n| `serial()` | `serial()` | `integer()` | `number` |\n| `text()` | `text()` | `text()` | `string` |\n| `integer()` | `int()` | `integer()` | `number` |\n| `boolean()` | `boolean()` | `integer()` | `boolean` |\n| `timestamp()` | `datetime()` | `integer()` | `Date` |\n| `json()` | `json()` | `text()` | `unknown` |\n| `uuid()` | `varchar(36)` | `text()` | `string` |\n\n### Common Schema Patterns\n\n```typescript\nimport { pgTable, serial, text, varchar, integer, boolean, timestamp, json, unique } from 'drizzle-orm/pg-core';\n\nexport const users = pgTable('users', {\n  id: serial('id').primaryKey(),\n  email: varchar('email', { length: 255 }).notNull().unique(),\n  passwordHash: varchar('password_hash', { length: 255 }).notNull(),\n  role: text('role', { enum: ['admin', 'user', 'guest'] }).default('user'),\n  metadata: json('metadata').$type<{ theme: string; locale: string }>(),\n  isActive: boolean('is_active').default(true),\n  createdAt: timestamp('created_at').defaultNow().notNull(),\n  updatedAt: timestamp('updated_at').defaultNow().notNull(),\n}, (table) => ({\n  emailIdx: unique('email_unique_idx').on(table.email),\n}));\n\n// Infer TypeScript types\ntype User = typeof users.$inferSelect;\ntype NewUser = typeof users.$inferInsert;\n```\n\n## Relations\n\n### One-to-Many\n\n```typescript\nimport { pgTable, serial, text, integer } from 'drizzle-orm/pg-core';\nimport { relations } from 'drizzle-orm';\n\nexport const authors = pgTable('authors', {\n  id: serial('id').primaryKey(),\n  name: text('name').notNull(),\n});\n\nexport const posts = pgTable('posts', {\n  id: serial('id').primaryKey(),\n  title: text('title').notNull(),\n  authorId: integer('author_id').notNull().references(() => authors.id),\n});\n\nexport const authorsRelations = relations(authors, ({ many }) => ({\n  posts: many(posts),\n}));\n\nexport const postsRelations = relations(posts, ({ one }) => ({\n  author: one(authors, {\n    fields: [posts.authorId],\n    references: [authors.id],\n  }),\n}));\n\n// Query with relations\nconst authorsWithPosts = await db.query.authors.findMany({\n  with: { posts: true },\n});\n```\n\n### Many-to-Many\n\n```typescript\nexport const users = pgTable('users', {\n  id: serial('id').primaryKey(),\n  name: text('name').notNull(),\n});\n\nexport const groups = pgTable('groups', {\n  id: serial('id').primaryKey(),\n  name: text('name').notNull(),\n});\n\nexport const usersToGroups = pgTable('users_to_groups', {\n  userId: integer('user_id').notNull().references(() => users.id),\n  groupId: integer('group_id').notNull().references(() => groups.id),\n}, (table) => ({\n  pk: primaryKey({ columns: [table.userId, table.groupId] }),\n}));\n\nexport const usersRelations = relations(users, ({ many }) => ({\n  groups: many(usersToGroups),\n}));\n\nexport const groupsRelations = relations(groups, ({ many }) => ({\n  users: many(usersToGroups),\n}));\n\nexport const usersToGroupsRelations = relations(usersToGroups, ({ one }) => ({\n  user: one(users, { fields: [usersToGroups.userId], references: [users.id] }),\n  group: one(groups, { fields: [usersToGroups.groupId], references: [groups.id] }),\n}));\n```\n\n## Queries\n\n### Filtering\n\n```typescript\nimport { eq, ne, gt, gte, lt, lte, like, ilike, inArray, isNull, isNotNull, and, or, between } from 'drizzle-orm';\n\n// Equality\nawait db.select().from(users).where(eq(users.email, 'user@example.com'));\n\n// Comparison\nawait db.select().from(users).where(gt(users.id, 10));\n\n// Pattern matching\nawait db.select().from(users).where(like(users.name, '%John%'));\n\n// Multiple conditions\nawait db.select().from(users).where(\n  and(\n    eq(users.role, 'admin'),\n    gt(users.createdAt, new Date('2024-01-01'))\n  )\n);\n\n// IN clause\nawait db.select().from(users).where(inArray(users.id, [1, 2, 3]));\n\n// NULL checks\nawait db.select().from(users).where(isNull(users.deletedAt));\n```\n\n### Joins\n\n```typescript\nimport { eq } from 'drizzle-orm';\n\n// Inner join\nconst result = await db\n  .select({\n    user: users,\n    post: posts,\n  })\n  .from(users)\n  .innerJoin(posts, eq(users.id, posts.authorId));\n\n// Left join\nconst result = await db\n  .select({\n    user: users,\n    post: posts,\n  })\n  .from(users)\n  .leftJoin(posts, eq(users.id, posts.authorId));\n\n// Multiple joins with aggregation\nimport { count, sql } from 'drizzle-orm';\n\nconst result = await db\n  .select({\n    authorName: authors.name,\n    postCount: count(posts.id),\n  })\n  .from(authors)\n  .leftJoin(posts, eq(authors.id, posts.authorId))\n  .groupBy(authors.id);\n```\n\n### Pagination & Sorting\n\n```typescript\nimport { desc, asc } from 'drizzle-orm';\n\n// Order by\nawait db.select().from(users).orderBy(desc(users.createdAt));\n\n// Limit & offset\nawait db.select().from(users).limit(10).offset(20);\n\n// Pagination helper\nfunction paginate(page: number, pageSize: number = 10) {\n  return db.select().from(users)\n    .limit(pageSize)\n    .offset(page * pageSize);\n}\n```\n\n## Transactions\n\n```typescript\n// Auto-rollback on error\nawait db.transaction(async (tx) => {\n  await tx.insert(users).values({ email: 'user@example.com', name: 'John' });\n  await tx.insert(posts).values({ title: 'First Post', authorId: 1 });\n  // If any query fails, entire transaction rolls back\n});\n\n// Manual control\nconst tx = db.transaction(async (tx) => {\n  const user = await tx.insert(users).values({ ... }).returning();\n\n  if (!user) {\n    tx.rollback();\n    return;\n  }\n\n  await tx.insert(posts).values({ authorId: user.id });\n});\n```\n\n## Migrations\n\n### Drizzle Kit Configuration\n\n```typescript\n// drizzle.config.ts\nimport type { Config } from 'drizzle-kit';\n\nexport default {\n  schema: './db/schema.ts',\n  out: './drizzle',\n  dialect: 'postgresql',\n  dbCredentials: {\n    url: process.env.DATABASE_URL!,\n  },\n} satisfies Config;\n```\n\n### Migration Workflow\n\n```bash\n# Generate migration\nnpx drizzle-kit generate\n\n# View SQL\ncat drizzle/0000_migration.sql\n\n# Apply migration\nnpx drizzle-kit migrate\n\n# Introspect existing database\nnpx drizzle-kit introspect\n\n# Drizzle Studio (database GUI)\nnpx drizzle-kit studio\n```\n\n### Example Migration\n\n```sql\n-- drizzle/0000_initial.sql\nCREATE TABLE IF NOT EXISTS \"users\" (\n  \"id\" serial PRIMARY KEY NOT NULL,\n  \"email\" varchar(255) NOT NULL,\n  \"name\" text NOT NULL,\n  \"created_at\" timestamp DEFAULT now() NOT NULL,\n  CONSTRAINT \"users_email_unique\" UNIQUE(\"email\")\n);\n```\n\n## Navigation\n\n### Detailed References\n\n- **[🏗️ Advanced Schemas](./references/advanced-schemas.md)** - Custom types, composite keys, indexes, constraints, multi-tenant patterns. Load when designing complex database schemas.\n\n- **[🔍 Query Patterns](./references/query-patterns.md)** - Subqueries, CTEs, raw SQL, prepared statements, batch operations. Load when optimizing queries or handling complex filtering.\n\n- **[⚡ Performance](./references/performance.md)** - Connection pooling, query optimization, N+1 prevention, prepared statements, edge runtime integration. Load when scaling or optimizing database performance.\n\n- **[🔄 vs Prisma](./references/vs-prisma.md)** - Feature comparison, migration guide, when to choose Drizzle over Prisma. Load when evaluating ORMs or migrating from Prisma.\n\n## Red Flags\n\n**Stop and reconsider if:**\n- Using `any` or `unknown` for JSON columns without type annotation\n- Building raw SQL strings without using `sql` template (SQL injection risk)\n- Not using transactions for multi-step data modifications\n- Fetching all rows without pagination in production queries\n- Missing indexes on foreign keys or frequently queried columns\n- Using `select()` without specifying columns for large tables\n\n## Performance Benefits vs Prisma\n\n| Metric | Drizzle | Prisma |\n|--------|---------|--------|\n| **Bundle Size** | ~35KB | ~230KB |\n| **Cold Start** | ~10ms | ~250ms |\n| **Query Speed** | Baseline | ~2-3x slower |\n| **Memory** | ~10MB | ~50MB |\n| **Type Generation** | Runtime inference | Build-time generation |\n\n## Integration\n\n- **typescript-core**: Type-safe schema inference with `satisfies`\n- **nextjs-core**: Server Actions, Route Handlers, Middleware integration\n- **Database Migration**: Safe schema evolution patterns\n\n## Related Skills\n\nWhen using Drizzle, these skills enhance your workflow:\n- **prisma**: Alternative ORM comparison: Drizzle vs Prisma trade-offs\n- **typescript**: Advanced TypeScript patterns for type-safe queries\n- **nextjs**: Drizzle with Next.js Server Actions and API routes\n- **sqlalchemy**: SQLAlchemy patterns for Python developers learning Drizzle\n\n[Full documentation available in these skills if deployed in your bundle]\n","contentSource":"skills.sh/api/download/bobmatnyc/claude-mpm-skills/drizzle-orm","contentFetchedAt":"2026-07-27T08:59:29.940Z"},{"name":"drizzle-best-practices","url":"https://skills.sh/honra-io/drizzle-best-practices/drizzle-best-practices","install":"npx skills add honra-io/drizzle-best-practices","sdk":"drizzle","key":"drizzle/drizzle-best-practices","description":"|","hasContent":true,"content":"---\nname: drizzle-best-practices\ndescription: |\n  Use this skill whenever the user is working with Drizzle ORM on PostgreSQL. This covers any mention of Drizzle, drizzle-orm, drizzle-kit, drizzle-zod, `pgTable`, `defineRelations`, `relations()`, `db.select()`, `db.query`, or insert/update/delete against Postgres.\n\n  Typical intents to trigger on:\n  - Designing or debugging Postgres table schemas, columns, identity PKs, enums, JSONB, arrays\n  - Modeling one-to-many or many-to-many relations and join tables in Drizzle\n  - Writing, optimizing, or preparing Drizzle queries (placeholders, `.prepare()`)\n  - Generating Zod validators from Drizzle tables\n  - Setting up TypeScript + Postgres projects (Neon, Supabase, postgres.js, node-postgres) with Drizzle\n  - Migrating from Prisma, TypeORM, or Sequelize **to Drizzle**\n  - Resolving Drizzle type errors; choosing between v1 RC and 0.45.x APIs\n\n  Do NOT trigger for Drizzle with MySQL/SQLite, raw SQL without an ORM, or other ORMs when Drizzle is not the target.\nlicense: MIT\ncompatibility: TypeScript projects using Node.js or edge runtimes with drizzle-orm and a PostgreSQL database.\nmetadata:\n  author: Marc A. Maceira Zayas\n  abstract: >\n    Comprehensive Drizzle ORM best practices guide for TypeScript developers building on\n    PostgreSQL. Contains guidance across 8 categories from critical (schema design, query\n    patterns) to incremental (advanced features). Each reference includes explanations,\n    correct vs incorrect code examples, and rationale for why the pattern matters.\n    Engine-specific Postgres patterns (identity columns, JSONB, arrays, enums, etc.) are\n    documented in a dedicated reference file to keep the skill modular.\n---\n\n# Drizzle ORM Best Practices (PostgreSQL)\n\nComprehensive best practices guide for Drizzle ORM with PostgreSQL. Contains guidance across\n8 categories, prioritized by impact to help you write correct, performant, and maintainable\ndatabase code.\n\n## Version & API Detection (read this first)\n\nDrizzle is mid-transition to **v1**, and the relations + relational-query APIs differ between\nthe two major lines. **Check the project's `package.json` before writing code** so you emit the\nright syntax:\n\n| Installed `drizzle-orm` | API to use | Install command |\n|---|---|---|\n| `^1.0.0-rc` or `^1.0.0-beta` | **v1 — the default in this skill.** `defineRelations`, object-syntax relational queries (`where: { … }`, `orderBy: { … }`), validators from `drizzle-orm/zod` | `npm i drizzle-orm@rc` + `npm i -D drizzle-kit@rc` |\n| `^0.4x` (e.g. `0.45.2`) | **Legacy.** `relations()` helper, callback/operator relational queries, validators from the separate `drizzle-zod` package | `npm i drizzle-orm` (resolves to 0.45.2) |\n\nThe current release candidate is **`drizzle-orm@1.0.0-rc.3`** (the `@rc` tag), which supersedes the\nolder `@beta` tag the docs still reference in places.\n\nThree things that routinely trip up agents:\n\n- **`@latest` is still `0.45.2`, not v1.** `npm i drizzle-orm` does *not* get you v1 — a new project\n  that wants the v1 API must ask for `@rc` explicitly.\n- **The SQL-like query builder is unchanged across versions.** `db.select().from(t).where(eq(t.id, 1))`,\n  `db.insert()`, `db.update()`, `db.delete()` work identically in 0.45.x and v1. Only the relational\n  query API (`db.query`) and relation *definitions* changed. Never rewrite `db.select()` operator\n  filters into the relational object syntax.\n- **On v1, the relational query API (`db.query`) is driven by `defineRelations`.** Passing a\n  legacy `schema` does *not* populate `db.query`. The old `relations()` helper is still importable\n  from `drizzle-orm/_relations` so existing relation modules keep compiling during a port, but to\n  query relationally on v1 you convert them to `defineRelations`. (Earlier betas exposed a\n  `db._query` path; it was removed before `1.0.0-rc.3`.) See `references/relations-defining.md`.\n\nWhen the version is unstated, default to **v1 (RC)** for new code, but match the existing codebase's\nAPI if you already see legacy `relations()` / callback-style `db.query` patterns in use. Throughout\nthe reference files, version-specific differences are marked with **\"Legacy (v0.45.x)\"** callouts.\n\n## When to Apply\n\nReference these guidelines when:\n\n- Defining table schemas with `pgTable`\n- Writing select, insert, update, or delete queries\n- Setting up relations between tables using `defineRelations` or the legacy `relations` API\n- Configuring `drizzle-kit` for migrations (`generate`, `push`, `pull`)\n- Inferring TypeScript types from your schema\n- Choosing between the SQL-like API and the relational query API\n- Optimizing query performance with prepared statements or batch operations\n- Integrating Drizzle with serverless Postgres providers (Neon, Supabase, etc.)\n\n## Rule Categories by Priority\n\n| Priority | Category | Impact | Prefix |\n|----------|----------|--------|--------|\n| 1 | Schema Design | CRITICAL | `schema-` |\n| 2 | Query Patterns | CRITICAL | `query-` |\n| 3 | Relations | HIGH | `relations-` |\n| 4 | Migrations | HIGH | `migrations-` |\n| 5 | Type Safety | MEDIUM-HIGH | `types-` |\n| 6 | Performance | MEDIUM | `perf-` |\n| 7 | Database Drivers | MEDIUM | `driver-` |\n| 8 | Advanced Patterns | LOW | `advanced-` |\n\n## How to Use\n\nRead individual reference files for detailed explanations and code examples:\n\n```\nreferences/engine-postgres.md          # Postgres-specific types, features, and patterns\nreferences/schema-table-definitions.md\nreferences/query-select-patterns.md\nreferences/relations-defining.md\nreferences/_sections.md                # Full index of all references\n```\n\nEach reference file contains:\n\n- Brief explanation of why it matters\n- Incorrect code example with explanation\n- Correct code example with explanation\n- Links to official Drizzle documentation\n\n## References\n\n- https://orm.drizzle.team/docs/overview\n- https://orm.drizzle.team/docs/sql-schema-declaration\n- https://orm.drizzle.team/docs/relations-v2\n- https://orm.drizzle.team/docs/perf-queries\n- https://orm.drizzle.team/docs/kit-overview\n- https://orm.drizzle.team/llms.txt\n","contentSource":"skills.sh/api/download/honra-io/drizzle-best-practices/drizzle-best-practices","contentFetchedAt":"2026-07-27T08:59:30.022Z"}],"official":true,"generatedAt":"2026-07-27T09:02:29.956Z"}