or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

cli-commands.mdconfiguration.mdindex.mdmysql-api.mdpostgresql-api.mdsinglestore-api.mdsqlite-api.md
tile.json

tessl/npm-drizzle-kit

CLI migration tool for Drizzle ORM that automatically generates SQL migrations, pushes schema changes, introspects databases, and provides visual database management through Drizzle Studio.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/drizzle-kit@0.31.x

To install, run

npx @tessl/cli install tessl/npm-drizzle-kit@0.31.0

index.mddocs/

Drizzle Kit

Drizzle Kit is a comprehensive CLI migration tool and schema management utility for Drizzle ORM. It automatically generates SQL migrations from TypeScript schema changes, supports direct schema pushing, database introspection, and provides a visual database browser through Drizzle Studio.

Package Information

  • Package Name: drizzle-kit
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install -D drizzle-kit

Core Imports

Configuration Import

import { defineConfig } from 'drizzle-kit';

For CommonJS:

const { defineConfig } = require('drizzle-kit');

Programmatic API Import

import {
  generateDrizzleJson,
  generateMigration,
  pushSchema,
  startStudioPostgresServer,
} from 'drizzle-kit/api';

For CommonJS:

const {
  generateDrizzleJson,
  generateMigration,
  pushSchema,
} = require('drizzle-kit/api');

Basic Usage

Configuration File

Create a drizzle.config.ts file in your project root:

import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  dialect: 'postgresql',
  schema: './src/schema.ts',
  out: './drizzle',
  dbCredentials: {
    url: process.env.DATABASE_URL,
  },
});

Generate Migrations

drizzle-kit generate

Apply Migrations

drizzle-kit migrate

Push Schema Changes

drizzle-kit push

Introspect Database

drizzle-kit introspect

Start Drizzle Studio

drizzle-kit studio

Architecture

Drizzle Kit is organized around several key components:

  • CLI Interface: Command-line tool for all database operations
  • Programmatic API: Node.js API for custom tooling and integrations
  • Configuration System: Type-safe configuration with defineConfig()
  • Snapshot System: JSON-based schema state tracking for migration generation
  • Differ Engine: Intelligent comparison of schema snapshots to detect changes
  • SQL Generator: Database-specific SQL statement generation
  • Interactive Prompts: User input for ambiguous cases (renames, data loss)
  • Studio Server: Visual database browser with HTTPS support

Capabilities

Configuration

Define and validate Drizzle Kit configuration with full TypeScript type safety. Supports all database dialects, connection credentials, migration options, and filters.

function defineConfig(config: Config): Config;

type Config = {
  dialect: 'postgresql' | 'mysql' | 'sqlite' | 'turso' | 'singlestore' | 'gel';
  schema?: string | string[];
  out?: string;
  breakpoints?: boolean;
  tablesFilter?: string | string[];
  schemaFilter?: string | string[];
  extensionsFilters?: 'postgis'[];
  verbose?: boolean;
  strict?: boolean;
  casing?: 'camelCase' | 'snake_case';
  migrations?: {
    table?: string;
    schema?: string;
    prefix?: 'index' | 'timestamp' | 'supabase' | 'unix' | 'none';
  };
  introspect?: {
    casing: 'camel' | 'preserve';
  };
  entities?: {
    roles?: boolean | {
      provider?: 'supabase' | 'neon' | string;
      exclude?: string[];
      include?: string[];
    };
  };
  dbCredentials?: DatabaseCredentials;
  driver?: 'aws-data-api' | 'd1-http' | 'expo' | 'turso' | 'pglite' | 'durable-sqlite';
};

Configuration

CLI Commands

Command-line interface providing migration generation, schema pushing, database introspection, migration management, and Drizzle Studio. Supports PostgreSQL, MySQL, SQLite, Turso, SingleStore, and Gel databases.

// Command: drizzle-kit generate
// Options: --config, --dialect, --schema, --out, --name, --breakpoints, --custom, --prefix, --casing

// Command: drizzle-kit migrate
// Options: --config

// Command: drizzle-kit push
// Options: --config, --dialect, --schema, --casing, --tablesFilter, --schemaFilters, --extensionsFilters,
//          --url, --host, --port, --user, --password, --database, --ssl, --authToken, --tlsSecurity,
//          --verbose, --strict, --force

// Command: drizzle-kit introspect (alias: pull)
// Options: --config, --dialect, --out, --breakpoints, --introspect-casing, --tablesFilter,
//          --schemaFilters, --extensionsFilters, [database credentials]

// Command: drizzle-kit studio
// Options: --config, --port, --host, --verbose

// Command: drizzle-kit check
// Options: --config, --dialect, --out

// Command: drizzle-kit up
// Options: --config, --dialect, --out

// Command: drizzle-kit drop
// Options: --config, --out, --driver

// Command: drizzle-kit export
// Options: --config, --dialect, --schema, --sql

CLI Commands

PostgreSQL Programmatic API

Generate snapshots, create migrations, push schema changes, and start Drizzle Studio for PostgreSQL databases programmatically. Supports standard PostgreSQL, AWS RDS Data API, and PGlite.

function generateDrizzleJson(
  imports: Record<string, unknown>,
  prevId?: string,
  schemaFilters?: string[],
  casing?: 'camelCase' | 'snake_case'
): PgSchemaKit;

function generateMigration(
  prev: DrizzleSnapshotJSON,
  cur: DrizzleSnapshotJSON
): Promise<string[]>;

function pushSchema(
  imports: Record<string, unknown>,
  drizzleInstance: PgDatabase<any>,
  schemaFilters?: string[],
  tablesFilter?: string[],
  extensionsFilters?: 'postgis'[]
): Promise<PushResult>;

function startStudioPostgresServer(
  imports: Record<string, unknown>,
  credentials: PostgresCredentials | { driver: 'pglite'; client: PGlite },
  options?: { host?: string; port?: number; casing?: 'camelCase' | 'snake_case' }
): Promise<void>;

function upPgSnapshot(snapshot: any): PgSchemaKit;

type DrizzleSnapshotJSON = PgSchemaKit;

PostgreSQL API

MySQL Programmatic API

Generate snapshots, create migrations, push schema changes, and start Drizzle Studio for MySQL databases programmatically.

async function generateMySQLDrizzleJson(
  imports: Record<string, unknown>,
  prevId?: string,
  casing?: 'camelCase' | 'snake_case'
): Promise<MySQLSchemaKit>;

function generateMySQLMigration(
  prev: DrizzleMySQLSnapshotJSON,
  cur: DrizzleMySQLSnapshotJSON
): Promise<string[]>;

function pushMySQLSchema(
  imports: Record<string, unknown>,
  drizzleInstance: MySql2Database<any>,
  databaseName: string
): Promise<PushResult>;

function startStudioMySQLServer(
  imports: Record<string, unknown>,
  credentials: MysqlCredentials,
  options?: { host?: string; port?: number; casing?: 'camelCase' | 'snake_case' }
): Promise<void>;

type DrizzleMySQLSnapshotJSON = MySQLSchemaKit;

MySQL API

SQLite Programmatic API

Generate snapshots, create migrations, push schema changes, and start Drizzle Studio for SQLite databases programmatically. Supports standard SQLite, Turso (LibSQL), Cloudflare D1, Expo SQLite, and Durable Objects.

async function generateSQLiteDrizzleJson(
  imports: Record<string, unknown>,
  prevId?: string,
  casing?: 'camelCase' | 'snake_case'
): Promise<SQLiteSchemaKit>;

function generateSQLiteMigration(
  prev: DrizzleSQLiteSnapshotJSON,
  cur: DrizzleSQLiteSnapshotJSON
): Promise<string[]>;

function pushSQLiteSchema(
  imports: Record<string, unknown>,
  drizzleInstance: LibSQLDatabase<any>
): Promise<PushResult>;

function startStudioSQLiteServer(
  imports: Record<string, unknown>,
  credentials: SqliteCredentials,
  options?: { host?: string; port?: number; casing?: 'camelCase' | 'snake_case' }
): Promise<void>;

type DrizzleSQLiteSnapshotJSON = SQLiteSchemaKit;

SQLite API

SingleStore Programmatic API

Generate snapshots, create migrations, push schema changes, and start Drizzle Studio for SingleStore databases programmatically.

async function generateSingleStoreDrizzleJson(
  imports: Record<string, unknown>,
  prevId?: string,
  casing?: 'camelCase' | 'snake_case'
): Promise<SingleStoreSchemaKit>;

function generateSingleStoreMigration(
  prev: DrizzleSingleStoreSnapshotJSON,
  cur: DrizzleSingleStoreSnapshotJSON
): Promise<string[]>;

function pushSingleStoreSchema(
  imports: Record<string, unknown>,
  drizzleInstance: SingleStoreDriverDatabase<any>,
  databaseName: string
): Promise<PushResult>;

function startStudioSingleStoreServer(
  imports: Record<string, unknown>,
  credentials: SingleStoreCredentials,
  options?: { host?: string; port?: number; casing?: 'camelCase' | 'snake_case' }
): Promise<void>;

type DrizzleSingleStoreSnapshotJSON = SingleStoreSchemaKit;

SingleStore API

Common Types

PushResult

Result object returned by push operations containing warnings, SQL statements, and an apply function.

interface PushResult {
  hasDataLoss: boolean;
  warnings: string[];
  statementsToExecute: string[];
  apply: () => Promise<void>;
}

Database Credentials

See individual database API documentation for specific credential types:

Supported Databases

  • PostgreSQL: Full support including enums, schemas, sequences, views, materialized views, policies, roles, and PostGIS
  • MySQL: Tables, views, indexes, and constraints
  • SQLite: Tables, views, indexes, and constraints (including Turso, D1, Expo)
  • Turso (LibSQL): SQLite-compatible with remote sync support
  • SingleStore: Tables, indexes, and constraints
  • Gel: PostgreSQL-like with enums, sequences, policies, and roles