Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill drizzle-orm -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/drizzle-orm/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/drizzle-orm/

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.

From the same set106

The whole set →
ui-ux-polish ui-ux-polish — a skill that runs repeated polish passes on a working web app, treating desktop and mobile separately and checking accessibility along the way. CX Codex +1 577installs playwright Teaches your agent the Playwright API: locators, assertions, screenshots and PDFs, stealth mode, authenticated sessions, error fixes. CX Codex +1 476installs coolify A skill for driving self-hosted Coolify from your agent: app deploys, webhooks, CI/CD and build-pack troubleshooting. CX Codex +1 385installs application-security application-security walks your code and design through OWASP Top 10 and STRIDE, then hands over a pre-deploy checklist plus the compliance angles for GDPR, HIPAA, SOC 2 and PCI-DSS. CX Codex +1 287installs brand-designer brand-designer is a Claude Code skill for building visual brand identities, from logos to brand guidelines. It responds to requests for palettes, typography systems, and social media templates. CX Codex +1 242installs tailwind A Tailwind CSS v4 skill for themes, components, dark mode, container queries, v3 migrations, shadcn/ui, and build troubleshooting. CX Codex +1 233installs vitest-testing vitest-testing adds Vitest patterns and best practices to Claude Code. Helps write reliable unit, component, and hook tests without typical async mistakes. CX Codex +1 226installs content-humanizer content-humanizer rewrites model-written drafts so they read like a person wrote them: sentence rhythm, tone, and the hedging that gives AI text away. CX Codex +1 225installs

Project sponsors

Companies that keep this analytics open