@nextlyhq/adapter-drizzle 0.0.2-alpha.65 → 0.0.2-alpha.67

package/dist/index.cjs

@@ -1,8 +1,23 @@
 'use strict';
 
+var async_hooks = require('async_hooks');
 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) => {
@@ -14,6 +29,14 @@ function buildDrizzleOrderBy(columns, orderBy) {
     return [spec.nulls === "last" ? drizzleOrm.asc(isNull2) : drizzleOrm.desc(isNull2), direction];
   });
 }
+function containsPattern(value) {
+  return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
+}
+function caseInsensitiveContains(column, value) {
+  return drizzleOrm.sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;
+}
+
+// src/drizzle-where.ts
 function buildDrizzleWhere(table, where) {
   const columns = drizzleOrm.getColumns(table);
   return processWhereClause(columns, where);
@@ -66,9 +89,6 @@ function isWhereCondition(item) {
 function namesABranch(where) {
   return Boolean(where.and?.length || where.or?.length || where.not);
 }
-function containsPattern(value) {
-  return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
-}
 function buildCondition(columns, cond) {
   const column = columns[cond.column];
   if (!column) {
@@ -93,7 +113,7 @@ function buildCondition(columns, cond) {
     case "LIKE":
       return drizzleOrm.like(col, cond.value);
     case "ILIKE":
-      return drizzleOrm.ilike(col, cond.value);
+      return drizzleOrm.sql`lower(${col}) like lower(${cond.value})`;
     case "IN":
       return drizzleOrm.inArray(col, cond.value);
     case "NOT IN":
@@ -108,11 +128,45 @@ function buildCondition(columns, cond) {
       return drizzleOrm.notBetween(col, cond.value, cond.valueTo);
     case "CONTAINS":
       return drizzleOrm.sql`${col} like ${containsPattern(String(cond.value))} escape '!'`;
+    case "ICONTAINS":
+      return caseInsensitiveContains(col, String(cond.value));
     default:
       throw new Error(`Unsupported operator: ${cond.op}`);
   }
 }
 
+// src/pinned-transaction.ts
+function pinTransactions(db, checkout) {
+  const pinned = async (work, config) => {
+    const connection = await checkout();
+    let dirty = false;
+    let workFailure;
+    try {
+      return await connection.drizzle.transaction(async (tx) => {
+        try {
+          return await work(tx);
+        } catch (error) {
+          workFailure = { error };
+          throw error;
+        }
+      }, config);
+    } catch (error) {
+      await connection.rollback().catch(() => {
+        dirty = true;
+      });
+      throw workFailure ? workFailure.error : error;
+    } finally {
+      connection.release(dirty);
+    }
+  };
+  Object.defineProperty(db, "transaction", {
+    value: pinned,
+    configurable: true,
+    writable: true
+  });
+  return db;
+}
+
 // src/transaction-forwarders.ts
 function createTransactionForwarders(delegator, txDb) {
   return {
@@ -122,9 +176,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());
     },
@@ -137,6 +188,20 @@ function createTransactionForwarders(delegator, txDb) {
     getDrizzle: () => txDb()
   };
 }
+function transactionDrizzleHandles(build) {
+  let bareInstance;
+  const bare = () => bareInstance ??= build();
+  const relational = /* @__PURE__ */ new WeakMap();
+  const withRelations = (relations) => {
+    let cached = relational.get(relations);
+    if (cached === void 0) {
+      cached = build(relations);
+      relational.set(relations, cached);
+    }
+    return cached;
+  };
+  return { bare, withRelations };
+}
 
 // src/types/error.ts
 function isDatabaseError(error) {
@@ -155,6 +220,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$/;
@@ -203,6 +336,155 @@ function affectedRowCount(result) {
   return 0;
 }
 var DrizzleAdapter = class {
+  /**
+   * Whether a `transaction()` call made from the current async context would
+   * join a transaction already open on this adapter, as a savepoint, rather
+   * than open one of its own.
+   *
+   * A caller about to do something no rollback can undo — removing a stored
+   * file, say — asks this first: work that joins an enclosing transaction is
+   * undone with it, while the effect it performs after its own savepoint
+   * releases is not.
+   *
+   * False here. Concrete rather than abstract so existing adapters keep
+   * working unchanged, and false is right for a pooled adapter: a call made
+   * inside another transaction's work opens its own transaction on its own
+   * connection, which commits independently.
+   *
+   * @returns True when the call would nest in an open transaction
+   */
+  inTransaction() {
+    return false;
+  }
+  /**
+   * The transaction each async flow is inside, kept per flow rather than per
+   * connection: on SQLite every request shares the one connection, and
+   * another request's open transaction says nothing about this one.
+   */
+  flowTransactions = new async_hooks.AsyncLocalStorage();
+  /**
+   * Whether the calling async flow is inside a transaction on this adapter
+   * that has not finished: its own, or one it was started from inside.
+   *
+   * A write that must outlive any rollback — a count of a failed attempt, the
+   * spend of a single-use secret — asks this before running in a transaction
+   * of its own. Made inside an open transaction on SQLite, it joins that
+   * transaction as a savepoint and is undone with it. On PostgreSQL and MySQL
+   * it would commit on a connection of its own, so refusing it there too
+   * keeps code that passes on one dialect from failing on another. Unlike
+   * {@link inTransaction}, which asks whether a call would nest and is always
+   * false on a pooled adapter, this answers alike on every dialect, and
+   * another flow's open transaction never answers true.
+   *
+   * Covers transactions opened through {@link transaction} and through the
+   * Drizzle handle's own `transaction` on the dialects whose handle takes
+   * async work. A dialect that keeps scopes of its own judges from those
+   * instead; an adapter that does neither answers false.
+   *
+   * @experimental
+   * @returns True while a transaction the calling flow is inside is open
+   */
+  transactionOpenInFlow() {
+    for (let at = this.flowTransactions.getStore(); at !== void 0; at = at.enclosing) {
+      if (at.open) return true;
+    }
+    return false;
+  }
+  /**
+   * Run a whole transaction, from its BEGIN until its COMMIT or ROLLBACK has
+   * run, as the calling flow's open transaction, for
+   * {@link transactionOpenInFlow}. A dialect's `transaction` runs through
+   * this unless it judges the flow from scopes of its own.
+   *
+   * The transaction counts as open for its work and for anything the work
+   * starts, awaited or not, until it has finished. Something the work starts
+   * that outlives it then sees it closed, or the one enclosing it still open.
+   *
+   * @param run - The transaction, BEGIN to COMMIT or ROLLBACK
+   * @returns What `run` resolves to
+   */
+  runInFlowTransaction(run) {
+    const scope = {
+      open: true,
+      enclosing: this.flowTransactions.getStore()
+    };
+    return this.flowTransactions.run(scope, async () => {
+      try {
+        return await run();
+      } finally {
+        scope.open = false;
+      }
+    });
+  }
+  /**
+   * Run each of a pool-bound Drizzle handle's transactions on a connection
+   * `checkout` hands it, and return that connection as the adapter's own
+   * `transaction()` does: closed rather than pooled when no ROLLBACK can be
+   * confirmed on it, and never leaked by a failed BEGIN (`pinTransactions`).
+   *
+   * For PostgreSQL's and MySQL's handles. Apply it before
+   * {@link trackFlowTransactions}, which wraps whatever `transaction` the
+   * handle has at that point.
+   *
+   * @param db - A Drizzle handle on this adapter's pool
+   * @param checkout - Checks out a connection for one transaction
+   * @returns The same handle, its `transaction` replaced
+   */
+  pinDrizzleTransactions(db, checkout) {
+    return pinTransactions(db, checkout);
+  }
+  /**
+   * Make a Drizzle handle's own `transaction` count for
+   * {@link transactionOpenInFlow}, as the adapter's does.
+   *
+   * Core's services run their transactions through the handle on PostgreSQL
+   * and MySQL; without this, a call made inside one would be refused on
+   * SQLite, where they go through the adapter, and let through on the
+   * others. Not for SQLite's handle: its `transaction` takes only
+   * synchronous work, which no async flow can be inside.
+   *
+   * @param db - A Drizzle handle this adapter created
+   * @returns The same handle, its `transaction` tracked
+   */
+  trackFlowTransactions(db) {
+    const transactor = db;
+    const untracked = transactor.transaction.bind(transactor);
+    const tracked = (work, config) => this.runInFlowTransaction(() => untracked(work, config));
+    Object.defineProperty(db, "transaction", {
+      value: tracked,
+      configurable: true,
+      writable: true
+    });
+    return db;
+  }
+  /**
+   * Run `effect` once the write made from the current async context has
+   * committed: an event, a hook, a cache flush, anything outside the database
+   * that must not happen for a change that is rolled back.
+   *
+   * A caller invokes this after its own transaction has resolved. Where that
+   * transaction was nested in an enclosing one, as a savepoint, the change is
+   * not durable yet, and an adapter that nests (see {@link inTransaction})
+   * holds `effect` until the outermost transaction commits, and drops it when
+   * that transaction, or the savepoint it was registered in, rolls back. A
+   * held effect runs after the commit, before the outermost `transaction()`
+   * call resolves, in registration order; one that then throws or rejects is
+   * handed to `onDeferredFailure` rather than failing a transaction that has
+   * committed.
+   *
+   * Here `effect` runs now and the returned promise settles with it, its
+   * failure included. Concrete rather than abstract, as `inTransaction` is,
+   * and right for a pooled adapter: each transaction has its own connection
+   * and has committed by the time its caller continues.
+   *
+   * @experimental
+   * @param effect - What to run once the change is durable
+   * @param onDeferredFailure - Receives the error of a held effect that fails
+   * @returns Settles once `effect` has run, or once it has been held
+   */
+  async afterCommit(effect, _onDeferredFailure) {
+    await effect();
+  }
   // ============================================================
   // Drizzle Query API Support
   // ============================================================
@@ -286,9 +568,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);
       }
     }
@@ -1152,7 +1432,8 @@ var DrizzleAdapter = class {
    * @remarks
    * Default implementation uses dialect-specific ON CONFLICT syntax.
    * PostgreSQL/SQLite: ON CONFLICT ... DO UPDATE
-   * MySQL: ON DUPLICATE KEY UPDATE
+   * MySQL: the MySQL adapter overrides this, resolving the conflict by the
+   * conflict columns (see its `upsert`)
    *
    * @param table - Table name
    * @param data - Record data
@@ -1189,9 +1470,12 @@ var DrizzleAdapter = class {
             updateData[key] = data[key];
           }
         }
+        const keepExisting = Object.keys(updateData).length === 0;
+        this.assertUpsertTarget(table, data, options, keepExisting);
         let query;
         if (caps.supportsOnConflict) {
-          query = db.insert(tableObj).values(data).onConflictDoUpdate({
+          const inserted = db.insert(tableObj).values(data);
+          query = keepExisting ? inserted.onConflictDoNothing({ target: conflictTarget }) : inserted.onConflictDoUpdate({
             target: conflictTarget,
             set: updateData
           });
@@ -1200,21 +1484,24 @@ var DrizzleAdapter = class {
         }
         if (caps.supportsReturning) {
           const result = await query.returning();
-          return Array.isArray(result) ? result[0] : result;
+          const row = Array.isArray(result) ? result[0] : result;
+          if (row !== void 0) return row;
+        } else {
+          await query;
         }
-        await query;
-        if (options.conflictColumns.length && data[options.conflictColumns[0]] !== void 0) {
+        const conflictValues = options.conflictColumns.map(
+          (column) => [column, data[column]]
+        );
+        if (conflictValues.length > 0 && conflictValues.every(([, value]) => value !== void 0)) {
           return await this.selectOne(
             table,
             {
               where: {
-                and: [
-                  {
-                    column: options.conflictColumns[0],
-                    op: "=",
-                    value: data[options.conflictColumns[0]]
-                  }
-                ]
+                and: conflictValues.map(([column, value]) => ({
+                  column,
+                  op: "=",
+                  value
+                }))
               }
             },
             executor
@@ -1458,11 +1745,11 @@ var DrizzleAdapter = class {
    */
   async tableExists(tableName, schema) {
     try {
-      let sql3;
+      let sql6;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql3 = `
+          sql6 = `
             SELECT EXISTS (
               SELECT FROM information_schema.tables
               WHERE table_schema = COALESCE($1, (
@@ -1476,7 +1763,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? null, tableName);
           break;
         case "mysql":
-          sql3 = `
+          sql6 = `
             SELECT COUNT(*) as count
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1485,7 +1772,7 @@ var DrizzleAdapter = class {
           params.push(tableName);
           break;
         case "sqlite":
-          sql3 = `
+          sql6 = `
             SELECT COUNT(*) as count
             FROM sqlite_master
             WHERE type = 'table'
@@ -1501,7 +1788,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql3,
+        sql6,
         params
       );
       if (results.length === 0) {
@@ -1533,11 +1820,11 @@ var DrizzleAdapter = class {
    */
   async listTables(schema) {
     try {
-      let sql3;
+      let sql6;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql3 = `
+          sql6 = `
             SELECT table_name
             FROM information_schema.tables
             WHERE table_schema = $1
@@ -1547,7 +1834,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? "public");
           break;
         case "mysql":
-          sql3 = `
+          sql6 = `
             SELECT table_name AS table_name
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1556,7 +1843,7 @@ var DrizzleAdapter = class {
           `;
           break;
         case "sqlite":
-          sql3 = `
+          sql6 = `
             SELECT name as table_name
             FROM sqlite_master
             WHERE type = 'table'
@@ -1572,7 +1859,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql3,
+        sql6,
         params
       );
       return results.map((row) => row.table_name);
@@ -1638,6 +1925,224 @@ var DrizzleAdapter = class {
   createTransactionForwarders(txDb) {
     return createTransactionForwarders(this, txDb);
   }
+  /**
+   * The Drizzle handles one transaction hands out; see
+   * `transactionDrizzleHandles`. `build` makes an instance on the
+   * transaction's own connection, with the relations config when given one.
+   *
+   * @protected
+   */
+  transactionDrizzleHandles(build) {
+    return transactionDrizzleHandles(build);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Refuse an upsert target every dialect would not answer alike: a conflict
+   * column named twice, which SQLite rejects as no constraint's target and
+   * MySQL would accept; and, when nothing is to be updated, a conflict column
+   * left for the database to fill, since the row that stands is then read
+   * back by a value the caller never gave. Shared with the dialects that
+   * override `upsert`, so the refusals are one rule.
+   */
+  assertUpsertTarget(table, data, options, keepExisting) {
+    const columns = options.conflictColumns;
+    if (new Set(columns).size !== columns.length) {
+      throw createDatabaseError({
+        kind: "query",
+        message: `upsert on ${table} names a conflict column more than once (${columns.join(", ")}).`
+      });
+    }
+    if (keepExisting && columns.some((column) => data[column] === void 0)) {
+      throw createDatabaseError({
+        kind: "query",
+        message: `upsert on ${table} needs a value for every conflict column (${columns.join(", ")}).`
+      });
+    }
+  }
+  /**
+   * 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);
+  }
+  /**
+   * The driver's own error inside `error`: the first in its `cause` chain that
+   * `isDriverError` recognises, or `error` itself when none does.
+   *
+   * A query that runs through Drizzle fails with Drizzle's `DrizzleQueryError`,
+   * whose message is the SQL statement and which carries no driver code; the
+   * driver's error, the only object that knows what actually went wrong, is
+   * its `cause`. A dialect's {@link classifyError} classifies from what this
+   * returns, so a failure reads the same whether or not Drizzle wrapped it.
+   *
+   * The walk is bounded, because an error chain can be made cyclic and a
+   * classifier that can hang is worse than one that gives up. Falling back to
+   * `error` keeps an error that carries no code anywhere classified as before.
+   *
+   * @param error - The error as it was caught
+   * @param isDriverError - Whether a link in the chain is the driver's error
+   * @returns The driver's error, or `error` when no link is
+   */
+  driverErrorIn(error, isDriverError) {
+    let cursor = error;
+    for (let depth = 0; depth < 10; depth++) {
+      if (cursor === null || typeof cursor !== "object") break;
+      const candidate = cursor;
+      if (isDriverError(candidate)) return candidate;
+      cursor = candidate.cause;
+    }
+    return error ?? {};
+  }
   /**
    * Classify an error into a DatabaseError.
    *
@@ -1650,14 +2155,14 @@ var DrizzleAdapter = class {
    *
    * @protected
    */
-  classifyError(error, sql3) {
+  classifyError(error, sql6) {
     if (isDatabaseError(error)) {
       return error;
     }
     const errorMessage = error instanceof Error ? error.message : String(error);
     return this.createDatabaseError(
       "query",
-      sql3 ? `Query failed: ${errorMessage}` : errorMessage,
+      sql6 ? `Query failed: ${errorMessage}` : errorMessage,
       error instanceof Error ? error : void 0
     );
   }
@@ -1678,8 +2183,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 +2193,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()",