drizzle-team/drizzle-orm

This system is a TypeScript ORM and database toolkit that provides type-safe query building and schema definitions for a wide variety of database engines, including PostgreSQL, MySQL, SQLite, and specialized platforms like Neon, PlanetScale, and Cloudflare D1. It includes a CLI tool for managing SQL migrations and schema introspection, alongside plugins that generate validation schemas for libraries like Zod, Valibot, and TypeBox. The system also offers utilities for deterministic database seeding and ESLint rules to enforce safe database operations.

65 changes.

The project significantly expanded its database support by adding drivers for Gel, LibSQL, Netlify DB, Vercel Postgres, and various proxy implementations, while restructuring internal query builders and column definitions for better type safety. Concurrently, it introduced a suite of validation schema plugins for Zod, Valibot, ArkType, and TypeBox, alongside an ESLint plugin to enforce safer database operations.

49 changes.

This period focused on significantly expanding Drizzle ORM's database support by adding native drivers for Xata, PGlite, TiDB Serverless, SingleStore, and Cloudflare Durable Objects, alongside Prisma client integration. The drizzle-kit CLI underwent major refactoring to support new dialects like Gel and SingleStore, while a new drizzle-seed package was introduced for deterministic database seeding. Comprehensive integration and type tests were added across all new features to ensure stability and correctness.

6 changes.

This period focused on introducing initial support for the Gel database dialect, including core driver implementations, query builders, and transaction handling. Comprehensive type and integration tests were added to validate query execution, caching, and type inference across various SQL operations and module resolution strategies.

Users can now connect Drizzle ORM to PostgreSQL databases using the AWS RDS Data API. This change introduces a new driver, session, and migrator in the \drizzle-orm/src/aws-data-api/pg\ directory, enabling full database operations including transactions, prepared statements, and schema migrations via the AWS Data API protocol.

drizzle-orm/src/aws-data-api/pg · high confidence

Introduces new helper functions in the AWS Data API common module to handle data conversion between Drizzle ORM types and the AWS RDS Data API format. The \getValueFromDataApi\ function now correctly parses various field types, including support for nested array values (strings, longs, doubles, booleans, and nested arrays). The \toValueParam\ function ensures proper serialization of input values, specifically handling date and timestamp strings by formatting them for the API, and mapping JavaScript numbers to the appropriate \longValue\ or \doubleValue\ fields. Additionally, \typingsToAwsTypeHint\ provides the necessary type hints for dates, decimals, JSON, times, timestamps, and UUIDs.

drizzle-orm/src/aws-data-api/common · high confidence

Users can now connect Drizzle ORM to Cloudflare Durable Objects using the new \drizzle-orm/src/durable-sqlite\ module. This change introduces a dedicated driver, session, and migrator that wrap the Durable Object's \DurableObjectStorage\ to provide standard ORM capabilities, including transaction support via \client.transactionSync\ and schema migration utilities for SQLite-backed durable objects.

drizzle-orm/src/durable-sqlite · high confidence

Introduces a new \expo-sqlite\ driver for Drizzle ORM, enabling usage with the Expo SQLite API. This includes a synchronous database client (\ExpoSQLiteDatabase\), session handling, and a React hook \useLiveQuery\ that automatically re-renders components when the underlying database tables change. Additionally, a \useMigrations\ hook is provided to handle database schema migrations within React components.

drizzle-orm/src/expo-sqlite · high confidence

Introduces a new \Gel\ dialect to the ORM, providing full schema definition and query-building capabilities for Gel databases. This includes the \GelDialect\ for SQL generation, \GelDatabase\ and \GelSession\ for execution, and comprehensive schema builders for tables, views, sequences, roles, policies, and constraints. Users can now define Gel-specific schemas and run queries against Gel instances using the standard Drizzle API.

drizzle-orm/src/pg-core · high confidence

This change introduces a new integration module for Knex.js, allowing users to define their database schema using Drizzle ORM while leveraging Knex as the query builder. The update adds a \Knexify\ type helper and augments the Knex types to provide automatic TypeScript inference for Drizzle tables within Knex queries, enabling seamless interoperability between the two libraries.

drizzle-orm/src/knex · high confidence

Introduces a new integration layer allowing users to define their database schema using Drizzle ORM while using Kysely as the query builder. This includes a \Kyselify\ type utility that maps Drizzle table definitions to Kysely-compatible database interfaces, enabling schema management via Drizzle migrations while leveraging Kysely for query construction.

drizzle-orm/src/kysely · high confidence

Drizzle ORM now supports LibSQL as a first-class database driver. This change introduces a new \drizzle-orm/src/libsql\ module containing the core \LibSQLDatabase\ and \LibSQLSession\ implementations, along with environment-specific entry points for Node.js, Web, WebSocket, HTTP, SQLite3, and WebAssembly runtimes. Users can now connect to LibSQL databases using the standard \drizzle()\ factory function, utilize batch operations, and run migrations via the provided migrator.

drizzle-orm/src/libsql · high confidence

Users can now connect Drizzle ORM to a MySQL database via a proxy layer by using the new \drizzle\ function in \drizzle-orm/src/mysql-proxy\. This driver accepts a custom callback to execute SQL queries, enabling integration with remote database services or custom network layers. The implementation includes a dedicated session and prepared query handler that supports query logging and caching, while explicitly noting that transactions and streaming are not supported by this proxy driver.

drizzle-orm/src/mysql-proxy · high confidence

Users can now define PostGIS geometry columns in their PostgreSQL schemas using the new \geometry()\ builder. This change introduces \PgGeometry\ (returning coordinate tuples) and \PgGeometryObject\ (returning x/y objects) column types, along with the necessary EWKB parsing utilities to handle data serialization and deserialization.

_drizzle-orm/src/pg-core/columns/postgis\extension · high confidence

Users can now use Drizzle ORM with Prisma's SQLite client by importing the new \drizzle\ function from \drizzle-orm/src/prisma/sqlite\. This adds a Prisma extension that exposes a \$drizzle\ property on the Prisma client, providing a \BaseSQLiteDatabase\ instance for executing queries. The implementation includes a custom session and prepared query classes that map Drizzle's SQLite dialect to Prisma's \$queryRawUnsafe\ method, supporting \all\, \get\, and \run\ operations, while \values\ and \transaction\ methods are currently unimplemented.

drizzle-orm/src/prisma/sqlite · high confidence

Users can now use Drizzle ORM with Prisma clients for MySQL and PostgreSQL databases. This change introduces new driver implementations (\PrismaMySqlDatabase\, \PrismaPgDatabase\) and session classes that wrap Prisma clients, allowing Drizzle queries to be executed via Prisma's \$queryRawUnsafe\. The drivers are exposed as Prisma extensions, enabling seamless integration where Drizzle's query builder can operate on top of an existing Prisma client instance.

drizzle-orm/src/prisma/mysql, drizzle-orm/src/prisma/pg · high confidence

Added a new SingleStore connector to drizzle-orm, providing two distinct integration paths: a native driver (singlestore) that connects directly via mysql2 pools/connections with support for caching and streaming, and a proxy driver (singlestore-proxy) that operates via a remote callback interface. Both implementations include database initialization, session handling, prepared query execution, and migration utilities, enabling users to interact with SingleStore databases using standard Drizzle ORM patterns.

drizzle-orm/src/singlestore · high confidence

The SingleStore connector now includes full query-building capabilities, adding builders for SELECT, INSERT, UPDATE, DELETE, and COUNT operations, along with support for relational queries and CTEs via the QueryBuilder.

drizzle-orm/src/singlestore-core/query-builders · high confidence

Users can now connect Drizzle ORM to TiDB Cloud Serverless. This change introduces a new driver package (\drizzle-orm/src/tidb-serverless\) that extends the existing MySQL dialect to support the \@tidbcloud/serverless\ client. It includes the database constructor, session handling, prepared queries, and migration utilities, enabling standard Drizzle operations like transactions and caching on TiDB Serverless instances.

drizzle-orm/src/tidb-serverless · high confidence

The D1 driver now supports executing multiple queries in a single batch via the new \db.batch()\ method, which improves performance for bulk operations. Additionally, the driver implements full transaction support, allowing users to wrap multiple statements in \BEGIN\/\COMMIT\ blocks with savepoint support for nested transactions. The migrator has also been updated to utilize the batch API for applying migration files more efficiently.

drizzle-orm/src/d1 · high confidence

The drizzle-seed package now includes a collection of static datasets in the \src/datasets\ directory to support realistic data generation. New files provide lists of adjectives, city names, company name suffixes, countries, email domains, first and last names, job titles, lorem ipsum sentences, phone number formats, US states, and street suffixes. These datasets are sourced from public repositories such as Kaggle and the copycat library, enabling the seed tool to generate more varied and authentic test data.

drizzle-seed/src/datasets · high confidence

Drizzle ORM now supports the PGlite database engine (from Electric SQL). This change introduces a new driver, session, and migrator implementation in the \drizzle-orm/src/pglite\ directory, allowing users to initialize a PGlite-backed database instance via the \drizzle()\ function. The implementation includes a \drizzle.mock()\ helper for testing, supports schema extraction for relational queries, and integrates with the existing caching and logging systems.

drizzle-orm/src/pglite · high confidence

Users can now connect Drizzle ORM to PlanetScale's serverless database using the official \@planetscale/database\ client. This change introduces a new driver module (\drizzle-orm/src/planetscale-serverless\) that provides a \drizzle()\ factory function, a dedicated \PlanetScaleDatabase\ class, and a \migrate()\ utility for schema migrations. The implementation leverages the MySQL dialect under the hood but includes specific handling for PlanetScale's execution model, such as disabling streaming iterators and supporting the PlanetScale-specific \Client\ instance. It also allows configuration of logging and caching via the standard Drizzle config options.

(repo-wide) · high confidence

Users can now connect Drizzle ORM to Vercel Postgres using the \@vercel/postgres\ driver. This change introduces a new \drizzle()\ function and associated driver, session, and migrator implementations in the \drizzle-orm/src/vercel-postgres\ module, enabling standard query execution, schema migrations, and relational schema support for Vercel Postgres databases.

drizzle-orm/src/vercel-postgres · high confidence

Users can now define PostgreSQL vector columns using the pgvector extension. This change introduces four new column types—\vector\, \halfvec\, \sparsevec\, and \bit\—each with a dedicated builder and configuration interface. These columns support dimension constraints, handle serialization/deserialization for array and string data types, and generate the appropriate SQL types (e.g., \vector(n)\, \halfvec(n)\, \sparsevec(n)\, \bit(n)\).

_drizzle-orm/src/pg-core/columns/vector\extension · high confidence

This change introduces a new driver implementation for the sql.js library, allowing users to connect Drizzle ORM to SQLite running in JavaScript environments (such as browsers or Node.js without native bindings). The diff adds the core driver entry point (\driver.ts\), a session layer (\session.ts\) that handles synchronous query execution and transaction management (including savepoints), a migrator (\migrator.ts\), and re-exports from \index.ts\. This enables the existing Drizzle ORM API to work with the in-memory or file-based SQLite provided by sql.js.

drizzle-orm/src/sql-js · high confidence

Introduced a new set of query builders for the Gel database dialect, including implementations for select, insert, update, delete, count, raw queries, and materialized view refresh operations, along with the necessary type definitions and a relational query builder to support Gel-specific SQL generation and execution.

drizzle-orm/src/gel-core/query-builders · high confidence

The Neon integration now includes a pre-defined schema for the \neon\_auth.users\_sync\ table, which automatically synchronizes user data from external authentication providers, and a \crudPolicy\ function that generates PostgreSQL Row-Level Security (RLS) policies for CRUD operations. This allows users to easily apply read and modify permissions to specific roles (including Neon's built-in \authenticated\ and \anonymous\ roles) with support for skipping policy generation by passing \null\.

drizzle-orm/src/neon · high confidence

Users can now connect Drizzle ORM to Netlify's managed database service. This change introduces a new driver implementation in the \drizzle-orm/src/netlify-db\ directory, providing a \drizzle()\ factory function that accepts Netlify-specific client configurations (including both serverless HTTP and server-side pool connections). The new module includes a custom session layer (\NetlifyDbSession\) that leverages the Neon serverless driver for queries and transactions, along with a migrator (\migrate\) compatible with both the new Netlify driver and existing Node PostgreSQL setups.

drizzle-orm/src/neon-serverless, drizzle-orm/src/netlify-db · high confidence

Introduced new utility functions in the PostgreSQL core module to handle array data types. The \parsePgArray\ and \parsePgNestedArray\ functions now correctly parse PostgreSQL array string representations, including proper handling of nested arrays, quoted strings, and escape characters. Additionally, the \makePgArray\ function provides a robust way to serialize JavaScript arrays back into PostgreSQL-compatible string formats, ensuring correct escaping of backslashes and quotes for string elements.

drizzle-orm/src/pg-core/utils · high confidence

Introduced a new Postgres Proxy driver (\pg-proxy\) that enables connecting to PostgreSQL databases via a remote callback interface rather than a direct connection. This change adds the \PgRemoteDatabase\, \PgRemoteSession\, and \PreparedQuery\ classes, allowing users to execute queries and migrations through a custom \RemoteCallback\ function. The implementation supports query caching, logging, and schema-based migrations, while explicitly noting that transactions are not supported by this proxy driver.

drizzle-orm/src/pg-proxy · high confidence

A new Prisma schema file (schema.prisma) has been added to the drizzle-orm/src/prisma directory. This file defines a PostgreSQL datasource and a basic User model with id, email, and name fields, providing the foundational schema definition for Prisma client generation within this module.

drizzle-orm/src/prisma · high confidence

The library now includes pre-defined schema definitions for Supabase's internal \auth\ and \realtime\ schemas, along with exports for common database roles (such as \anon\, \authenticated\, and \service\_role\). This allows users to easily reference Supabase's built-in tables (like \auth.users\) and roles in their own schema definitions without manually recreating them, facilitating the implementation of Row Level Security policies.

drizzle-orm/src/supabase · high confidence

The drizzle-kit codebase now includes a new utility module that extends the native String and Array prototypes with helper methods. Users interacting with the kit's internal logic will benefit from added string manipulation capabilities, including trimming specific characters, squashing multiple spaces, converting to camelCase or snake\_case, capitalizing the first letter, and conditionally concatenating strings. Additionally, an Array prototype method has been added to retrieve a random element from an array.

drizzle-kit/src/@types · high confidence

Drizzle Kit is now available as a standalone, open-source CLI tool for generating SQL migrations. This release includes the core kit codebase, build configurations (esbuild/tsup), and a test suite (Vitest). The kit automatically generates SQL migrations by comparing schema snapshots and prompts for user input in ambiguous cases like renames. It supports multiple database drivers including PostgreSQL (pg, postgres, @vercel/postgres, @neondatabase/serverless, @electric-sql/pglite), MySQL (mysql2, @planetscale/database), and SQLite (@libsql/client, better-sqlite3, bun:sqlite). The package is structured with separate TypeScript configs for CLI types and building, and includes patches for dependencies like difflib.

drizzle-kit · high confidence

Drizzle Kit introduces support for the Gel database dialect, a new SingleStore connector, and native PGlite support for PostgreSQL. The release also adds the ability to filter tables by extensions (such as PostGIS) and allows users to specify casing for introspected schema names. Additionally, the snapshot version has been bumped to 7, and the kit now includes a loader for handling TypeScript modules in Node.js environments.

drizzle-kit/src · high confidence

This change introduces the foundational column type definitions for the SingleStore database connector within Drizzle ORM. The \drizzle-orm/src/singlestore-core/columns\ directory now contains implementations for standard SQL types including integers (bigint, int, smallint, mediumint, tinyint), floating-point numbers (float, double, real), decimals, dates, datetimes, timestamps, times, years, booleans, and strings (char, varchar, text, binary, varbinary). It also adds support for JSON, custom user-defined types, SingleStore-specific enums, and vector columns. These files provide the necessary builders and column classes to map TypeScript types to SingleStore SQL types, enabling schema definition and data mapping for this new dialect.

drizzle-orm/src/singlestore-core/columns · high confidence

This change introduces the core SingleStore dialect and connector for Drizzle ORM, enabling users to define SingleStore-specific tables, schemas, views, and constraints. It provides the foundational query builders for SELECT, INSERT, UPDATE, and DELETE operations, along with support for Common Table Expressions (CTEs) via the \$with\ API, vector similarity search operators (dot product and Euclidean distance), and schema management through \singlestoreDatabase\.

drizzle-orm/src/singlestore-core · high confidence

This change introduces the \drizzle-valibot\ package, providing a new way to generate Valibot validation schemas directly from Drizzle ORM tables and views. It exports \createSelectSchema\, \createInsertSchema\, and \createUpdateSchema\ functions that automatically map database column types (including PostgreSQL vectors, geometry, enums, and JSON) to corresponding Valibot schemas, while respecting nullability and default value constraints for each operation type.

drizzle-valibot/src · high confidence

This change introduces the \drizzle-seed\ service, enabling programmatic database seeding with support for PostgreSQL, MySQL, and SQLite. The service provides a \refine\ API to customize data generation, including support for array columns, UUIDs, and weighted random counts. It introduces generator versioning (v1 and v2) to manage changes in string and interval generation logic, and implements logic to handle cyclic and soft table relations via a \with\ option, ensuring correct insertion order and referential integrity during seeding.

drizzle-seed/src/services · high confidence

Introduces the drizzle-seed library, providing a new capability to generate mock data for database schemas. The package exports a SeedService and generator functions that support PostgreSQL, MySQL, and SQLite databases, allowing users to seed tables with configurable counts and handle relational data.

drizzle-seed/src · high confidence

This change introduces the \drizzle-typebox\ package, enabling users to generate TypeBox validation schemas directly from Drizzle ORM tables and views. The implementation provides \createSelectSchema\, \createInsertSchema\, and \createUpdateSchema\ functions that map Drizzle column definitions (including PostgreSQL geometry, vector, and array types, as well as MySQL and SQLite specific types) to corresponding TypeBox types. It also supports schema refinements and allows for custom TypeBox instances via a factory pattern.

drizzle-typebox/src · high confidence

The drizzle-zod package is introduced as a new plugin for Drizzle ORM that generates Zod validation schemas from Drizzle table, view, and enum definitions. It provides functions to create insert, update, and select schemas, supporting PostgreSQL, MySQL, and SQLite dialects, and allows for field overriding and refinement to ensure type-safe validation for API requests and responses.

drizzle-valibot, drizzle-zod · high confidence

Drizzle ORM now supports the Gel database. This change introduces the core driver, session, and transaction implementations for Gel, allowing users to connect to Gel databases using the \drizzle()\ function with Gel-specific clients. The implementation includes query execution with caching and logging support, as well as transaction handling. Note that database migrations are currently not supported for this dialect.

drizzle-orm/src/gel · high confidence

The \eslint-plugin-drizzle\ package is introduced with two new linting rules: \enforce-delete-with-where\ and \enforce-update-with-where\. These rules flag Drizzle ORM \delete\ and \update\ calls that lack a \.where()\ clause, helping prevent accidental mass deletion or modification of all rows in a table. The rules are available in both \recommended\ and \all\ configurations and support a \drizzleObjectName\ option to specify which database object names should be checked.

eslint-plugin-drizzle/src · high confidence

This change adds initial support for the Gel database dialect, introducing a new \gel-core\ module with column builders (e.g., \bigint\, \boolean\, \bytes\) and table definitions, alongside a new \cache\ module that provides an abstract caching interface and a concrete \UpstashCache\ implementation for query result caching with automatic invalidation.

drizzle-orm/src · high confidence

Adds a new \sqlite-proxy\ driver that enables Drizzle ORM to connect to SQLite databases via a remote callback interface rather than a local file or WASM instance. This location provides the core driver implementation (\SqliteRemoteDatabase\), the session layer (\SQLiteRemoteSession\) handling query execution and caching, a migrator for applying schema changes through the proxy, and the public exports. Users can now use Drizzle with SQLite backends that are accessed remotely, supporting standard operations, transactions, and batch queries through the provided callback functions.

drizzle-orm/src/sqlite-proxy · high confidence

The new \drizzle-arktype\ package allows you to generate ArkType validation schemas directly from your Drizzle ORM tables, views, and enums. It provides \createSelectSchema\, \createInsertSchema\, and \createUpdateSchema\ functions that automatically map Drizzle column types to ArkType types while respecting nullability and optionality rules for each operation. The plugin supports PostgreSQL, MySQL, SQLite, and SingleStore, and allows you to refine or override specific fields during schema generation.

drizzle-arktype, drizzle-typebox · high confidence

A new \drizzle-seed\ package is added to the monorepo, providing a TypeScript library to generate deterministic, realistic fake data for database tables. It leverages a seedable pseudorandom number generator to ensure reproducible data sets across runs, which is useful for testing and debugging. The package requires \drizzle-orm@0.36.4\ or higher and includes build configurations for ESM and CJS outputs, along with test infrastructure for PostgreSQL, MySQL, and SQLite.

drizzle-seed · high confidence

The MySQL dialect is now fully implemented within the \drizzle-orm/src/mysql-core\ directory, providing the core infrastructure for MySQL database interactions. This includes the \MySqlDialect\ class for query generation and migration handling, the \MySqlDatabase\ class for executing relational queries and managing CTEs via \$with\, and comprehensive schema definition tools such as \mysqlTable\, \mysqlView\, and \mysqlDatabase\ for defining tables, views, and schemas. The update also introduces builders for MySQL-specific constraints and indexes, including \foreignKey\, \index\, \uniqueIndex\, \primaryKey\, and \check\, allowing users to define complex database structures with support for features like index algorithms, locking, and foreign key actions.

drizzle-orm/src/mysql-core · high confidence

The MySQL query builders for \update\ and \delete\ operations now accept \limit\ and \orderBy\ configurations, allowing users to restrict the number of affected rows and specify the order in which rows are processed. This change introduces new \MySqlUpdateConfig\ and \MySqlDeleteConfig\ interfaces that include these optional fields, enabling more precise control over write operations in MySQL.

drizzle-orm/src/mysql-core/query-builders · high confidence

The drizzle-kit utility layer now includes native support for managing local SSL certificates and generating migration file names. The new certs utility replaces external shell dependencies with Node's native child\_process to automatically generate and store localhost keys and certificates using mkcert, ensuring secure local connections without manual setup. Additionally, the words utility provides logic for preparing migration metadata, allowing users to generate migration tags with configurable prefixes (index, timestamp, unix) and randomized suffixes, improving the organization and readability of database migration files.

drizzle-kit/src/utils · high confidence

An internal ESLint plugin now includes a 'require-entity-kind' rule that ensures all Drizzle-related classes define a static readonly \[entityKind\] property with a string value. This rule is set to error by default and provides an automatic fix to insert the missing property, helping maintain consistency in class definitions within the codebase.

eslint · high confidence

This change introduces a dedicated driver for the \postgres.js\ library, allowing users to connect Drizzle ORM to databases using this specific client. The implementation includes support for query result caching via the \cache\ configuration option, a \drizzle.mock()\ function for testing without a real database, and explicit handling of date/time serialization to prevent automatic parsing by the underlying driver. It also provides a migrator module for running schema migrations.

drizzle-orm/src/postgres-js · high confidence

The library introduces new modules for building SQL queries, specifically adding condition operators (eq, ne, and, or, not) and sorting functions (asc, desc) to the expressions layer. These utilities allow users to construct WHERE clauses and ORDER BY statements with improved type safety and automatic parameter binding, simplifying the creation of complex filter and sort logic in select queries.

drizzle-orm/src/sql/expressions · high confidence

The SQLite dialect now uses a new query builder implementation in \drizzle-orm/src/sqlite-core/query-builders\. This introduces a \QueryBuilder\ class for constructing standalone queries (including \WITH\ clauses and \SELECT DISTINCT\), a \RelationalQueryBuilder\ for fetching data with relations (\findMany\, \findFirst\), and a \SQLiteCountBuilder\ for counting rows. The existing \select\, \insert\, \update\, and \delete\ builders have been rewritten to support advanced features such as \LIMIT\ and \ORDER BY\ on \UPDATE\ and \DELETE\ statements, \INSERT ... SELECT\ syntax, and \ON CONFLICT\ handling.

drizzle-orm/src/sqlite-core/query-builders · high confidence

Drizzle ORM now supports Xata as a database target via a new HTTP-based driver. This addition introduces \XataHttpDriver\, \XataHttpSession\, and a \migrate\ utility, allowing users to connect to Xata using the \@xata.io/client\ HTTP interface. The driver leverages the PostgreSQL dialect for query generation but explicitly does not support transactions, throwing an error if transactional operations are attempted. It also includes support for query logging and caching through standard Drizzle configuration options.

drizzle-orm/src/xata-http · high confidence

This change introduces new SQL function helpers in the \drizzle-orm\ library. It adds standard aggregate functions (\count\, \countDistinct\, \avg\, \avgDistinct\, \sum\, \sumDistinct\, \max\, \min\) to \aggregate.ts\, allowing users to perform common database aggregations with proper type mapping. Additionally, it adds vector distance calculation functions (\l2Distance\, \l1Distance\, \innerProduct\, \cosineDistance\, \hammingDistance\, \jaccardDistance\) in \vector.ts\, enabling similarity-based sorting and querying for vector columns. These functions are exported via the new \functions/index.ts\ barrel file.

drizzle-orm/src/sql/functions · high confidence

The drizzle-kit/imports-checker module has been added to provide static analysis of import dependencies. It uses an OHM grammar to parse JavaScript/TypeScript files, distinguishing between data and type imports, and tracks access chains to identify issues. The checker supports whitelist/blacklist modes, handles local and external imports, and can ignore type-only imports, helping to detect unused or problematic dependencies within the kit's source tree.

drizzle-kit/imports-checker · high confidence

The \drizzle-orm\ package now includes a dedicated driver for the \mysql2\ library, located in \drizzle-orm/src/mysql2\. This addition introduces native support for iterating over query results via the \iterator\ method, allowing users to process large result sets row-by-row without loading everything into memory. The driver also exposes a \drizzle.mock()\ function for testing purposes, which returns a database instance where the \$client\ property is explicitly unavailable. Additionally, the implementation ensures that the \$client\ property on the returned database object correctly reflects the type of the underlying connection (e.g., \Pool\ vs \Connection\) based on how the client was instantiated.

drizzle-orm/src/mysql2 · high confidence

The entire legacy source code base for the PostgreSQL ORM has been removed from the \src\ directory. This includes the core type definitions and session abstractions (\core.ts\), the SQL query builder and parameter handling (\sql.ts\), the PostgreSQL-specific dialect and session logic (\pg/core.ts\), and all column type definitions (\pg/columns/\). The public entry point (\index.ts\) and operator utilities (\operators.ts\) that exposed the previous table and query API are also deleted, effectively stripping the library of its previous data-access capabilities.

src, src/pg · high confidence

The PostgreSQL query builders (select, insert, update, delete, count, and relational queries) have been reorganized into individual, dedicated files within the \drizzle-orm/src/pg-core/query-builders\ directory. This change introduces new builder classes such as \PgSelectBuilder\, \PgInsertBuilder\, \PgUpdateBuilder\, and \PgDeleteBuilder\, along with supporting types and a \RelationalQueryBuilder\ for handling complex relational data fetching. The \index.ts\ file now explicitly re-exports these components, providing a clearer module structure for PostgreSQL-specific query construction while maintaining the existing API surface for users.

drizzle-orm/src/pg-core/query-builders · high confidence

The schema serialization logic in drizzle-kit has been restructured from a monolithic implementation into distinct, dialect-specific modules. New files have been added for PostgreSQL (pgSchema.ts, pgSerializer.ts, pgImports.ts), MySQL (mysqlSchema.ts, mysqlSerializer.ts, mysqlImports.ts), SQLite (sqliteSchema.ts, sqliteImports.ts), SingleStore (singlestoreSchema.ts, singlestoreSerializer.ts, singlestoreImports.ts), and Gel (gelSchema.ts, gelSerializer.ts). A central index.ts now routes serialization requests to the appropriate dialect handler, allowing each database engine to maintain its own schema definitions, import parsing, and snapshot generation logic.

drizzle-kit/src/serializer · high confidence

The build process for drizzle-typebox has been restructured to generate both CommonJS and ES Module variants. A new build script (scripts/build.ts) now handles the compilation and distribution steps, while a dedicated utility (scripts/fix-imports.ts) post-processes the generated files to correctly resolve path aliases and append the appropriate file extensions (.cjs, .js, .mjs) for both CommonJS and ESM contexts.

drizzle-typebox/scripts · high confidence

The build process for drizzle-orm has been replaced with a new script that uses tsup instead of Rollup to generate both ESM (.js) and CommonJS (.cjs) bundles. This change enables proper dual-package support by automatically populating the package.json exports field with the correct import, require, and types paths for every source entry. Additionally, a post-build step now fixes import paths in the generated files to ensure compatibility between the two module formats.

drizzle-orm/scripts · high confidence

The drizzle-orm package has replaced its previous bundling setup with tsup, enabling the generation of both CommonJS (.cjs) and ESM (.js) entry points without bundling the source code into a single file. This change, accompanied by new TypeScript configuration files (tsconfig.build.json, tsconfig.dts.json) and a madgerc configuration, ensures that consumers can import the library using standard ESM or CommonJS module resolution, while declaration files are emitted to a separate dist-dts directory to support accurate type checking for consumers.

drizzle-orm · high confidence

The Drizzle Kit CLI has been reorganized into a new modular structure (connections.ts, schema.ts, utils.ts, views.ts) that introduces support for the Gel and SingleStore database dialects, as well as the PGlite driver for PostgreSQL. The CLI now handles AWS Data API for PostgreSQL and normalizes SQLite/Turso connections to LibSQL. Additionally, legacy database-specific commands (such as generate:pg, push:mysql, introspect:sqlite) have been deprecated in favor of unified commands (generate, push, introspect) that accept a dialect option, simplifying the user interface while maintaining backward compatibility through hidden alias commands.

drizzle-kit/src/cli · high confidence

The TypeScript server's default maximum truncation length for internal declarations has been increased from 160 to 1,000,000 characters. This change, applied via a patch to the TypeScript 5.6.3 library, allows for more detailed symbol information to be displayed in the IDE without being cut off, improving the visibility of large declarations.

patches · high confidence

The integration test suite has been migrated from AVA to Vitest, introducing new configuration files (vitest.config.ts, vitest-ci.config.ts) and a .env.example template. This change expands test coverage to include new database dialects and drivers, specifically adding setup and test files for SingleStore, PlanetScale, TiDB Serverless, Neon (HTTP and Serverless), LibSQL, AWS Data API, and Xata. The migration also includes infrastructure updates such as a Docker Compose file for local Neon proxying and SST configuration for AWS Data API testing.

integration-tests · high confidence

The CLI command implementations in \drizzle-kit/src/cli/commands\ have been rewritten to support PostgreSQL schema versions 4 through 7, including migration logic in \pgUp.ts\ and \mysqlUp.ts\ for handling timestamp and date format changes. The \introspect.ts\ command now supports filtering by tables, schemas, and specific entities (like views and policies) for PostgreSQL, MySQL, SQLite, LibSQL, SingleStore, and Gel. New utility modules (\pgPushUtils.ts\, \mysqlPushUtils.ts\, \singlestorePushUtils.ts\, \libSqlPushUtils.ts\) provide dialect-specific logic for pushing schema changes, including data-loss warnings and statement filtering. A new \check.ts\ command validates migration journals for malformed data, collisions, and timestamp ordering issues, while \drop.ts\ allows removing specific migrations from the journal and file system.

drizzle-kit/src/cli/commands · high confidence

The MySQL column definitions in \drizzle-orm/src/mysql-core/columns\ have been reorganized into a modular structure where each data type (such as \bigint\, \datetime\, \decimal\, and \enum\) is now defined in its own file with dedicated builder classes and configuration interfaces. This change introduces explicit support for MySQL-specific features, including \unsigned\ modifiers for numeric types, fractional second precision (\fsp\) for \datetime\, and \onUpdateNow\ for timestamps. It also standardizes the API by replacing generic column creation with specific builder methods (e.g., \autoincrement()\, \generatedAlwaysAs\) and ensures consistent type mapping between driver values and TypeScript types.

drizzle-orm/src/mysql-core/columns · high confidence

The drizzle-kit CLI now uses a comprehensive set of Zod-based validation schemas to enforce configuration and command-line arguments. This change introduces strict validation for connection credentials across PostgreSQL, MySQL, SQLite (including D1, Expo, Durable Objects, and Turso), LibSQL, SingleStore, and Gel databases, ensuring required fields like URLs, hosts, and authentication tokens are present. It also defines validation rules for core CLI commands (generate, push, pull, introspect, check) and the Studio interface, while adding support for new features such as casing type enforcement (snake\_case/camelCase) and specific driver constraints like AWS Data API and pglite.

drizzle-kit/src/cli/validations · high confidence

The \drizzle-orm/src/node-postgres\ package now provides a complete, new implementation for the Node-Postgres driver, introducing \NodePgDriver\, \NodePgSession\, and \NodePgPreparedQuery\ classes. This change enables users to leverage prepared statements with custom type parsers for PostgreSQL-specific types (such as timestamps and intervals) and integrates OpenTelemetry tracing for query execution. The driver also supports query result caching via the \cache\ configuration option and exposes a \$client\ property on the database instance for direct access to the underlying \pg.Pool\ or \Client\. Additionally, a \drizzle.mock()\ function is available for testing purposes.

drizzle-orm/src/node-postgres · high confidence

The better-sqlite3 driver now provides a dedicated \drizzle()\ factory that accepts a \better-sqlite3\ Database instance or connection string, exposing a \$client\ property for direct access to the underlying driver. This update introduces \drizzle.mock()\ for testing without a real database, implements nested transactions using SQLite savepoints, and fixes the \.get()\ method to correctly return \undefined\ when a query yields no results.

drizzle-orm/src/better-sqlite3 · high confidence

The PostgreSQL column definitions in \drizzle-orm/src/pg-core/columns\ have been reorganized into individual module files (e.g., \bigint.ts\, \date.ts\, \integer.ts\) and re-exported via a central \index.ts\. This change introduces new builder classes (such as \PgBigInt53Builder\ and \PgBigInt64Builder\) that support distinct data modes (e.g., \number\ vs. \bigint\), allowing users to choose between 53-bit safe numbers and native 64-bit bigints. Additionally, columns like \date\ now support a \mode\ configuration to switch between \Date\ objects and string representations, and integer columns expose \generatedAlwaysAsIdentity\ and \generatedByDefaultAsIdentity\ methods for identity column support.

drizzle-orm/src/pg-core/columns · high confidence

The query builder module has been restructured to improve type safety and internal consistency. A new abstract \TypedQueryBuilder\ base class is introduced to standardize how query builders expose selected fields and SQL generation. The type definitions in \select.types.ts\ have been significantly updated to refine how subquery selections, join nullability, and result shapes are inferred, ensuring that column aliases and table associations are handled more accurately during type checking.

drizzle-orm/src/query-builders · medium confidence

The SQL query generation engine has been restructured to use a new chunk-based system (SQLChunk, StringChunk, Param, Placeholder) and a dedicated SQL class, replacing previous internal implementations. This change introduces OpenTelemetry integration for Postgres, adding tracing spans to the query building process to improve observability. The refactoring also resolves circular dependencies and improves type performance, while ensuring that placeholders are correctly mapped to their driver values and null values are handled properly for columns with mappers.

drizzle-orm/src/sql · medium confidence

The SQLite column definitions in \drizzle-orm/src/sqlite-core/columns\ have been reorganized into individual module files (blob, common, custom, integer, numeric, real, text) and re-exported via a new \all.ts\ entry point. This change introduces new column modes: \blob\ now supports \json\, \bigint\, and \buffer\ modes; \text\ supports a \json\ mode for automatic serialization; \numeric\ supports \string\, \number\, and \bigint\ modes; and \integer\ now includes \timestamp\ and \boolean\ modes. The \common.ts\ module centralizes base builders and adds support for \generatedAlwaysAs\ and unique constraint naming.

drizzle-orm/src/sqlite-core/columns · high confidence

The \drizzle-orm/src/sqlite-core\ module has been reorganized into a new file structure, introducing dedicated builders for schema elements (checks, foreign keys, indexes, primary keys, unique constraints) and query operations (count, raw, select, update, delete). This change adds support for \LIMIT\ and \ORDER BY\ in \UPDATE\ and \DELETE\ statements, enables the \WITH\ clause (CTEs) via \$with\, and introduces a \$count\ method for counting rows. The dialect now handles casing caching and supports both sync and async execution modes with integrated query caching. Additionally, the module now includes full support for SQLite views (\sqliteView\) and improved type safety for table aliases and subqueries.

drizzle-orm/src/sqlite-core · high confidence

The drizzle-zod package has been rewritten to support Zod v4, introducing a new \createSchemaFactory\ API that allows users to configure global type coercion for strings, numbers, booleans, dates, and bigints, as well as provide a custom Zod instance. The library now generates more precise TypeScript types for database columns across PostgreSQL, MySQL, SingleStore, and SQLite, including specific handling for geometry, vector, and array types, while correctly managing insert/update schema conditions for generated and identity columns.

drizzle-zod/src · high confidence

The integration test fixtures for the Drizzle v2 MySQL and PostgreSQL proxies have been updated to align with the latest migration snapshot format. For MySQL, the test suite now includes a second migration step that adds a \users12\ table with a unique index on the \name\ column, and the corresponding snapshot metadata has been refreshed. Similarly, the PostgreSQL proxy tests have been updated to include a second migration step adding a \users12\ table, ensuring the proxy's migration handling is correctly validated against these schema changes.

integration-tests/drizzle2/mysql-proxy · high confidence

The build process for the drizzle-valibot and drizzle-zod packages now includes a dedicated post-build step that automatically corrects import paths in the distributed files. This ensures that CommonJS (\.cjs\, \.d.cts\) and ES Module (\.js\, \.mjs\, \.d.mts\) outputs reference each other with the correct file extensions, resolving potential runtime errors when consumers import from these packages.

drizzle-valibot/scripts, drizzle-zod/scripts · high confidence

Add Knex integration type tests; Added Kysely integration type tests for Postgres and MySQL schemas; Added MySQL integration tests and benchmarking suite; Added MySQL integration tests for caching and custom types; Added Xata integration test setup and client; Added casing cache tests for MySQL, PostgreSQL, and SQLite; Added comprehensive TypeBox schema validation tests for MySQL, PostgreSQL, SQLite, and SingleStore; Added comprehensive integration tests for PostgreSQL drivers and Neon services; Added comprehensive test coverage for drizzle-kit CLI and schema diffing; Added comprehensive test coverage for drizzle-valibot schema generation; Added integration tests for Bun SQL and Bun SQLite drivers; Added integration tests for CommonJS and ESM driver initialization; Added integration tests for Drizzle ORM with SQLite Durable Objects; Added integration tests for MySQL returning IDs and version schema validation; Added integration tests for PostGIS and pgvector extensions; Added integration tests for Postgres relational schema mapping; Added integration tests for SQLite drivers; Added integration tests for database introspection across multiple dialects; Added integration tests for drizzle-kit push across all supported dialects; Added integration tests for duplicate relational schema handling in MySQL and PostgreSQL; Added integration tests for dynamic import resolution; Added integration tests for read replicas across MySQL, PostgreSQL, SQLite, and SingleStore; Added integration tests for the Gel database dialect; Added integration tests for the drizzle-seed library; Added test coverage for PostgreSQL array handling, relational schemas, and RDS Data API type hints; Added tests for Drizzle ORM ESLint rules; Added tests for PostgreSQL RLS policies and roles; Added tests for PostgreSQL index generation and diffing; Added tests for the isConfig utility function; Added type test for Neon HTTP auth token variants; Added type tests for MySQL, PostgreSQL, and SQLite seed/reset functions; Added type tests for dialect-specific aliased tables and views; Added type tests for joins under NodeNext module resolution; Added type tests for the Gel database dialect; Comprehensive type tests added for SQLite query builders; Initial type tests for SingleStore connector; Integration tests for SingleStore connector; MySQL type tests restructured for comprehensive coverage; PostgreSQL type tests restructured and expanded; Relational integration tests migrated to Vitest with multi-database coverage; Updated PostgreSQL integration test schema.

This release updates the Drizzle ORM monorepo to version 0.45.3 and introduces a new \drizzle-arktype\ package (v0.1.3) for generating ArkType schemas from Drizzle ORM schemas. The \drizzle-zod\ package has been upgraded to v0.8.3, now supporting both Zod v3 and v4 via peer dependency ranges. Additionally, \drizzle-seed\ is updated to v0.3.1, \drizzle-typebox\ to v0.3.3, and \drizzle-valibot\ to v0.4.2. The root \package.json\ has been restructured to use pnpm workspaces with Turbo for build orchestration, and the lockfile has been upgraded to pnpm v9.0 format.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 39 → 51 (+12.1)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 67 → 84 (+16.6)
• Architecture 86 (new)
• Maturity 57 → 67 (+10.1)
• Readiness 20 → 33 (+12.9)
• Security 54 → 71 (+16.6)
• Performance 60 (new)

• Boundary-crossing change coupling: index.ts ↔ ast.ts (drizzle-orm/src/aws-data-api/common/index.ts)
• Boundary-crossing change coupling: introspect-singlestore.ts ↔ vector.ts (drizzle-kit/src/introspect-singlestore.ts)
• Boundary-crossing change coupling: singlestoreSerializer.ts ↔ vector.ts (drizzle-kit/src/serializer/singlestoreSerializer.ts)
• Change coupling: GeneratorFuncs.ts ↔ SeedService.ts (drizzle-seed/src/services/GeneratorFuncs.ts)
• Change coupling: analyze.ts ↔ index.ts (drizzle-kit/imports-checker/analyze.ts)
• Change coupling: ast.ts ↔ options.ts (eslint-plugin-drizzle/src/utils/ast.ts)
• Change coupling: checker.ts ↔ grammar.ohm-bundle.js (drizzle-kit/imports-checker/checker.ts)
• Change coupling: enforce-delete-with-where.ts ↔ ast.ts (eslint-plugin-drizzle/src/enforce-delete-with-where.ts)
• Change coupling: enforce-delete-with-where.ts ↔ enforce-update-with-where.ts (eslint-plugin-drizzle/src/enforce-delete-with-where.ts)
• Change coupling: enforce-update-with-where.ts ↔ ast.ts (eslint-plugin-drizzle/src/enforce-update-with-where.ts)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Dimension evaluation failed
• FileTooLong: src/jsonDiffer.js (drizzle-kit/src/jsonDiffer.js)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• …and 87 more

• Assertions commented out: Simple case from GH (integration-tests/tests/relational/issues-schemas/wrong-mapping/pg.test.ts)
• Change coupling clique: dialect.ts, dialect.ts, dialect.ts (drizzle-orm/src/mysql-core/dialect.ts)
• Change coupling: db.ts ↔ db.ts (drizzle-orm/src/mysql-core/db.ts)
• Change coupling: delete.ts ↔ insert.ts (drizzle-orm/src/pg-core/query-builders/delete.ts)
• Change coupling: delete.ts ↔ update.ts (drizzle-orm/src/mysql-core/query-builders/delete.ts)
• Change coupling: delete.ts ↔ update.ts (drizzle-orm/src/pg-core/query-builders/delete.ts)
• Change coupling: driver.ts ↔ driver.ts (drizzle-orm/src/better-sqlite3/driver.ts)
• Change coupling: driver.ts ↔ driver.ts (drizzle-orm/src/mysql2/driver.ts)
• Change coupling: session.ts ↔ session.ts (drizzle-orm/src/neon-serverless/session.ts)
• Change coupling: tables.ts ↔ tables.ts (drizzle-orm/type-tests/mysql/tables.ts)
• Change coupling: tables.ts ↔ tables.ts (drizzle-orm/type-tests/pg/tables.ts)
• Change-coupling hub: driver.ts → driver.ts, driver.ts, driver.ts (drizzle-orm/src/node-postgres/driver.ts)
• Change-coupling hub: driver.ts → driver.ts, driver.ts, driver.ts, driver.ts (drizzle-orm/src/neon-serverless/driver.ts)
• Change-coupling hub: driver.ts → driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts (drizzle-orm/src/vercel-postgres/driver.ts)
• Change-coupling hub: driver.ts → driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts (drizzle-orm/src/bun-sqlite/driver.ts)
• Change-coupling hub: driver.ts → driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts, driver.ts (drizzle-orm/src/libsql/driver.ts)
• Coverage not measured — JavaScript/TypeScript suite
• Critical CVE: [CVE redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• …and 606 more

• 5 commits — 5 feature/other, 0 fixes

• .github/workflows — 2 commits
• (root) — 1 commit
• drizzle-kit/vitest.config.ts — 1 commit
• integration-tests/vitest.config.ts — 1 commit

• change: +
• change: [All-kit]: Warn when journal timestamps can cause migrations to be skipped (#6301)
• change: exclude gel from pull
• change: remove gel
• change: skip gel

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

drizzle-team/drizzle-orm was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.