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

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var async_hooks = require('async_hooks');
 var drizzleOrm = require('drizzle-orm');
 
 // src/adapter.ts
@@ -28,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);
@@ -80,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) {
@@ -107,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":
@@ -122,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 {
@@ -148,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) {
@@ -282,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
   // ============================================================
@@ -1229,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
@@ -1266,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
           });
@@ -1277,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
@@ -1535,11 +1745,11 @@ var DrizzleAdapter = class {
    */
   async tableExists(tableName, schema) {
     try {
-      let sql5;
+      let sql6;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql5 = `
+          sql6 = `
             SELECT EXISTS (
               SELECT FROM information_schema.tables
               WHERE table_schema = COALESCE($1, (
@@ -1553,7 +1763,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? null, tableName);
           break;
         case "mysql":
-          sql5 = `
+          sql6 = `
             SELECT COUNT(*) as count
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1562,7 +1772,7 @@ var DrizzleAdapter = class {
           params.push(tableName);
           break;
         case "sqlite":
-          sql5 = `
+          sql6 = `
             SELECT COUNT(*) as count
             FROM sqlite_master
             WHERE type = 'table'
@@ -1578,7 +1788,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql5,
+        sql6,
         params
       );
       if (results.length === 0) {
@@ -1610,11 +1820,11 @@ var DrizzleAdapter = class {
    */
   async listTables(schema) {
     try {
-      let sql5;
+      let sql6;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql5 = `
+          sql6 = `
             SELECT table_name
             FROM information_schema.tables
             WHERE table_schema = $1
@@ -1624,7 +1834,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? "public");
           break;
         case "mysql":
-          sql5 = `
+          sql6 = `
             SELECT table_name AS table_name
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1633,7 +1843,7 @@ var DrizzleAdapter = class {
           `;
           break;
         case "sqlite":
-          sql5 = `
+          sql6 = `
             SELECT name as table_name
             FROM sqlite_master
             WHERE type = 'table'
@@ -1649,7 +1859,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql5,
+        sql6,
         params
       );
       return results.map((row) => row.table_name);
@@ -1715,6 +1925,16 @@ 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.
    *
@@ -1814,6 +2034,29 @@ var DrizzleAdapter = class {
   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
@@ -1872,6 +2115,34 @@ var DrizzleAdapter = class {
   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.
    *
@@ -1884,14 +2155,14 @@ var DrizzleAdapter = class {
    *
    * @protected
    */
-  classifyError(error, sql5) {
+  classifyError(error, sql6) {
     if (isDatabaseError(error)) {
       return error;
     }
     const errorMessage = error instanceof Error ? error.message : String(error);
     return this.createDatabaseError(
       "query",
-      sql5 ? `Query failed: ${errorMessage}` : errorMessage,
+      sql6 ? `Query failed: ${errorMessage}` : errorMessage,
       error instanceof Error ? error : void 0
     );
   }