@nextlyhq/adapter-drizzle 0.0.2-alpha.64 → 0.0.2-alpha.66

package/dist/{adapter-D4GM1VAZ.d.ts → adapter-CHlx_Taa.d.ts}

@@ -1,5 +1,5 @@
 import { AnyRelations, SQL } from 'drizzle-orm';
-import { T as TransactionContext, S as SelectOptions, W as WhereClause, U as UpdateOptions, D as DeleteOptions, e as UpsertOptions, f as TransactionOptions, g as DatabaseCapabilities, P as PoolStats, C as CountOptions, I as InsertOptions, a as Migration, d as MigrationResult } from './migration-R06fsTrz.js';
+import { T as TransactionContext, S as SelectOptions, W as WhereClause, D as DeleteOptions, U as UpsertOptions, e as TransactionOptions, f as DatabaseCapabilities, P as PoolStats, C as CountOptions, I as InsertOptions, g as UpdateOptions, a as Migration, d as MigrationResult } from './migration-CgoxgWOL.js';
 import { S as SupportedDialect, a as SqlParam, T as TableResolver } from './core-CVO7WYDj.js';
 import { T as TableDefinition, C as CreateTableOptions, D as DropTableOptions, A as AlterTableOperation, a as AlterTableOptions } from './schema-BIQ0YQZ_.js';
 import { D as DatabaseErrorKind, a as DatabaseError } from './error-BrdknH2s.js';
@@ -21,15 +21,20 @@ import { D as DatabaseErrorKind, a as DatabaseError } from './error-BrdknH2s.js'
 interface TransactionCrudDelegator {
     select<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T[]>;
     selectOne<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T | null>;
-    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
     updateCount(table: string, data: Record<string, unknown>, where: WhereClause, executor?: unknown): Promise<number>;
     delete(table: string, where: WhereClause, options?: DeleteOptions, executor?: unknown): Promise<number>;
     upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions, executor?: unknown): Promise<T>;
 }
 /**
  * Transaction context CRUD methods provided by the forwarder.
+ *
+ * `update` is not among them. The pooled `update` goes through the Drizzle
+ * query builder, which writes the columns the runtime model declares; a
+ * transaction's update must reach the columns the physical table has, and
+ * each adapter binds the base class's `transactionUpdate` beside its
+ * transactional `insert`.
  */
-type TransactionCrudForwarders = Pick<TransactionContext, "select" | "selectOne" | "update" | "updateCount" | "delete" | "upsert" | "getDrizzle">;
+type TransactionCrudForwarders = Pick<TransactionContext, "select" | "selectOne" | "updateCount" | "delete" | "upsert" | "getDrizzle">;
 
 /**
  * Base database adapter abstract class.
@@ -806,6 +811,87 @@ declare abstract class DrizzleAdapter {
      * @protected
      */
     protected createTransactionForwarders(txDb: () => unknown): TransactionCrudForwarders;
+    /**
+     * A transaction context's `update`, for each adapter to bind.
+     *
+     * Not forwarded to the pooled `update` the way `select` and `delete` are:
+     * that one goes through the Drizzle query builder, which writes the columns
+     * the runtime MODEL declares, and a transaction's update must reach the
+     * columns the physical TABLE has — the localization transition window
+     * writes a column the model has already moved to a companion table that
+     * does not exist yet. The INSERT half of every transaction context already
+     * builds its own statement for that reason; `update-statement.ts` is the
+     * UPDATE half, spelled once for the three adapters, and this runs it: on
+     * the transaction executor, classified with the operation and table named
+     * as the pooled `update` classifies its failures, and read back through
+     * `select` on the same executor when the caller asked for rows.
+     *
+     * That read is by the rows' IDENTITY where the dialect can report it: on
+     * PostgreSQL and SQLite the statement carries `RETURNING <primary key>`, and
+     * the read-back asks for exactly those rows — so a row another transaction
+     * adds under the same predicate meanwhile is not among them, and an update
+     * whose own write falsifies its predicate still reads its rows back. MySQL
+     * has no RETURNING, so there the read re-runs the predicate, as the pooled
+     * `update` always has on that dialect; a table with no primary key in its
+     * model reads back the same way.
+     *
+     * @param txDb - thunk returning the transaction-bound Drizzle instance
+     * @param run - how this dialect runs a statement on that instance, and the
+     *   rows it returns when the statement carries RETURNING: better-sqlite3
+     *   answers synchronously, the pooled drivers do not
+     * @param bindUnmodeled - how a value binds when the model declares no
+     *   column for it; a declared column binds through its own encoder
+     * @returns the context's `update` method
+     */
+    protected transactionUpdate(txDb: () => unknown, run: (statement: SQL, returnsRows: boolean) => Promise<Record<string, unknown>[] | undefined> | Record<string, unknown>[] | undefined, bindUnmodeled: (value: unknown) => unknown): TransactionContext["update"];
+    /**
+     * The columns that identify a row of this table, under both spellings: the
+     * SQL name RETURNING reports and the Drizzle property name the query
+     * builder's WHERE is addressed by. Columns flagged primary first; failing
+     * that, the table-level primary key the dialect's table config carries
+     * (`primaryKey({ columns })` leaves each column's flag false), which each
+     * adapter reads through its own dialect. Empty when the model declares
+     * neither, and the read-back falls back to the caller's predicate.
+     */
+    protected identityColumns(tableObj: Record<string, unknown>): Array<{
+        jsName: string;
+        sqlName: string;
+    }>;
+    /**
+     * How a value binds to a column the model does not declare, on a driver
+     * that binds scalars, dates and binary natively: a structured value goes
+     * as JSON text, since what node-postgres and mysql2 make of a bare object
+     * or array is not JSON. For the adapters to hand `transactionUpdate`.
+     */
+    protected bindUnmodeledStructuredAsJson(value: unknown): unknown;
+    /**
+     * The columns of a table-level `primaryKey({ columns })`, as the dialect's
+     * table config reports them. The base class cannot read that config without
+     * naming a dialect, so each adapter answers for its own; a dialect that does
+     * not answer reports none.
+     */
+    protected compositePrimaryKey(_tableObj: Record<string, unknown>): object[];
+    /** The registered table object, or the error every CRUD method throws without one. */
+    private resolvedTableObject;
+    /**
+     * The statement `transactionUpdate` runs.
+     *
+     * @throws when nothing would be written — every key `undefined`, or none at
+     *   all. The query builder refused that too ("No values to set"), and a
+     *   patch that names nothing is a caller's mistake rather than a write of
+     *   nothing.
+     */
+    private buildTransactionUpdate;
+    /**
+     * Whether a transaction's `update` reads the rows it changed back: the
+     * caller named columns, or `*`. An empty list, like no option at all, asks
+     * for nothing and `update` answers `[]`, as it always has. The rows come
+     * from a read of the update's own WHERE on its own transaction, so they are
+     * the model's view of the row, decoded as every read is decoded — which is
+     * what the query-builder update returned for them, and why the named list
+     * selects nothing narrower.
+     */
+    private updateReturnsRows;
     /**
      * Classify an error into a DatabaseError.
      *

package/dist/{adapter-C6ENLDau.d.cts → adapter-Cs3Jl9Fb.d.cts}

@@ -1,5 +1,5 @@
 import { AnyRelations, SQL } from 'drizzle-orm';
-import { T as TransactionContext, S as SelectOptions, W as WhereClause, U as UpdateOptions, D as DeleteOptions, e as UpsertOptions, f as TransactionOptions, g as DatabaseCapabilities, P as PoolStats, C as CountOptions, I as InsertOptions, a as Migration, d as MigrationResult } from './migration-B6AmjCQ1.cjs';
+import { T as TransactionContext, S as SelectOptions, W as WhereClause, D as DeleteOptions, U as UpsertOptions, e as TransactionOptions, f as DatabaseCapabilities, P as PoolStats, C as CountOptions, I as InsertOptions, g as UpdateOptions, a as Migration, d as MigrationResult } from './migration-Ce0hkgr_.cjs';
 import { S as SupportedDialect, a as SqlParam, T as TableResolver } from './core-CVO7WYDj.cjs';
 import { T as TableDefinition, C as CreateTableOptions, D as DropTableOptions, A as AlterTableOperation, a as AlterTableOptions } from './schema-BDn8WfSL.cjs';
 import { D as DatabaseErrorKind, a as DatabaseError } from './error-BrdknH2s.cjs';
@@ -21,15 +21,20 @@ import { D as DatabaseErrorKind, a as DatabaseError } from './error-BrdknH2s.cjs
 interface TransactionCrudDelegator {
     select<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T[]>;
     selectOne<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T | null>;
-    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
     updateCount(table: string, data: Record<string, unknown>, where: WhereClause, executor?: unknown): Promise<number>;
     delete(table: string, where: WhereClause, options?: DeleteOptions, executor?: unknown): Promise<number>;
     upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions, executor?: unknown): Promise<T>;
 }
 /**
  * Transaction context CRUD methods provided by the forwarder.
+ *
+ * `update` is not among them. The pooled `update` goes through the Drizzle
+ * query builder, which writes the columns the runtime model declares; a
+ * transaction's update must reach the columns the physical table has, and
+ * each adapter binds the base class's `transactionUpdate` beside its
+ * transactional `insert`.
  */
-type TransactionCrudForwarders = Pick<TransactionContext, "select" | "selectOne" | "update" | "updateCount" | "delete" | "upsert" | "getDrizzle">;
+type TransactionCrudForwarders = Pick<TransactionContext, "select" | "selectOne" | "updateCount" | "delete" | "upsert" | "getDrizzle">;
 
 /**
  * Base database adapter abstract class.
@@ -806,6 +811,87 @@ declare abstract class DrizzleAdapter {
      * @protected
      */
     protected createTransactionForwarders(txDb: () => unknown): TransactionCrudForwarders;
+    /**
+     * A transaction context's `update`, for each adapter to bind.
+     *
+     * Not forwarded to the pooled `update` the way `select` and `delete` are:
+     * that one goes through the Drizzle query builder, which writes the columns
+     * the runtime MODEL declares, and a transaction's update must reach the
+     * columns the physical TABLE has — the localization transition window
+     * writes a column the model has already moved to a companion table that
+     * does not exist yet. The INSERT half of every transaction context already
+     * builds its own statement for that reason; `update-statement.ts` is the
+     * UPDATE half, spelled once for the three adapters, and this runs it: on
+     * the transaction executor, classified with the operation and table named
+     * as the pooled `update` classifies its failures, and read back through
+     * `select` on the same executor when the caller asked for rows.
+     *
+     * That read is by the rows' IDENTITY where the dialect can report it: on
+     * PostgreSQL and SQLite the statement carries `RETURNING <primary key>`, and
+     * the read-back asks for exactly those rows — so a row another transaction
+     * adds under the same predicate meanwhile is not among them, and an update
+     * whose own write falsifies its predicate still reads its rows back. MySQL
+     * has no RETURNING, so there the read re-runs the predicate, as the pooled
+     * `update` always has on that dialect; a table with no primary key in its
+     * model reads back the same way.
+     *
+     * @param txDb - thunk returning the transaction-bound Drizzle instance
+     * @param run - how this dialect runs a statement on that instance, and the
+     *   rows it returns when the statement carries RETURNING: better-sqlite3
+     *   answers synchronously, the pooled drivers do not
+     * @param bindUnmodeled - how a value binds when the model declares no
+     *   column for it; a declared column binds through its own encoder
+     * @returns the context's `update` method
+     */
+    protected transactionUpdate(txDb: () => unknown, run: (statement: SQL, returnsRows: boolean) => Promise<Record<string, unknown>[] | undefined> | Record<string, unknown>[] | undefined, bindUnmodeled: (value: unknown) => unknown): TransactionContext["update"];
+    /**
+     * The columns that identify a row of this table, under both spellings: the
+     * SQL name RETURNING reports and the Drizzle property name the query
+     * builder's WHERE is addressed by. Columns flagged primary first; failing
+     * that, the table-level primary key the dialect's table config carries
+     * (`primaryKey({ columns })` leaves each column's flag false), which each
+     * adapter reads through its own dialect. Empty when the model declares
+     * neither, and the read-back falls back to the caller's predicate.
+     */
+    protected identityColumns(tableObj: Record<string, unknown>): Array<{
+        jsName: string;
+        sqlName: string;
+    }>;
+    /**
+     * How a value binds to a column the model does not declare, on a driver
+     * that binds scalars, dates and binary natively: a structured value goes
+     * as JSON text, since what node-postgres and mysql2 make of a bare object
+     * or array is not JSON. For the adapters to hand `transactionUpdate`.
+     */
+    protected bindUnmodeledStructuredAsJson(value: unknown): unknown;
+    /**
+     * The columns of a table-level `primaryKey({ columns })`, as the dialect's
+     * table config reports them. The base class cannot read that config without
+     * naming a dialect, so each adapter answers for its own; a dialect that does
+     * not answer reports none.
+     */
+    protected compositePrimaryKey(_tableObj: Record<string, unknown>): object[];
+    /** The registered table object, or the error every CRUD method throws without one. */
+    private resolvedTableObject;
+    /**
+     * The statement `transactionUpdate` runs.
+     *
+     * @throws when nothing would be written — every key `undefined`, or none at
+     *   all. The query builder refused that too ("No values to set"), and a
+     *   patch that names nothing is a caller's mistake rather than a write of
+     *   nothing.
+     */
+    private buildTransactionUpdate;
+    /**
+     * Whether a transaction's `update` reads the rows it changed back: the
+     * caller named columns, or `*`. An empty list, like no option at all, asks
+     * for nothing and `update` answers `[]`, as it always has. The rows come
+     * from a read of the update's own WHERE on its own transaction, so they are
+     * the model's view of the row, decoded as every read is decoded — which is
+     * what the query-builder update returned for them, and why the named list
+     * selects nothing narrower.
+     */
+    private updateReturnsRows;
     /**
      * Classify an error into a DatabaseError.
      *

package/dist/index.cjs

@@ -3,6 +3,20 @@
 var drizzleOrm = require('drizzle-orm');
 
 // src/adapter.ts
+
+// src/column-kinds.ts
+function isJsonColumn(column) {
+  return column.dataType === "json" || column.columnType === "PgJsonb" || column.columnType === "PgJson" || column.columnType === "MySqlJson" || column.columnType === "SQLiteTextJson";
+}
+function isStructuredValue(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (value instanceof Date) return false;
+  if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) return false;
+  return true;
+}
+function bindStructuredAsJson(value) {
+  return isStructuredValue(value) ? JSON.stringify(value) : value;
+}
 function buildDrizzleOrderBy(columns, orderBy) {
   if (!orderBy?.length) return [];
   return orderBy.flatMap((spec) => {
@@ -122,9 +136,6 @@ function createTransactionForwarders(delegator, txDb) {
     selectOne: async (table, options) => {
       return delegator.selectOne(table, options, txDb());
     },
-    update: async (table, data, where, options) => {
-      return delegator.update(table, data, where, options, txDb());
-    },
     updateCount: async (table, data, where) => {
       return delegator.updateCount(table, data, where, txDb());
     },
@@ -155,6 +166,74 @@ function createDatabaseError(options) {
   if (options.cause !== void 0) error.cause = options.cause;
   return error;
 }
+function isBindableColumn(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.mapToDriverValue === "function";
+}
+function valueForJsonColumn(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function columnsOf(tableObj) {
+  const byName = /* @__PURE__ */ new Map();
+  const declared = [];
+  for (const [jsName, column] of Object.entries(
+    drizzleOrm.getColumns(tableObj)
+  )) {
+    if (!isBindableColumn(column)) continue;
+    byName.set(column.name, column);
+    byName.set(jsName, column);
+    declared.push(column);
+  }
+  return { byName, declared };
+}
+function boundValue(value, column, bindUnmodeled) {
+  if (drizzleOrm.is(value, drizzleOrm.SQL) || drizzleOrm.is(value, drizzleOrm.Column)) return drizzleOrm.sql`${value}`;
+  if (column) {
+    return drizzleOrm.sql`${drizzleOrm.sql.param(
+      isJsonColumn(column) ? valueForJsonColumn(value) : value,
+      column
+    )}`;
+  }
+  return drizzleOrm.sql`${drizzleOrm.sql.param(bindUnmodeled(value))}`;
+}
+function buildUpdateStatement(input) {
+  const { byName, declared } = columnsOf(input.tableObj);
+  const assignments = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(input.data)) {
+    const column = byName.get(key);
+    const name = column?.name ?? key;
+    if (value === void 0) {
+      assignments.delete(name);
+      continue;
+    }
+    assignments.set(
+      name,
+      drizzleOrm.sql`${drizzleOrm.sql.identifier(name)} = ${boundValue(value, column, input.bindUnmodeled)}`
+    );
+  }
+  if (assignments.size === 0) return null;
+  for (const column of declared) {
+    if (assignments.has(column.name) || column.onUpdateFn === void 0) {
+      continue;
+    }
+    const value = column.onUpdateFn();
+    assignments.set(
+      column.name,
+      drizzleOrm.sql`${drizzleOrm.sql.identifier(column.name)} = ${boundValue(value, column, input.bindUnmodeled)}`
+    );
+  }
+  const statement = drizzleOrm.sql`UPDATE ${input.tableObj} SET ${drizzleOrm.sql.join([...assignments.values()], drizzleOrm.sql`, `)}`;
+  const condition = buildDrizzleWhere(input.tableObj, input.where);
+  if (condition) statement.append(drizzleOrm.sql` WHERE ${condition}`);
+  if (input.returning && input.returning.length > 0) {
+    statement.append(drizzleOrm.sql` RETURNING ${drizzleOrm.sql.join(input.returning, drizzleOrm.sql`, `)}`);
+  }
+  return statement;
+}
 
 // src/adapter.ts
 var DATE_DATA_TYPE = /(?:^|\s)date$/;
@@ -286,9 +365,7 @@ var DrizzleAdapter = class {
         continue;
       const sqlName = colDef.name;
       sqlToJs.set(sqlName, jsName);
-      const dataType = colDef.dataType;
-      const columnType = colDef.columnType;
-      if (dataType === "json" || columnType === "PgJsonb" || columnType === "PgJson" || columnType === "MySqlJson" || columnType === "SQLiteTextJson") {
+      if (isJsonColumn(colDef)) {
         jsonColumns.add(jsName);
       }
     }
@@ -1458,11 +1535,11 @@ var DrizzleAdapter = class {
    */
   async tableExists(tableName, schema) {
     try {
-      let sql3;
+      let sql5;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql3 = `
+          sql5 = `
             SELECT EXISTS (
               SELECT FROM information_schema.tables
               WHERE table_schema = COALESCE($1, (
@@ -1476,7 +1553,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? null, tableName);
           break;
         case "mysql":
-          sql3 = `
+          sql5 = `
             SELECT COUNT(*) as count
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1485,7 +1562,7 @@ var DrizzleAdapter = class {
           params.push(tableName);
           break;
         case "sqlite":
-          sql3 = `
+          sql5 = `
             SELECT COUNT(*) as count
             FROM sqlite_master
             WHERE type = 'table'
@@ -1501,7 +1578,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql3,
+        sql5,
         params
       );
       if (results.length === 0) {
@@ -1533,11 +1610,11 @@ var DrizzleAdapter = class {
    */
   async listTables(schema) {
     try {
-      let sql3;
+      let sql5;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql3 = `
+          sql5 = `
             SELECT table_name
             FROM information_schema.tables
             WHERE table_schema = $1
@@ -1547,7 +1624,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? "public");
           break;
         case "mysql":
-          sql3 = `
+          sql5 = `
             SELECT table_name AS table_name
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1556,7 +1633,7 @@ var DrizzleAdapter = class {
           `;
           break;
         case "sqlite":
-          sql3 = `
+          sql5 = `
             SELECT name as table_name
             FROM sqlite_master
             WHERE type = 'table'
@@ -1572,7 +1649,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql3,
+        sql5,
         params
       );
       return results.map((row) => row.table_name);
@@ -1638,6 +1715,163 @@ var DrizzleAdapter = class {
   createTransactionForwarders(txDb) {
     return createTransactionForwarders(this, txDb);
   }
+  /**
+   * A transaction context's `update`, for each adapter to bind.
+   *
+   * Not forwarded to the pooled `update` the way `select` and `delete` are:
+   * that one goes through the Drizzle query builder, which writes the columns
+   * the runtime MODEL declares, and a transaction's update must reach the
+   * columns the physical TABLE has — the localization transition window
+   * writes a column the model has already moved to a companion table that
+   * does not exist yet. The INSERT half of every transaction context already
+   * builds its own statement for that reason; `update-statement.ts` is the
+   * UPDATE half, spelled once for the three adapters, and this runs it: on
+   * the transaction executor, classified with the operation and table named
+   * as the pooled `update` classifies its failures, and read back through
+   * `select` on the same executor when the caller asked for rows.
+   *
+   * That read is by the rows' IDENTITY where the dialect can report it: on
+   * PostgreSQL and SQLite the statement carries `RETURNING <primary key>`, and
+   * the read-back asks for exactly those rows — so a row another transaction
+   * adds under the same predicate meanwhile is not among them, and an update
+   * whose own write falsifies its predicate still reads its rows back. MySQL
+   * has no RETURNING, so there the read re-runs the predicate, as the pooled
+   * `update` always has on that dialect; a table with no primary key in its
+   * model reads back the same way.
+   *
+   * @param txDb - thunk returning the transaction-bound Drizzle instance
+   * @param run - how this dialect runs a statement on that instance, and the
+   *   rows it returns when the statement carries RETURNING: better-sqlite3
+   *   answers synchronously, the pooled drivers do not
+   * @param bindUnmodeled - how a value binds when the model declares no
+   *   column for it; a declared column binds through its own encoder
+   * @returns the context's `update` method
+   */
+  transactionUpdate(txDb, run, bindUnmodeled) {
+    return async (table, data, where, options) => {
+      const wantsRows = this.updateReturnsRows(options?.returning);
+      const tableObj = this.resolvedTableObject(table);
+      const identity = wantsRows && this.getCapabilities().supportsReturning ? this.identityColumns(tableObj) : [];
+      let reported;
+      try {
+        reported = await run(
+          this.buildTransactionUpdate(tableObj, table, data, where, {
+            bindUnmodeled,
+            returning: identity.map((key) => drizzleOrm.sql`${drizzleOrm.sql.identifier(key.sqlName)}`)
+          }),
+          identity.length > 0
+        );
+      } catch (error) {
+        throw this.handleQueryError(error, "update", table);
+      }
+      if (!wantsRows) return [];
+      if (identity.length === 0 || !Array.isArray(reported)) {
+        return this.select(table, { where }, txDb());
+      }
+      const rows = [];
+      for (let at = 0; at < reported.length; at += IDENTITY_READ_BACK_CHUNK) {
+        rows.push(
+          ...await this.select(
+            table,
+            {
+              where: rowsByIdentity(
+                identity,
+                reported.slice(at, at + IDENTITY_READ_BACK_CHUNK)
+              )
+            },
+            txDb()
+          )
+        );
+      }
+      return rows;
+    };
+  }
+  /**
+   * The columns that identify a row of this table, under both spellings: the
+   * SQL name RETURNING reports and the Drizzle property name the query
+   * builder's WHERE is addressed by. Columns flagged primary first; failing
+   * that, the table-level primary key the dialect's table config carries
+   * (`primaryKey({ columns })` leaves each column's flag false), which each
+   * adapter reads through its own dialect. Empty when the model declares
+   * neither, and the read-back falls back to the caller's predicate.
+   */
+  identityColumns(tableObj) {
+    const columns = Object.entries(drizzleOrm.getColumns(tableObj));
+    const flagged = columns.filter(([, c]) => c.primary === true);
+    const members = flagged.length > 0 ? flagged : columns.filter(
+      ([, c]) => this.compositePrimaryKey(tableObj).includes(c)
+    );
+    return members.flatMap(
+      ([jsName, c]) => typeof c.name === "string" ? [{ jsName, sqlName: c.name }] : []
+    );
+  }
+  /**
+   * How a value binds to a column the model does not declare, on a driver
+   * that binds scalars, dates and binary natively: a structured value goes
+   * as JSON text, since what node-postgres and mysql2 make of a bare object
+   * or array is not JSON. For the adapters to hand `transactionUpdate`.
+   */
+  bindUnmodeledStructuredAsJson(value) {
+    return bindStructuredAsJson(value);
+  }
+  /**
+   * The columns of a table-level `primaryKey({ columns })`, as the dialect's
+   * table config reports them. The base class cannot read that config without
+   * naming a dialect, so each adapter answers for its own; a dialect that does
+   * not answer reports none.
+   */
+  compositePrimaryKey(_tableObj) {
+    return [];
+  }
+  /** The registered table object, or the error every CRUD method throws without one. */
+  resolvedTableObject(table) {
+    const tableObj = this.getTableObject(table);
+    if (!tableObj || typeof tableObj !== "object") {
+      throw this.createDatabaseError(
+        "query",
+        `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+        void 0
+      );
+    }
+    return tableObj;
+  }
+  /**
+   * The statement `transactionUpdate` runs.
+   *
+   * @throws when nothing would be written — every key `undefined`, or none at
+   *   all. The query builder refused that too ("No values to set"), and a
+   *   patch that names nothing is a caller's mistake rather than a write of
+   *   nothing.
+   */
+  buildTransactionUpdate(tableObj, table, data, where, binding) {
+    const statement = buildUpdateStatement({
+      tableObj,
+      data,
+      where,
+      bindUnmodeled: binding.bindUnmodeled,
+      returning: binding.returning
+    });
+    if (!statement) {
+      throw this.createDatabaseError(
+        "query",
+        `No values to set: the update of "${table}" names no column with a defined value.`,
+        void 0
+      );
+    }
+    return statement;
+  }
+  /**
+   * Whether a transaction's `update` reads the rows it changed back: the
+   * caller named columns, or `*`. An empty list, like no option at all, asks
+   * for nothing and `update` answers `[]`, as it always has. The rows come
+   * from a read of the update's own WHERE on its own transaction, so they are
+   * the model's view of the row, decoded as every read is decoded — which is
+   * what the query-builder update returned for them, and why the named list
+   * selects nothing narrower.
+   */
+  updateReturnsRows(returning) {
+    return returning !== void 0 && !(Array.isArray(returning) && returning.length === 0);
+  }
   /**
    * Classify an error into a DatabaseError.
    *
@@ -1650,14 +1884,14 @@ var DrizzleAdapter = class {
    *
    * @protected
    */
-  classifyError(error, sql3) {
+  classifyError(error, sql5) {
     if (isDatabaseError(error)) {
       return error;
     }
     const errorMessage = error instanceof Error ? error.message : String(error);
     return this.createDatabaseError(
       "query",
-      sql3 ? `Query failed: ${errorMessage}` : errorMessage,
+      sql5 ? `Query failed: ${errorMessage}` : errorMessage,
       error instanceof Error ? error : void 0
     );
   }
@@ -1678,8 +1912,9 @@ var DrizzleAdapter = class {
    */
   handleQueryError(error, operation, table) {
     const dbError = this.classifyError(error);
-    if (!dbError.message.includes(operation)) {
-      dbError.message = `${operation} operation failed on table '${table}': ${dbError.message}`;
+    const context = `${operation} operation failed on table '${table}'`;
+    if (!dbError.message.includes(context)) {
+      dbError.message = `${context}: ${dbError.message}`;
     }
     if (!dbError.table) {
       dbError.table = table;
@@ -1687,6 +1922,34 @@ var DrizzleAdapter = class {
     return dbError;
   }
 };
+var IDENTITY_READ_BACK_CHUNK = 200;
+function rowsByIdentity(identity, rows) {
+  if (identity.length === 1) {
+    const [key] = identity;
+    return {
+      and: [
+        {
+          column: key.jsName,
+          op: "IN",
+          value: rows.map((row) => row[key.sqlName])
+        }
+      ]
+    };
+  }
+  return {
+    or: rows.map(
+      (row) => ({
+        and: identity.map(
+          (key) => ({
+            column: key.jsName,
+            op: "=",
+            value: row[key.sqlName]
+          })
+        )
+      })
+    )
+  };
+}
 var ALLOWED_DEFAULT_SQL_EXPRESSIONS = /* @__PURE__ */ new Set([
   "current_timestamp",
   "now()",