drizzle-orm · oakoss — Claude Code skill: what it does, how to install
Equips coding agents with schema conventions, query patterns, and migration workflows for Drizzle ORM across PostgreSQL, MySQL, and SQLite.
MIT 263 installs ★ 29 updated 2026-08-17
npx skills add oakoss/agent-skills --skill drizzle-orm -a claude-codeWhat drizzle-orm does
This skill guides the agent in writing TypeScript schemas and SQL queries using Drizzle ORM. It covers schema declarations such as pgTable, relation mapping, and both the SQL-like query builder and the db.query relational API.
It also prevents syntax pitfalls, such as forgetting .where() on deletions or importing column types from the wrong dialect module. The relational API strictly requires passing { schema } to the drizzle() client initialization.
What it helps with
- define database schemas for PostgreSQL, MySQL, or SQLite
- build type-safe queries with joins, filters, and transactions
- run database migrations using drizzle-kit
- declare table relations and infer TypeScript types
Example prompts for the agent
- Define a PostgreSQL users table with identity columns and indexes
- Write an upsert query with onConflictDoUpdate for user profiles
- Set up a multi-table database transaction with rollback handling
How to install drizzle-orm
1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill drizzle-orm -a claude-code2Manually: put the files in place
~/.claude/skills/drizzle-orm/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/drizzle-orm/
1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill drizzle-orm -a codex2Manually: put the files in place
.agents/skills/drizzle-orm/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill drizzle-orm -a cursor2Manually: put the files in place
.cursor/skills/drizzle-orm/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install oakoss/agent-skills skills/drizzle-orm2Manually: put the files in place
.github/skills/drizzle-orm/SKILL.md1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill drizzle-orm -a gemini-cli2Platform CLI
gemini skills install https://github.com/oakoss/agent-skills --path skills/drizzle-ormManually: put the files in place
.devin/skills/drizzle-orm/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill drizzle-orm -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about drizzle-orm
How to install drizzle-orm in Claude Code?
Run npx skills add oakoss/agent-skills --skill drizzle-orm -a claude-code.
What does the drizzle-orm skill do?
It provides the agent with conventions for schema design, SQL-like queries, relation mappings, and drizzle-kit migration commands.
When should relations() be used instead of .references()?
Use .references() to define SQL-level foreign keys, while relations() configures logical relationships required by the db.query relational API.
Source text
SKILL.md · MIT
---
name: drizzle-orm
description: 'Drizzle ORM for type-safe SQL with PostgreSQL, MySQL, and SQLite. Use when defining schemas, writing queries, managing relations, running migrations, or using drizzle-kit. Use for drizzle, orm, schema, query, migration, pgTable, relations, drizzle-kit, drizzle-zod.'
license: MIT
metadata:
author: oakoss
version: '1.1'
source: 'https://orm.drizzle.team/docs/overview'
user-invocable: false
---
# Drizzle ORM
## Overview
Drizzle ORM is a lightweight, type-safe TypeScript ORM that maps directly to SQL for PostgreSQL, MySQL, and SQLite. It provides both a SQL-like query builder and a relational queries API, with zero dependencies and full serverless compatibility. Use Drizzle when you need compile-time type safety with SQL-level control; avoid it when you need a full active-record ORM with automatic migrations (use Prisma) or when working with MongoDB/NoSQL databases.
## Quick Reference
| Pattern | API | Key Points |
| ------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------- |
| Schema definition | `pgTable('name', { columns }, (t) => [indexes])` | Third arg returns array of indexes/constraints |
| Column types | `text()`, `integer()`, `boolean()`, `timestamp()` | Import from `drizzle-orm/pg-core` |
| Type inference | `typeof table.$inferSelect`, `$inferInsert` | Derive TS types directly from schema |
| Relational queries | `db.query.table.findMany({ with, where })` | Requires schema passed to `drizzle()` client |
| SQL-like queries | `db.select().from(table).where()` | Chainable, returns array of rows |
| Insert | `db.insert(table).values({}).returning()` | `.returning()` for getting inserted rows |
| Update | `db.update(table).set({}).where().returning()` | Always include `.where()` to avoid full-table updates |
| Delete | `db.delete(table).where()` | Always include `.where()` to avoid full-table deletes |
| Upsert | `.onConflictDoUpdate({ target, set })` | Chain after `.insert().values()` |
| Transactions | `db.transaction(async (tx) => { ... })` | Auto-rollback on thrown errors |
| Filters | `eq()`, `and()`, `or()`, `inArray()`, `sql\`\`` | Import operators from `drizzle-orm` |
| Relations | `relations(table, ({ one, many }) => ({}))` | Declares logical relations for relational queries |
| Generate migrations | `drizzle-kit generate` | Creates SQL migration files from schema diff |
| Apply migrations | `drizzle-kit migrate` or `migrate()` in code | Applies pending migrations to database |
| Push schema | `drizzle-kit push` | Direct schema push without migration files |
| Prepared statements | `db.select().from(t).where(eq(t.id, sql.placeholder('id'))).prepare()` | Reusable parameterized queries |
| Views | `pgView('name').as(qb => ...)` | Regular and materialized views |
| $count utility | `db.$count(table, filter?)` | Shorthand count, usable as subquery |
| Generated columns | `text().generatedAlwaysAs(() => sql\`...\`)` | Computed columns (virtual or stored) |
| Check constraints | `check('name', sql\`condition\`)` | Row-level validation at database level |
## Common Mistakes
| Mistake | Correct Pattern |
| -------------------------------------------------- | --------------------------------------------------------------------- |
| Missing `.returning()` on insert/update | Chain `.returning()` to get back inserted/updated rows |
| Omitting `.where()` on update/delete | Always provide `.where()` to avoid affecting all rows |
| Using `any` for query result types | Use `$inferSelect` / `$inferInsert` for type-safe results |
| Not passing `schema` to `drizzle()` client | Pass `{ schema }` to enable `db.query` relational API |
| Forgetting indexes on foreign key columns | Add explicit indexes for columns used in joins/lookups |
| Wrapping related writes without a transaction | Use `db.transaction()` for multi-table mutations |
| Using raw column names with `casing: 'snake_case'` | With casing option, define columns in camelCase without name arg |
| Declaring relations but missing the inverse | Both sides of a relation need declarations for relational queries |
| Using `serial()` in new PostgreSQL schemas | Prefer `integer().generatedAlwaysAsIdentity()` (modern approach) |
| Not handling `findFirst` returning `undefined` | Check for `undefined` before accessing properties |
| Importing column types from wrong dialect module | Use `drizzle-orm/pg-core` for PostgreSQL, `mysql-core`, `sqlite-core` |
| Using `.references()` instead of `relations()` | `.references()` is SQL foreign key; `relations()` is for query API |
## Delegation
> If the `tanstack-query` skill is available, delegate client-side caching and server state management to it.
> Otherwise, recommend: `npx skills add oakoss/agent-skills --skill tanstack-query`
>
> If the `tanstack-start` skill is available, delegate server function patterns for database access to it.
> Otherwise, recommend: `npx skills add oakoss/agent-skills --skill tanstack-start`
>
> If the `electricsql` skill is available, delegate Electric setup, shape configuration, and write patterns to it.
> Otherwise, recommend: `pnpm dlx skills add oakoss/agent-skills -s electricsql -a claude-code -y`
>
> If the `pglite` skill is available, delegate PGlite-specific configuration, extensions, and browser storage patterns to it.
> Otherwise, recommend: `pnpm dlx skills add oakoss/agent-skills -s pglite -a claude-code -y`
- **Schema validation**: Use `drizzle-zod` to generate Zod schemas from Drizzle tables for input validation
- **Query pattern discovery**: Use `Explore` agent
- **Code review**: Delegate to `code-reviewer` agent
## References
- [Schema definition, column types, constraints, indexes, and type inference](references/schema-definition.md)
- [Relational queries, SQL-like API, joins, subqueries, and aggregations](references/queries.md)
- [Insert, update, delete, upsert, and transactions](references/mutations.md)
- [Relations: one, many, nested with clauses, self-referencing](references/relations.md)
- [Migrations: drizzle-kit generate, migrate, push, pull, studio](references/migrations.md)
- [Filter operators: eq, ne, gt, lt, like, inArray, sql template](references/filters-and-operators.md)
- [Views, materialized views, generated columns, check constraints, $count, batch API](references/views-and-advanced.md)
- [ElectricSQL + PGlite integration: driver setup, schema-to-shape mapping, type inference, local sync](references/electric-integration.md)
© oakoss · MIT · oakoss/agent-skills
Similar skills
All skills for Data and databases →drizzle-orm by other authors comes first.