Skip to content
verdict:

Drizzle ORM 1.0.0-rc.1

preview

Release notes

note: no summary for this older release

We summarize recent releases. The original release notes for this version are below.

release-notesgithub.com/drizzle-team/drizzle-orm · 125 lines
  1. # v1.0.0-rc.1
  2. ⚠️ This release introduced a breaking change into our `casing` API([see below](#new-casing-api)) and removes RQB v1 `._query` for postgres
  3. ## JIT mappers
  4. Drizzle ORM now has an opt-in API for JIT(just in time compilated) mappers which make most expensive part of the db request pipeline(row mapping) as fast as humanly possible.
  5. ```ts
  6. const db = drizzle({ ..., jit: true })
  8. const query = db.select().from(users).prepare();
  9. // ^ here drizzle generates a jit mapper which will then be reused during each invocation
  11. server.get('users', (c) => {
  12. const users = await query.execute(); // as fast as using raw driver
  13. return c.json(users)
  14. })
  15. ```
  16. We've reworked internals of Drizzle ORM with the new system of `codecs`. Those are now in charge of normalising responses and requests for diffrent drivers across pg dialect. They helped us not only properly fix a set of data mapping issues but also massively improve performance by not doing unnecessary work.
  17. We've seen a 25%-30% reduction in latency, while +800rps(14500->15300) in our benchmarks
  18. Give it a go and let us know if everything works just fine!
  20. ## Effect v4
  21. `drizzle-orm@1.0.0-rc.1` comes with native support for Effect v4 via:
  22. ```ts
  23. import { PgClient } from '@effect/sql-pg';
  24. import * as PgDrizzle from 'drizzle-orm/effect-postgres';
  25. import * as Effect from 'effect/Effect';
  26. import * as Redacted from 'effect/Redacted';
  27. import { relations } from '../relations';
  29. const connectionStr = Redacted.make(process.env['PG_CONNECTION_STRING']!);
  30. const PgClientLive = PgClient.layer({
  31. url: connectionStr,
  32. });
  34. const DB = PgDrizzle.make({ relations }).pipe(Effect.provide(PgDrizzle.DefaultServices));
  35. const program = Effect.gen(function*() {
  36. const db = yield* DB;
  38. const users = yield* db.select().from(usersTable);
  39. }).pipe(Effect.provide(PgClientLive));
  41. await Effect.runPromise(program);
  42. ```
  44. ## New Casing API
  45. ⚠️ BREAKING CHANGE
  46. In `rc.1` we've finally reworked our legacy casing API of `const db = drizzle({..., casing: "camel" })` which turned out to not be a proper solution, it required duplication in drizzle-orm instantiation and drizzle-kit config and introduced and set of endless bugs all around query builder chain. All of the above is now fixed with new API:
  47. ```ts
  48. import * as d from "drizzle-orm/pg-core";
  50. const users = d.snakeCase.table("users", {
  51. id: d.serial().primaryKey(),
  52. email: d.text().unique(),
  53. fullName: d.text(), // full_name in db
  54. createdAt: d.timestamp().defaultNow(), // created_at in db
  55. })
  57. // --- for namespaces/schemas you can use
  59. const schema2 = d.camelCase.schema("schema2");
  61. const usersInSchema2 = schema2.table("users", ...);
  62. const ordersInSchema2 = schema2.table("orders", ...);
  63. // ^ all entities in schema2 will be snake_cased
  66. // --- all available entities
  67. import { snakeCase, camelCase } from "drizzle-orm/pg-core";
  69. snakeCase.view
  70. snakeCase.materializedView
  71. snakeCase.schema
  72. snakeCase.table
  74. camelCase.view
  75. camelCase.materializedView
  76. camelCase.schema
  77. camelCase.table
  78. ```
  80. ## New Netlify Database Driver
  81. > Note: The Netlify Database driver is developed and maintained by the Netlify team.
  83. **Installation:**
  84. ```bash
  85. npm install @netlify/database
  86. ```
  88. **Usage example:**
  89. ```typescript
  90. import { drizzle } from 'drizzle-orm/netlify-db';
  92. const db = drizzle();
  94. const result = await db.execute('select 1');
  95. ```
  97. ```typescript
  98. import { drizzle } from 'drizzle-orm/netlify-db';
  100. const db = drizzle(process.env.DATABASE_URL);
  102. const result = await db.execute('select 1');
  103. ```
  105. ```typescript
  106. import { drizzle } from 'drizzle-orm/netlify-db';
  108. // Explicit client — consumer controls the driver
  109. const db = drizzle({ client: netlifyDbClient });
  111. const result = await db.execute('select 1');
  112. ```
  114. ## Bug fixes and improvements:
  115. - Codec system for `postgres` - resolves issues created by differences of data types returned by different drivers or different contexts of query (regular select, JSON object, postgres array). Currently only handles supported by drizzle constructors column types. (fixes #3018, #5090, #5287)
  116. - Optimized query mappers for `postgres`
  117. - Opt-in JIT-generated mappers for all dialects
  118. - Optimized RQBv2 mappers for all dialects
  119. - ⚠️ BREAKING CHANGE: Removed RQBv1 (`db._query`) from `postgres`
  120. - Moved pg array utils (`makePgArray`, `parsePgArray`) from `drizzle-orm/pg-core/utils[/array]` to `drizzle-orm/pg-core/array`
  121. - Simplified `postgres` sessions & prepared queries
  122. - Fixed `neon-http` `bytea` data corruption
  123. - Fixed `bun-sql/postgres` timestamp timezone truncation, `json[b]` data double stringification
  124. - ⚠️ BREAKING CHANGE: Reworked casing API - moved casing control from `db` instance to `table` \ `view` \ `schema` via `import { snakeCase, camelCase } from "drizzle-orm/dialect-core"`, fixed #5112 #5282 #4181 #4209
  125. - Switched from Effect V3 to Effect V4 beta for `effect-schema`, `effect-postgres` (fixes #5414)

view on githubimported 2026-09-28 via npm