@prisma/query-plan-executor 7.10.0-dev.2 → 7.10.0-dev.21

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.2";
+var version = "7.10.0-dev.21";
 
 // ../../node_modules/.pnpm/temporal-polyfill@0.3.0/node_modules/temporal-polyfill/chunks/internal.js
 function clampProp(e2, n2, t2, o2, r2) {
@@ -101793,6 +101793,16 @@ function safeJsonStringify(obj) {
     return val;
   });
 }
+var MAX_PUSH_SPREAD_ARGS = 8192;
+function appendToArray(target, source) {
+  if (source.length <= MAX_PUSH_SPREAD_ARGS) {
+    target.push(...source);
+    return;
+  }
+  for (let i2 = 0; i2 < source.length; i2 += MAX_PUSH_SPREAD_ARGS) {
+    target.push(...source.slice(i2, i2 + MAX_PUSH_SPREAD_ARGS));
+  }
+}
 function normalizeJsonProtocolValues(result) {
   if (result === null) {
     return result;
@@ -101944,6 +101954,7 @@ function getErrorCode(err) {
     case "UniqueConstraintViolation":
       return "P2002";
     case "ForeignKeyConstraintViolation":
+    case "RestrictViolation":
       return "P2003";
     case "InvalidInputValue":
       return "P2007";
@@ -102016,6 +102027,7 @@ function renderErrorMessage(err) {
     case "UniqueConstraintViolation":
       return `Unique constraint failed on the ${renderConstraint(err.cause.constraint)}`;
     case "ForeignKeyConstraintViolation":
+    case "RestrictViolation":
       return `Foreign key constraint violated on the ${renderConstraint(err.cause.constraint)}`;
     case "UnsupportedNativeDataType":
       return `Failed to deserialize column of type '${err.cause.type}'. If you're using $queryRaw and this column is explicitly marked as \`Unsupported\` in your Prisma schema, try casting this column to any supported Prisma type such as \`String\`.`;
@@ -102656,8 +102668,9 @@ function renderTemplateSql(fragments, placeholderFormat, params, argTypes) {
     if (fragment.type === "stringChunk") {
       continue;
     }
-    const length2 = flattenedParams.length;
-    const added = flattenedParams.push(...flattenedFragmentParams(fragment)) - length2;
+    const fragmentParams = Array.from(flattenedFragmentParams(fragment));
+    const added = fragmentParams.length;
+    appendToArray(flattenedParams, fragmentParams);
     if (fragment.argType.arity === "tuple") {
       if (added % fragment.argType.elements.length !== 0) {
         throw new Error(
@@ -103199,7 +103212,7 @@ var QueryInterpreter = class _QueryInterpreter {
           if (results === void 0) {
             results = result;
           } else {
-            results.rows.push(...result.rows);
+            appendToArray(results.rows, result.rows);
             results.lastInsertId = result.lastInsertId;
           }
         }
@@ -103579,6 +103592,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 +103619,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 +103685,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 +103860,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 +104027,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) => {
@@ -106465,7 +106537,7 @@ var MariaDbTransaction = class extends MariaDbQueryable {
       this.onError(err);
     } finally {
       this.cleanup?.();
-      await this.client.end();
+      await releaseConnection(this.client);
     }
   }
   async rollback() {
@@ -106476,7 +106548,7 @@ var MariaDbTransaction = class extends MariaDbQueryable {
       this.onError(err);
     } finally {
       this.cleanup?.();
-      await this.client.end();
+      await releaseConnection(this.client);
     }
   }
   async createSavepoint(name22) {
@@ -106490,10 +106562,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");
@@ -106517,7 +106590,7 @@ var PrismaMariaDbAdapter = class extends MariaDbQueryable {
     };
     conn.on("error", onError);
     const cleanup = () => {
-      conn.removeListener("error", onError);
+      conn.off("error", onError);
     };
     try {
       const tx = new MariaDbTransaction(conn, this.mariadbOptions, options, cleanup);
@@ -106531,13 +106604,16 @@ var PrismaMariaDbAdapter = class extends MariaDbQueryable {
       await tx.conn.query({ sql: "BEGIN" }).catch(this.onError.bind(this));
       return tx;
     } catch (error44) {
-      await conn.end();
-      cleanup();
+      try {
+        cleanup();
+      } finally {
+        await releaseConnection(conn);
+      }
       this.onError(error44);
     }
   }
   async dispose() {
-    await this.client.end();
+    return this.release?.();
   }
   underlyingDriver() {
     return this.client;
@@ -106547,47 +106623,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 {
@@ -106624,6 +106726,14 @@ function rewriteConnectionString(url2) {
   }
   return url2;
 }
+async function releaseConnection(conn) {
+  const poolConn = conn;
+  if (typeof poolConn.release === "function") {
+    await poolConn.release();
+  } else {
+    await conn.end();
+  }
+}
 
 // ../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
 var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
@@ -108079,6 +108189,18 @@ function mapDriverError3(error44) {
         constraint
       };
     }
+    case "23001": {
+      let constraint;
+      if (error44.column) {
+        constraint = { fields: [error44.column] };
+      } else if (error44.constraint) {
+        constraint = { index: error44.constraint };
+      }
+      return {
+        kind: "RestrictViolation",
+        constraint
+      };
+    }
     case "3D000":
       return {
         kind: "DatabaseDoesNotExist",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/query-plan-executor",
-  "version": "7.10.0-dev.2",
+  "version": "7.10.0-dev.21",
   "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-pg": "7.10.0-dev.2",
-    "@prisma/adapter-mariadb": "7.10.0-dev.2",
-    "@prisma/adapter-mssql": "7.10.0-dev.2",
-    "@prisma/client-engine-runtime": "7.10.0-dev.2",
-    "@prisma/driver-adapter-utils": "7.10.0-dev.2"
+    "@prisma/adapter-pg": "7.10.0-dev.21",
+    "@prisma/adapter-mssql": "7.10.0-dev.21",
+    "@prisma/adapter-mariadb": "7.10.0-dev.21",
+    "@prisma/client-engine-runtime": "7.10.0-dev.21",
+    "@prisma/driver-adapter-utils": "7.10.0-dev.21"
   },
   "files": [
     "dist"