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

package/dist/index.mjs

@@ -1,11 +1,31 @@
 import { DrizzleAdapter } from '@nextlyhq/adapter-drizzle';
 import { isApplicationError, createDatabaseError, isDatabaseError } from '@nextlyhq/adapter-drizzle/types';
-import { checkDialectVersion } from '@nextlyhq/adapter-drizzle/version-check';
+import { checkDialectVersion, acceptsForShare } from '@nextlyhq/adapter-drizzle/version-check';
+import { and, eq, getColumns } from 'drizzle-orm';
 import { getTableConfig } from 'drizzle-orm/mysql-core';
 import { drizzle } from 'drizzle-orm/mysql2';
 import mysql from 'mysql2/promise';
 
 // src/index.ts
+async function restoreSession(connection, restore) {
+  if (restore === null) return true;
+  if (restore.lockWaitTimeout === null) return false;
+  try {
+    await connection.query(
+      `SET SESSION innodb_lock_wait_timeout = ${restore.lockWaitTimeout}`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function returnTransactionConnection(connection, rollbackFailed, restore) {
+  if (!rollbackFailed && await restoreSession(connection, restore)) {
+    connection.release();
+  } else {
+    connection.destroy();
+  }
+}
 var VERSION = "0.1.0";
 var DEFAULT_POOL_CONFIG = {
   max: 10,
@@ -104,6 +124,11 @@ var MySqlAdapter = class extends DrizzleAdapter {
    * Connection state flag.
    */
   connected = false;
+  /**
+   * Whether the server accepts `SELECT ... FOR SHARE`, read from its version
+   * string at connect. Undefined until then, which callers treat as not known.
+   */
+  sharedRowLock;
   /**
    * Creates a new MySQL adapter instance.
    *
@@ -134,11 +159,12 @@ var MySqlAdapter = class extends DrizzleAdapter {
       const connection = await this.pool.getConnection();
       try {
         await connection.query("SELECT 1");
-        await checkDialectVersion(connection, "mysql", {
+        const { variant } = await checkDialectVersion(connection, "mysql", {
           // Why: route variant warnings through the adapter's logger so
           // users see a single, consistent log surface.
           onWarning: (msg) => this.config.logger?.warn?.(msg)
         });
+        this.sharedRowLock = acceptsForShare(variant);
         this.connected = true;
         if (this.config.logger?.info) {
           this.config.logger.info("MySQL connection established", {
@@ -264,6 +290,12 @@ var MySqlAdapter = class extends DrizzleAdapter {
    * MySQL's quirks with nested transactions.
    */
   async transaction(work, options) {
+    return this.runInFlowTransaction(
+      () => this.runTransactionAttempts(work, options)
+    );
+  }
+  /** The attempts `transaction` makes, each on a connection of its own. */
+  async runTransactionAttempts(work, options) {
     const pool = this.ensurePool();
     const maxAttempts = (options?.retryCount ?? 0) + 1;
     const retryDelayMs = options?.retryDelayMs ?? 100;
@@ -271,8 +303,10 @@ var MySqlAdapter = class extends DrizzleAdapter {
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       const connection = await pool.getConnection();
       const startTime = Date.now();
+      let rollbackFailed = false;
+      let restore = null;
       try {
-        await this.beginTransaction(connection, options);
+        restore = await this.beginTransaction(connection, options);
         const ctx = this.createTransactionContext(connection);
         const result = await work(ctx);
         await connection.query("COMMIT");
@@ -286,6 +320,7 @@ var MySqlAdapter = class extends DrizzleAdapter {
         return result;
       } catch (error) {
         await connection.query("ROLLBACK").catch(() => {
+          rollbackFailed = true;
         });
         lastError = error;
         if (isApplicationError(error)) throw error;
@@ -303,7 +338,7 @@ var MySqlAdapter = class extends DrizzleAdapter {
         }
         throw this.classifyError(error);
       } finally {
-        connection.release();
+        await returnTransactionConnection(connection, rollbackFailed, restore);
       }
     }
     throw this.classifyError(lastError);
@@ -341,8 +376,10 @@ var MySqlAdapter = class extends DrizzleAdapter {
       // ON DUPLICATE KEY UPDATE
       maxParamsPerQuery: 65535,
       // MySQL limit
-      maxIdentifierLength: 64
+      maxIdentifierLength: 64,
       // MySQL limit
+      sharedRowLock: this.sharedRowLock
+      // Known once connected
     };
   }
   /**
@@ -403,18 +440,44 @@ var MySqlAdapter = class extends DrizzleAdapter {
       throw new Error("getDrizzle() is server-only");
     }
     const pool = this.ensurePool();
-    const client = pool.pool;
     if (!relations) {
-      this.drizzleBare ??= drizzle({ client });
+      this.drizzleBare ??= this.poolDrizzle(pool);
       return this.drizzleBare;
     }
     let cached = this.drizzleByRelations.get(relations);
     if (!cached) {
-      cached = drizzle({ client, relations });
+      cached = this.poolDrizzle(pool, relations);
       this.drizzleByRelations.set(relations, cached);
     }
     return cached;
   }
+  /**
+   * A Drizzle handle on the pool, for `getDrizzle`.
+   *
+   * Its `transaction` runs on a connection this adapter checks out and
+   * returns itself (`pinDrizzleTransactions`): destroyed rather than pooled
+   * when no ROLLBACK could be confirmed on it. And it counts for
+   * `transactionOpenInFlow`, as the adapter's does.
+   */
+  poolDrizzle(pool, relations) {
+    const onClient = (client) => relations ? drizzle({ client, relations }) : drizzle({ client });
+    const callbackPool = pool.pool;
+    return this.trackFlowTransactions(
+      this.pinDrizzleTransactions(onClient(callbackPool), async () => {
+        const connection = await pool.getConnection();
+        return {
+          drizzle: onClient(
+            connection.connection
+          ),
+          rollback: () => connection.query("ROLLBACK"),
+          release: (dirty) => {
+            if (dirty) connection.destroy();
+            else connection.release();
+          }
+        };
+      })
+    );
+  }
   /**
    * Builds mysql2 Pool configuration from adapter config.
    */
@@ -457,7 +520,8 @@ var MySqlAdapter = class extends DrizzleAdapter {
     return config;
   }
   /**
-   * Begins a transaction with the specified options.
+   * Begins a transaction with the specified options, and returns what it
+   * changed on the session for `restoreSession` to put back.
    */
   async beginTransaction(connection, options) {
     if (options?.isolationLevel) {
@@ -477,11 +541,17 @@ var MySqlAdapter = class extends DrizzleAdapter {
     }
     await connection.query("START TRANSACTION");
     if (options?.timeoutMs) {
+      const [rows] = await connection.query(
+        "SELECT @@SESSION.innodb_lock_wait_timeout AS timeout"
+      );
+      const previous = Number(rows[0]?.timeout);
       const timeoutSeconds = Math.ceil(options.timeoutMs / 1e3);
       await connection.query(
         `SET SESSION innodb_lock_wait_timeout = ${timeoutSeconds}`
       );
+      return { lockWaitTimeout: Number.isInteger(previous) ? previous : null };
     }
+    return null;
   }
   /**
    * Creates a TransactionContext for the given connection.
@@ -490,6 +560,194 @@ var MySqlAdapter = class extends DrizzleAdapter {
    * Note: Savepoint methods are not implemented (set to undefined)
    * as savepoints are disabled in this adapter per approved approach.
    */
+  /**
+   * Upsert with the meaning `INSERT … ON CONFLICT (target)` has on PostgreSQL
+   * and SQLite, on the tables where MySQL can keep that promise.
+   *
+   * MySQL cannot limit a duplicate to one key: `ON DUPLICATE KEY UPDATE`
+   * fires on a collision with ANY unique key, and a failed insert does not
+   * say reliably which one. So the conflict target must be the table's only
+   * unique key apart from its primary key, and any other table is refused
+   * before anything is written. On such a table the row is inserted first —
+   * its validation and triggers apply, as they do before `ON CONFLICT`
+   * elsewhere — and a duplicate is resolved by a locking read of the target
+   * key, which sees the latest committed row rather than the transaction's
+   * snapshot. The row found is kept as it is when there is nothing to update
+   * (a no-op assignment would still run its update triggers), or updated by
+   * its key. No row there means the collision was on the primary key, and it
+   * is refused as `ON CONFLICT (target)` refuses it.
+   *
+   * The steps run in the caller's transaction, or in one of their own, since a
+   * locking read locks nothing past its statement under autocommit. Rows are
+   * read back by their primary key, so a trigger that rewrites the conflict
+   * value still returns the row stored. The conflict columns must also be
+   * given values: MySQL cannot look a row up by a key the database would only
+   * fill in itself. A conflict is resolved on the caller's key value: a
+   * BEFORE INSERT trigger that moves the key onto another row's value is
+   * refused as a unique violation rather than resolved onto that row. A failed insert rolls back only itself on MySQL, so a
+   * caller's transaction stays usable.
+   */
+  async upsert(table, data, options, executor) {
+    const tableObj = this.getTableObject(table);
+    if (!tableObj) return super.upsert(table, data, options, executor);
+    let target;
+    try {
+      target = this.upsertTarget(tableObj, table, data, options);
+    } catch (error) {
+      throw this.handleQueryError(error, "upsert", table);
+    }
+    if (executor === void 0) {
+      return this.transaction((tx) => tx.upsert(table, data, options));
+    }
+    try {
+      const db = executor;
+      if (target.nullKey) {
+        return await this.insertRow(db, tableObj, data) ?? data;
+      }
+      return await this.insertOrResolve(
+        db,
+        tableObj,
+        data,
+        options,
+        target.where
+      );
+    } catch (error) {
+      throw this.handleQueryError(error, "upsert", table);
+    }
+  }
+  /**
+   * What an upsert is keyed on: the target's condition, and whether its key
+   * holds a NULL. Refuses a target this dialect cannot keep to, and a conflict
+   * column left for the database to fill — MySQL cannot look a row up by a key
+   * value only the database would supply.
+   */
+  upsertTarget(tableObj, table, data, options) {
+    this.assertUpsertTarget(table, data, options, true);
+    const key = this.conflictKey(tableObj, table, options.conflictColumns);
+    const values = options.conflictColumns.map((column) => data[column]);
+    return {
+      where: and(...key.map((column, i) => eq(column, values[i]))),
+      nullKey: values.some((value) => value === null)
+    };
+  }
+  /**
+   * The table's columns for a conflict target, refusing a target MySQL cannot
+   * keep to: one that is not a primary or unique key, which an update could
+   * spread over several rows, and one beside which the table has another
+   * unique key, a collision on which MySQL would not tell apart.
+   */
+  conflictKey(tableObj, table, conflictColumns) {
+    const record = tableObj;
+    const columns = conflictColumns.map((name) => record[name]);
+    const names = new Set(columns.map((column) => column?.name));
+    const isTarget = (key) => key.length === names.size && key.every((name) => names.has(name));
+    const { primary, unique } = keysOf(tableObj);
+    if (primary.length === 0) {
+      throw createDatabaseError({
+        kind: "query",
+        message: `upsert on ${table}: MySQL upserts need a table with a primary key, to read back the row they write.`
+      });
+    }
+    const known = columns.every((column) => column !== void 0);
+    if (!known || !(isTarget(primary) || unique.some((k) => isTarget(k.columns)))) {
+      throw createDatabaseError({
+        kind: "query",
+        message: `upsert on ${table}: the conflict columns (${conflictColumns.join(", ")}) are not a primary or unique key of the table.`
+      });
+    }
+    const others = unique.filter((key) => !isTarget(key.columns));
+    if (others.length > 0) {
+      throw createDatabaseError({
+        kind: "query",
+        message: `upsert on ${table}: MySQL cannot limit a duplicate to the conflict columns (${conflictColumns.join(", ")}) while the table has other unique keys (${others.map((key) => key.name).join(", ")}). Upsert only on a table whose one unique key besides the primary key is the conflict target, or insert and update inside a transaction.`
+      });
+    }
+    return columns;
+  }
+  /** The update an upsert applies to an existing row: never its key. */
+  updateValues(data, options) {
+    const key = new Set(options.conflictColumns);
+    const update = {};
+    for (const column of options.updateColumns ?? Object.keys(data)) {
+      if (!key.has(column) && column in data) update[column] = data[column];
+    }
+    return update;
+  }
+  /** The row matching `where`, by a locking (current) read. */
+  async lockedRow(db, tableObj, where) {
+    const rows = await db.select().from(tableObj).where(where).limit(1).for("update");
+    return rows[0];
+  }
+  /**
+   * Insert the row, or resolve a duplicate on the target key. The insert is
+   * read back by the primary key it reports, not by the conflict key: a
+   * BEFORE INSERT trigger may have rewritten the conflict value, and the row
+   * stored is the one to return.
+   *
+   * A duplicate is resolved when a row holds the TARGET key, whichever unique
+   * key MySQL names in its error. PostgreSQL checks the target's index before
+   * any other, so a row colliding on the target and on another key resolves
+   * on the target there too; refusing it here because MySQL happened to check
+   * the other index first would answer that case differently. A target row
+   * committed by another transaction after this insert failed is the order in
+   * which that transaction ran first, where PostgreSQL also resolves on it.
+   */
+  async insertOrResolve(db, tableObj, data, options, where) {
+    let failure;
+    try {
+      const stored = await this.insertRow(db, tableObj, data);
+      return stored ?? await this.lockedRow(db, tableObj, where);
+    } catch (error) {
+      if (this.classifyError(error).kind !== "unique_violation") throw error;
+      failure = error;
+    }
+    const existing = await this.lockedRow(db, tableObj, where);
+    if (existing === void 0) throw failure;
+    const update = this.updateValues(data, options);
+    if (Object.keys(update).length === 0) return existing;
+    await db.update(tableObj).set(update).where(where);
+    const identity = this.byIdentity(tableObj, {
+      ...existing,
+      ...update
+    });
+    const updated = identity === void 0 ? void 0 : await this.lockedRow(db, tableObj, identity);
+    return updated ?? this.lockedRow(db, tableObj, where);
+  }
+  /**
+   * Insert a row and read it back by its primary key: the value the caller
+   * gave, or the one MySQL or the model generated, which `$returningId()`
+   * reports and a given value it does not. Undefined when the table has no
+   * primary key to read by.
+   */
+  async insertRow(db, tableObj, data) {
+    const [generated] = await db.insert(tableObj).values(data).$returningId();
+    const given = Object.fromEntries(
+      Object.entries(data).filter(
+        ([, value]) => value !== void 0 && value !== null
+      )
+    );
+    const identity = this.byIdentity(tableObj, { ...generated, ...given });
+    return identity === void 0 ? void 0 : this.lockedRow(db, tableObj, identity);
+  }
+  /**
+   * A row's primary key as a condition, from a record keyed as the model's
+   * properties are. Undefined when the table has no primary key or the record
+   * lacks part of it.
+   */
+  byIdentity(tableObj, record) {
+    const primary = new Set(keysOf(tableObj).primary);
+    const parts = Object.entries(getColumns(tableObj)).filter(
+      ([, column]) => primary.has(column.name)
+    );
+    if (parts.length === 0 || parts.some(
+      ([name]) => record[name] === void 0 || record[name] === null
+    )) {
+      return void 0;
+    }
+    return and(
+      ...parts.map(([name, column]) => eq(column, record[name]))
+    );
+  }
   /** A table-level `primaryKey({ columns })`, read through the MySQL table config. */
   compositePrimaryKey(tableObj) {
     return getTableConfig(
@@ -497,12 +755,13 @@ var MySqlAdapter = class extends DrizzleAdapter {
     ).primaryKeys.flatMap((key) => key.columns);
   }
   createTransactionContext(connection) {
-    const buildTxExecutor = () => drizzle({
-      client: connection.connection
-    });
-    let txExecutor;
-    const txDb = () => txExecutor ??= buildTxExecutor();
+    const txConnection = connection.connection;
+    const txHandles = this.transactionDrizzleHandles(
+      (relations) => relations ? drizzle({ client: txConnection, relations }) : drizzle({ client: txConnection })
+    );
+    const txDb = txHandles.bare;
     return {
+      drizzleWithRelations: txHandles.withRelations,
       execute: async (sql, params = []) => {
         const [rows] = await connection.query(
           sql,
@@ -641,7 +900,7 @@ var MySqlAdapter = class extends DrizzleAdapter {
    */
   classifyError(error, sql) {
     if (isDatabaseError(error)) return error;
-    const mysqlError = error;
+    const mysqlError = this.driverErrorIn(error, (candidate) => typeof candidate.errno === "number");
     const kind = mysqlError.errno && MYSQL_ERROR_CODES[mysqlError.errno] || "unknown";
     let message = mysqlError.message ?? String(error);
     if (sql && kind === "query") {
@@ -656,6 +915,36 @@ var MySqlAdapter = class extends DrizzleAdapter {
     });
   }
 };
+var TABLE_KEYS = /* @__PURE__ */ new WeakMap();
+function keysOf(tableObj) {
+  const cached = TABLE_KEYS.get(tableObj);
+  if (cached) return cached;
+  const config = getTableConfig(tableObj);
+  const primary = [
+    ...config.columns.filter((column) => column.primary),
+    ...config.primaryKeys.flatMap((key) => key.columns)
+  ].map((column) => column.name);
+  const unique = [
+    ...config.columns.filter((column) => column.isUnique && !column.primary).map((column) => ({
+      // Drizzle's own name for an unnamed column-level unique key.
+      name: column.uniqueName ?? `${config.name}_${column.name}_unique`,
+      columns: [column.name]
+    })),
+    ...config.uniqueConstraints.map((constraint) => ({
+      name: constraint.name,
+      columns: constraint.columns.map((column) => column.name)
+    })),
+    ...config.indexes.filter((index) => index.config.unique === true).map((index) => ({
+      name: index.config.name,
+      columns: index.config.columns.map(
+        (column) => column.name
+      )
+    }))
+  ];
+  const keys = { primary, unique };
+  TABLE_KEYS.set(tableObj, keys);
+  return keys;
+}
 function createMySqlAdapter(config) {
   return new MySqlAdapter(config);
 }