@prisma/query-plan-executor 7.10.0-dev.1 → 7.10.0-dev.11

package/dist/index.js

@@ -22009,7 +22009,7 @@ var require_promise = __commonJS({
         return Promise.reject(err);
       }
     };
-    module2.exports.createPool = function createPool2(opts) {
+    module2.exports.createPool = function createPool3(opts) {
       const options = new PoolOptions(opts);
       const pool2 = new PoolPromise(options);
       pool2.on("error", (err) => {
@@ -93473,7 +93473,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "7.10.0-dev.1";
+var version = "7.10.0-dev.11";
 
 // ../../node_modules/.pnpm/temporal-polyfill@0.3.0/node_modules/temporal-polyfill/chunks/internal.js
 function clampProp(e2, n2, t2, o2, r2) {
@@ -103579,6 +103579,14 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
   }
 };
 var MAX_CLOSED_TRANSACTIONS = 100;
+var CANCEL_ROLLBACK_GRACE_MS = 2e3;
+function trackStartingTransaction() {
+  let markSettled;
+  const settled = new Promise((resolve) => {
+    markSettled = resolve;
+  });
+  return { abortController: new AbortController(), settled, markSettled };
+}
 var debug3 = Debug("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
@@ -103598,6 +103606,9 @@ var TransactionManager = class {
   // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
   // Used to provide better error messages than a generic "transaction not found".
   closedTransactions = [];
+  // Transactions that are still being started. Tracked separately so that
+  // `cancelAllTransactions` can reach them: they are not in `transactions` yet.
+  #startingTransactions = /* @__PURE__ */ new Set();
   driverAdapter;
   transactionOptions;
   tracingHelper;
@@ -103661,56 +103672,91 @@ var TransactionManager = class {
         return { id: existing.id };
       });
     }
-    const transaction = {
-      id: await randomUUID(),
-      status: "waiting",
-      timer: void 0,
-      timeout: options.timeout,
-      startedAt: Date.now(),
-      transaction: void 0,
-      operationQueue: Promise.resolve(),
-      depth: 1,
-      savepoints: [],
-      savepointCounter: 0
-    };
-    const abortController = new AbortController();
-    const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
-    startTimer?.unref?.();
-    const startTransactionPromise = this.driverAdapter.startTransaction(options.isolationLevel).catch(rethrowAsUserFacing);
-    transaction.transaction = await Promise.race([
-      startTransactionPromise.finally(() => clearTimeout(startTimer)),
-      once(abortController.signal, "abort").then(() => void 0)
-    ]);
-    this.transactions.set(transaction.id, transaction);
-    switch (transaction.status) {
-      case "waiting":
-        if (abortController.signal.aborted) {
-          void startTransactionPromise.then(async (tx) => {
-            if (tx.options.usePhantomQuery) {
-              await tx.rollback();
-            } else {
-              try {
-                await tx.executeRaw(ROLLBACK_QUERY());
-              } finally {
-                await tx.rollback();
-              }
-            }
-          }).catch((e2) => debug3("error in discarded transaction:", e2));
-          await this.#closeTransaction(transaction, "timed_out");
-          throw new TransactionStartTimeoutError();
-        }
-        transaction.status = "running";
-        transaction.timer = this.#startTransactionTimeout(transaction.id, options.timeout);
-        return { id: transaction.id };
-      case "timed_out":
-      case "running":
-      case "committed":
-      case "rolled_back":
-        throw new TransactionInternalConsistencyError(
-          `Transaction in invalid state ${transaction.status} although it just finished startup.`
-        );
-      default:
-        assertNever(transaction["status"], "Unknown transaction status.");
+    const starting = trackStartingTransaction();
+    const { abortController } = starting;
+    this.#startingTransactions.add(starting);
+    let discarding;
+    try {
+      const transaction = {
+        id: await randomUUID(),
+        status: "waiting",
+        timer: void 0,
+        timeout: options.timeout,
+        startedAt: Date.now(),
+        transaction: void 0,
+        operationQueue: Promise.resolve(),
+        depth: 1,
+        savepoints: [],
+        savepointCounter: 0
+      };
+      if (abortController.signal.aborted) {
+        throw new TransactionStartTimeoutError();
+      }
+      const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
+      startTimer?.unref?.();
+      const startTransactionPromise = this.driverAdapter.startTransaction(options.isolationLevel).catch(rethrowAsUserFacing);
+      transaction.transaction = await Promise.race([
+        startTransactionPromise.finally(() => clearTimeout(startTimer)),
+        once(abortController.signal, "abort").then(() => void 0)
+      ]);
+      this.transactions.set(transaction.id, transaction);
+      switch (transaction.status) {
+        case "waiting":
+          if (abortController.signal.aborted) {
+            transaction.transaction = void 0;
+            discarding = this.#discardStartedTransaction(startTransactionPromise);
+            await this.#closeTransaction(transaction, "timed_out");
+            throw new TransactionStartTimeoutError();
+          }
+          transaction.status = "running";
+          transaction.startedAt = Date.now();
+          transaction.timer = this.#startTransactionTimeout(transaction.id, options.timeout);
+          return { id: transaction.id };
+        case "timed_out":
+        case "running":
+        case "committed":
+        case "rolled_back":
+          throw new TransactionInternalConsistencyError(
+            `Transaction in invalid state ${transaction.status} although it just finished startup.`
+          );
+        default:
+          return assertNever(transaction["status"], "Unknown transaction status.");
+      }
+    } finally {
+      this.#startingTransactions.delete(starting);
+      if (discarding) {
+        void discarding.finally(starting.markSettled);
+      } else {
+        starting.markSettled();
+      }
+    }
+  }
+  /**
+   * Rolls back a transaction whose start was abandoned, and releases its connection.
+   *
+   * The `startTransaction` promise may still be running in the background. If it eventually
+   * succeeds, we need to roll back and release the connection to avoid leaking it and
+   * exhausting the connection pool. For adapters that don't use phantom queries (e.g. pg/neon),
+   * `rollback()` only releases the connection without sending SQL, so we send an explicit
+   * ROLLBACK first; otherwise the connection returns to the pool mid-transaction because
+   * `BEGIN` already ran on the wire during startup.
+   *
+   * Errors are only logged: the caller has already reported the failure that led here.
+   */
+  async #discardStartedTransaction(startTransactionPromise) {
+    try {
+      const tx = await startTransactionPromise;
+      if (tx.options.usePhantomQuery) {
+        await tx.rollback();
+      } else {
+        try {
+          await tx.executeRaw(ROLLBACK_QUERY());
+        } finally {
+          await tx.rollback();
+        }
+      }
+    } catch (e2) {
+      debug3("error in discarded transaction:", e2);
     }
   }
   async commitTransaction(transactionId) {
@@ -103801,16 +103847,21 @@ var TransactionManager = class {
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled(
-      [...this.transactions.values()].map(
+    const starting = [...this.#startingTransactions];
+    for (const { abortController } of starting) {
+      abortController.abort();
+    }
+    await Promise.allSettled([
+      ...[...this.transactions.values()].map(
         (tx) => this.#runSerialized(tx, async () => {
           const current = this.transactions.get(tx.id);
           if (current) {
             await this.#closeTransaction(current, "rolled_back");
           }
         })
-      )
-    );
+      ),
+      ...starting.map(({ settled }) => settleWithin(settled, CANCEL_ROLLBACK_GRACE_MS))
+    ]);
   }
   #nextSavepointName(transaction) {
     return `prisma_sp_${transaction.savepointCounter++}`;
@@ -103963,6 +104014,14 @@ var TransactionManager = class {
 function createTimeoutIfDefined(cb, ms) {
   return ms !== void 0 ? setTimeout(cb, ms) : void 0;
 }
+function settleWithin(promise2, timeout) {
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeout);
+    timer?.unref?.();
+  });
+  return Promise.race([promise2, deadline]).finally(() => clearTimeout(timer));
+}
 
 // ../../node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -106490,10 +106549,11 @@ var MariaDbTransaction = class extends MariaDbQueryable {
   }
 };
 var PrismaMariaDbAdapter = class extends MariaDbQueryable {
-  constructor(client, capabilities, mariadbOptions) {
+  constructor(client, capabilities, mariadbOptions, release) {
     super(client, mariadbOptions);
     this.capabilities = capabilities;
     this.mariadbOptions = mariadbOptions;
+    this.release = release;
   }
   executeScript(_script) {
     throw new Error("Not implemented yet");
@@ -106537,7 +106597,7 @@ var PrismaMariaDbAdapter = class extends MariaDbQueryable {
     }
   }
   async dispose() {
-    await this.client.end();
+    return this.release?.();
   }
   underlyingDriver() {
     return this.client;
@@ -106547,47 +106607,73 @@ var PrismaMariaDbAdapterFactory = class {
   provider = "mysql";
   adapterName = name;
   #capabilities;
-  #config;
+  #poolOrConfig;
   #options;
-  constructor(config3, options) {
-    if (typeof config3 === "string") {
-      try {
-        const url2 = new URL(config3);
-        if (!url2.searchParams.has("prepareCacheLength")) {
-          url2.searchParams.set("prepareCacheLength", "0");
-        }
-        this.#config = rewriteConnectionString(url2).toString();
-      } catch (error44) {
-        debug4("Error parsing connection string: %O", error44);
-        this.#config = config3;
-      }
-    } else {
-      if (config3.prepareCacheLength === void 0) {
-        this.#config = { ...config3, prepareCacheLength: 0 };
-      } else {
-        this.#config = config3;
-      }
-    }
+  #externalPoolClaimed = false;
+  /**
+   * Accepts either connection settings for a pool the adapter creates and owns, or an existing
+   * pool. Settings the adapter would normally apply to its own pool (such as defaulting
+   * `prepareCacheLength` to 0) are not applied to an externally created pool.
+   */
+  constructor(poolOrConfig, options) {
+    this.#poolOrConfig = isPool(poolOrConfig) ? { type: "pool", pool: poolOrConfig } : { type: "config", config: normalizeConfig(poolOrConfig) };
     this.#options = options;
   }
   async connect() {
-    let pool2;
-    try {
-      pool2 = mariadb.createPool(this.#config);
-    } catch (error44) {
-      if (error44 instanceof Error && error44.message.startsWith("error parsing connection string")) {
+    const poolOrConfig = this.#poolOrConfig;
+    const ownsPool = poolOrConfig.type === "config" || this.#options?.disposeExternalPool === true;
+    if (poolOrConfig.type === "pool" && ownsPool) {
+      if (this.#externalPoolClaimed) {
         throw new Error(
-          "error parsing connection string, format must be 'mariadb://[<user>[:<password>]@]<host>[:<port>]/[<db>[?<opt1>=<value1>[&<opt2>=<value2>]]]'"
+          "connect() can only be called once when `disposeExternalPool` is true, because the adapter ends the pool it was given and cannot create a replacement from it. Either pass connection settings instead of a pool, or set `disposeExternalPool: false` and end the pool yourself once you no longer need the adapter."
         );
       }
-      throw error44;
+      this.#externalPoolClaimed = true;
     }
+    const pool2 = poolOrConfig.type === "pool" ? poolOrConfig.pool : createPool2(poolOrConfig.config);
     if (this.#capabilities === void 0) {
       this.#capabilities = await getCapabilities(pool2);
     }
-    return new PrismaMariaDbAdapter(pool2, this.#capabilities, this.#options);
+    return new PrismaMariaDbAdapter(pool2, this.#capabilities, this.#options, async () => {
+      if (ownsPool) {
+        await pool2.end();
+      }
+    });
   }
 };
+function isPool(poolOrConfig) {
+  return typeof poolOrConfig === "object" && typeof poolOrConfig.getConnection === "function";
+}
+function normalizeConfig(config3) {
+  if (typeof config3 === "string") {
+    try {
+      const url2 = new URL(config3);
+      if (!url2.searchParams.has("prepareCacheLength")) {
+        url2.searchParams.set("prepareCacheLength", "0");
+      }
+      return rewriteConnectionString(url2).toString();
+    } catch {
+      debug4("Failed to parse the connection string, passing it to the driver as-is");
+      return config3;
+    }
+  }
+  if (config3.prepareCacheLength === void 0) {
+    return { ...config3, prepareCacheLength: 0 };
+  }
+  return config3;
+}
+function createPool2(config3) {
+  try {
+    return mariadb.createPool(config3);
+  } catch (error44) {
+    if (error44 instanceof Error && error44.message.startsWith("error parsing connection string")) {
+      throw new Error(
+        "error parsing connection string, format must be 'mariadb://[<user>[:<password>]@]<host>[:<port>]/[<db>[?<opt1>=<value1>[&<opt2>=<value2>]]]'"
+      );
+    }
+    throw error44;
+  }
+}
 async function getCapabilities(pool2) {
   const tag2 = "[js::getCapabilities]";
   try {
@@ -106619,6 +106705,9 @@ function rewriteConnectionString(url2) {
   if (url2.protocol === "mysql:") {
     url2.protocol = "mariadb:";
   }
+  if (url2.hostname.startsWith("[") && url2.hostname.endsWith("]")) {
+    url2.hostname = encodeURIComponent(url2.hostname.slice(1, -1));
+  }
   return url2;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/query-plan-executor",
-  "version": "7.10.0-dev.1",
+  "version": "7.10.0-dev.11",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,11 +19,11 @@
     "hono": "^4.12.23",
     "temporal-polyfill": "0.3.0",
     "zod": "4.1.3",
-    "@prisma/adapter-mariadb": "7.10.0-dev.1",
-    "@prisma/adapter-pg": "7.10.0-dev.1",
-    "@prisma/client-engine-runtime": "7.10.0-dev.1",
-    "@prisma/driver-adapter-utils": "7.10.0-dev.1",
-    "@prisma/adapter-mssql": "7.10.0-dev.1"
+    "@prisma/adapter-pg": "7.10.0-dev.11",
+    "@prisma/client-engine-runtime": "7.10.0-dev.11",
+    "@prisma/adapter-mssql": "7.10.0-dev.11",
+    "@prisma/adapter-mariadb": "7.10.0-dev.11",
+    "@prisma/driver-adapter-utils": "7.10.0-dev.11"
   },
   "files": [
     "dist"