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

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-export { D as DrizzleAdapter, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-C6ENLDau.cjs';
+export { D as DrizzleAdapter, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-Cs3Jl9Fb.cjs';
 export { T as TableResolver } from './core-CVO7WYDj.cjs';
 import 'drizzle-orm';
-import './migration-B6AmjCQ1.cjs';
+import './migration-Ce0hkgr_.cjs';
 import './schema-BDn8WfSL.cjs';
 import './error-BrdknH2s.cjs';
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { D as DrizzleAdapter, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-D4GM1VAZ.js';
+export { D as DrizzleAdapter, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-CHlx_Taa.js';
 export { T as TableResolver } from './core-CVO7WYDj.js';
 import 'drizzle-orm';
-import './migration-R06fsTrz.js';
+import './migration-CgoxgWOL.js';
 import './schema-BIQ0YQZ_.js';
 import './error-BrdknH2s.js';
 

package/dist/index.mjs

@@ -1,6 +1,20 @@
-import { getColumns, count, desc, asc, sql, and, or, not, notBetween, between, isNotNull, isNull, notInArray, inArray, ilike, like, lte, gte, lt, gt, ne, eq } from 'drizzle-orm';
+import { getColumns, count, sql, desc, asc, and, or, not, is, SQL, Column, notBetween, between, isNotNull, isNull, notInArray, inArray, ilike, like, lte, gte, lt, gt, ne, eq } from '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) => {
@@ -120,9 +134,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());
     },
@@ -153,6 +164,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(
+    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 (is(value, SQL) || is(value, Column)) return sql`${value}`;
+  if (column) {
+    return sql`${sql.param(
+      isJsonColumn(column) ? valueForJsonColumn(value) : value,
+      column
+    )}`;
+  }
+  return sql`${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,
+      sql`${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,
+      sql`${sql.identifier(column.name)} = ${boundValue(value, column, input.bindUnmodeled)}`
+    );
+  }
+  const statement = sql`UPDATE ${input.tableObj} SET ${sql.join([...assignments.values()], sql`, `)}`;
+  const condition = buildDrizzleWhere(input.tableObj, input.where);
+  if (condition) statement.append(sql` WHERE ${condition}`);
+  if (input.returning && input.returning.length > 0) {
+    statement.append(sql` RETURNING ${sql.join(input.returning, sql`, `)}`);
+  }
+  return statement;
+}
 
 // src/adapter.ts
 var DATE_DATA_TYPE = /(?:^|\s)date$/;
@@ -284,9 +363,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);
       }
     }
@@ -1456,11 +1533,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, (
@@ -1474,7 +1551,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()
@@ -1483,7 +1560,7 @@ var DrizzleAdapter = class {
           params.push(tableName);
           break;
         case "sqlite":
-          sql3 = `
+          sql5 = `
             SELECT COUNT(*) as count
             FROM sqlite_master
             WHERE type = 'table'
@@ -1499,7 +1576,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql3,
+        sql5,
         params
       );
       if (results.length === 0) {
@@ -1531,11 +1608,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
@@ -1545,7 +1622,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()
@@ -1554,7 +1631,7 @@ var DrizzleAdapter = class {
           `;
           break;
         case "sqlite":
-          sql3 = `
+          sql5 = `
             SELECT name as table_name
             FROM sqlite_master
             WHERE type = 'table'
@@ -1570,7 +1647,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql3,
+        sql5,
         params
       );
       return results.map((row) => row.table_name);
@@ -1636,6 +1713,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) => sql`${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(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.
    *
@@ -1648,14 +1882,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
     );
   }
@@ -1676,8 +1910,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;
@@ -1685,6 +1920,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()",