Required dependencies

# Core (always required)
npm install drizzle-orm

# Choose ONE driver adapter based on your database:

# PostgreSQL – node-postgres
npm install pg
npm install --save-dev @types/pg

# PostgreSQL – postgres.js
npm install postgres

# PostgreSQL – Neon serverless
npm install @neondatabase/serverless

# MySQL – mysql2
npm install mysql2

# SQLite – better-sqlite3
npm install better-sqlite3
npm install --save-dev @types/better-sqlite3

# SQLite – Bun built-in (no extra install)

# AWS RDS Data API
npm install @aws-sdk/client-rds-data

# Migrations (CLI companion, dev only)
npm install --save-dev drizzle-kit

No native build steps, pod installs, or Android linking are required for server-side Node.js use. Expo SQLite (expo-sqlite/) requires npx expo prebuild and a managed/bare Expo project.

Project setup

1. Drop the source. Copy the source/ directory into your project, e.g. src/drizzle-orm/.

2. Configure tsconfig.json paths so imports resolve cleanly:

{
  "compilerOptions": {
    "strict": true,
    "moduleResolution": "bundler",
    "paths": {
      "~/sql/sql.ts": ["./src/drizzle-orm/sql/sql.ts"],
      "~/*": ["./src/drizzle-orm/*"]
    }
  }
}

3. Choose a driver and import from its subdirectory (e.g. src/drizzle-orm/node-postgres).

4. Environment variables (driver-specific, not ORM-specific):

   • DATABASE_URL – standard connection string consumed by your driver of choice.
   • AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY – required for aws-data-api/pg.

5. Optional: enable logging by passing a logger option to drizzle():

import { DefaultLogger } from './src/drizzle-orm/logger';
// pass { logger: new DefaultLogger() } to drizzle(driver, { logger })

Public API

sql (template tag)

import { sql } from 'drizzle-orm'; // or from './source/sql/index.ts'

const fragment: SQL = sql`SELECT * FROM ${usersTable} WHERE id = ${userId}`;

The sql tagged template literal builds a parameterized SQL object. Use it wherever you need raw SQL fragments inside query builders, default column values, or where conditions that exceed the query builder's helpers.

relations

import { relations } from 'drizzle-orm';

const userRelations = relations(users, ({ one, many }) => ({
  profile: one(profiles, { fields: [users.id], references: [profiles.userId] }),
  posts: many(posts),
}));

Declares relational metadata consumed by Drizzle's Relational Query Builder (db.query.*). Call it once per table, alongside the table definition. Required when using findFirst / findMany with with: includes.

getValueFromDataApi

import { getValueFromDataApi } from './source/aws-data-api/common/index.ts';
import type { Field } from '@aws-sdk/client-rds-data';

const jsValue = getValueFromDataApi(field as Field);

Converts a single AWS RDS Data API Field union type into a plain JavaScript value. Used internally by the aws-data-api/pg session, but exposed for custom result-set processors that work directly with the AWS SDK response.

typingsToAwsTypeHint

import { typingsToAwsTypeHint } from './source/aws-data-api/common/index.ts';
import type { QueryTypingsValue } from './source/sql/sql.ts';

const hint = typingsToAwsTypeHint('uuid'); // TypeHint.UUID

Maps Drizzle's internal QueryTypingsValue strings ('date', 'uuid', 'json', etc.) to the AWS TypeHint enum required when sending parameters to the RDS Data API. Use it when building a custom RDS Data API adapter or middleware layer.

Working examples

Scenario - Define a PostgreSQL schema and query with node-postgres

Declare a typed table, run a select, and use sql for a raw fragment.

import { drizzle } from 'drizzle-orm/node-postgres';
import { pgTable, serial, text, varchar } from 'drizzle-orm/pg-core';
import { sql, eq } from 'drizzle-orm';
import { Pool } from 'pg';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(pool);

const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: varchar('name', { length: 100 }).notNull(),
  email: text('email').notNull(),
});

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

// Raw SQL fragment
const count = await db.execute(sql`SELECT COUNT(*) FROM ${users}`);

// Filtered select
const user = await db.select().from(users).where(eq(users.id, 1));

Scenario - Relational query with one-to-many

Use relations to declare associations and db.query to fetch nested data.

import { drizzle } from 'drizzle-orm/node-postgres';
import { pgTable, serial, text, integer } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';
import { Pool } from 'pg';

const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
});

const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  authorId: integer('author_id').notNull(),
});

const userRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));

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

const db = drizzle(new Pool({ connectionString: process.env.DATABASE_URL }), {
  schema: { users, posts, userRelations, postRelations },
});

const result = await db.query.users.findMany({
  with: { posts: true },
});

Scenario - AWS RDS Data API field deserialization

Process a raw AWS RDS Data API response using the exposed helpers.

import { getValueFromDataApi, typingsToAwsTypeHint, toValueParam } from './source/aws-data-api/common/index.ts';
import { RDSDataClient, ExecuteStatementCommand } from '@aws-sdk/client-rds-data';

const client = new RDSDataClient({ region: 'us-east-1' });

const response = await client.send(new ExecuteStatementCommand({
  resourceArn: process.env.DB_ARN!,
  secretArn: process.env.DB_SECRET!,
  database: 'mydb',
  sql: 'SELECT id, created_at FROM events WHERE id = :id',
  parameters: [
    toValueParam('550e8400-e29b-41d4-a716-446655440000', 'uuid').value
      ? { name: 'id', ...toValueParam('550e8400-e29b-41d4-a716-446655440000', 'uuid') }
      : { name: 'id', value: { stringValue: '550e8400-e29b-41d4-a716-446655440000' } },
  ],
}));

const rows = response.records?.map(row => row.map(getValueFromDataApi));
console.log(rows);

File walkthrough

• index.ts - Barrel that re-exports every public symbol from the core modules.
• alias.ts - Implements aliasedTable() for giving tables query-scoped aliases.
• column-builder.ts - Abstract ColumnBuilder wired into the schema DSL chain.
• column.ts - Runtime Column class carrying type metadata and constraints.
• entity.ts - Lightweight brand-tagging so the ORM can identify its own objects at runtime.
• errors.ts - DrizzleError and related typed exceptions.
• logger.ts - Logger interface plus DefaultLogger that writes to console.
• operations.ts - Internal helpers for constructing INSERT / UPDATE / DELETE AST nodes.
• query-promise.ts - QueryPromise<T> base class making queries thenable and composable.
• relations.ts - relations(), one(), many() for Relational Query Builder declarations.
• sql/ - The sql tag, SQL AST node, Placeholder, operators, and type-hint constants.
• subquery.ts - Subquery wrapper enabling nested selects in from/join clauses.
• table.ts - Table base class, getTableName, getTableColumns inspection helpers.
• utils.ts - Internal helpers: mapValues, chunk, iife, etc.
• view-common.ts - Shared types for materialized and non-materialized view definitions.
• casing.ts - CasingCache and strategy objects for camelCase / snake_case mapping.
• session.ts - Abstract Session and Transaction that all drivers implement.
• migrator.ts - MigrationMeta type and base migration runner contract.
• tracing.ts / tracing-utils.ts - Optional OpenTelemetry span wrapping for queries.
• batch.ts - BatchItem type and batch execution helpers for supported drivers.
• cache/ - Pluggable query-result cache layer with TTL support.
• pg-core/ - Full PostgreSQL DDL types: pgTable, column builders, indexes, enums.
• mysql-core/ - MySQL DDL types: mysqlTable, column builders, indexes.
• sqlite-core/ - SQLite DDL types: sqliteTable, column builders.
• aws-data-api/ - RDS Data API field conversion utilities and PostgreSQL session adapter.
• better-sqlite3/ - Synchronous better-sqlite3 driver integration.
• bun-sql/ - Bun native SQL driver integration.
• neon-http/ - Neon serverless HTTP transport adapter.
• node-postgres/ - pg Pool/Client driver integration.
• libsql/ - LibSQL (Turso) driver integration.
• d1/ - Cloudflare D1 binding adapter.

Common pitfalls and fixes

• moduleResolution must be bundler or node16 - path aliases with .ts extensions in imports fail under classic node resolution; set "moduleResolution": "bundler" in tsconfig.json.
• ~/* path alias not resolved - The source uses ~/ as an alias for the source root; configure paths in tsconfig.json and mirror them in your bundler (Vite: resolve.alias, webpack: alias).
• Mixing ESM and CJS - The published drizzle-orm package ships dual ESM/CJS; if you copy source directly, ensure your build tool handles .ts re-exports and does not mix module formats.
• @aws-sdk/client-rds-data version pin - getValueFromDataApi depends on the Field union shape; pin to ^3.0.0 to avoid breaking field-type changes.
• relations not passed to drizzle() - Relational queries (db.query.*) silently return nothing if schema (including relation objects) is not passed as the second argument to drizzle().
• better-sqlite3 / bun-sqlite sync vs async - SQLite adapters execute synchronously; wrapping calls in async functions works, but do not await an already-resolved value expecting lazy execution.

Vibe-coding prompt template

I have the Drizzle ORM TypeScript source at `source/` in my project root,
and a usage guide at `USAGE.md`. The upstream package is `drizzle-orm`.

My project is a Node.js TypeScript Express API using [DESCRIBE YOUR DATABASE: e.g. PostgreSQL via node-postgres].

Please help me integrate Drizzle ORM step by step:

1. Read `USAGE.md` and `source/index.ts` to understand the public API.
2. Create a `src/db/schema.ts` file defining my tables: [LIST YOUR TABLES AND COLUMNS].
3. Create a `src/db/index.ts` that initializes the drizzle client using the appropriate driver from `source/`.
4. Add a `DATABASE_URL` environment variable and show how to load it.
5. Write typed query helpers for: select all, find by id, insert, update, delete.
6. If I have relations, use `relations()` from `source/relations.ts` and wire up `db.query`.
7. Show the required `tsconfig.json` changes for path aliases.
8. Do not invent any API; use only symbols visible in `source/index.ts` and the driver subdirectories shown in `USAGE.md`.

License and credit

Drizzle ORM is released under the Apache 2.0 License (see source/LICENSE if present, or the repository at https://github.com/drizzle-team/drizzle-orm). Upstream npm package: drizzle-orm. Maintained by the Drizzle Team.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.

Bookshelf.js Node.js ORM for SQL Databases

Automation, Utilities & Developer Tools

Free