@prisma/client-engine-runtime 7.10.0-dev.3 → 7.10.0-dev.31

package/dist/index.js

@@ -145,6 +145,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 i = 0; i < source.length; i += MAX_PUSH_SPREAD_ARGS) {
+    target.push(...source.slice(i, i + MAX_PUSH_SPREAD_ARGS));
+  }
+}
 
 // src/json-protocol.ts
 function normalizeJsonProtocolValues(result) {
@@ -226,10 +236,8 @@ function deserializeTaggedValue({ $type, value }) {
   switch ($type) {
     case "BigInt":
       return BigInt(value);
-    case "Bytes": {
-      const { buffer, byteOffset, byteLength } = Buffer.from(value, "base64");
-      return new Uint8Array(buffer, byteOffset, byteLength);
-    }
+    case "Bytes":
+      return new Uint8Array(Buffer.from(value, "base64"));
     case "DateTime":
       return new Date(value);
     case "Decimal":
@@ -343,6 +351,7 @@ function getErrorCode(err) {
     case "UniqueConstraintViolation":
       return "P2002";
     case "ForeignKeyConstraintViolation":
+    case "RestrictViolation":
       return "P2003";
     case "InvalidInputValue":
       return "P2007";
@@ -415,6 +424,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\`.`;
@@ -1148,8 +1158,9 @@ function renderTemplateSql(fragments, placeholderFormat, params, argTypes) {
     if (fragment.type === "stringChunk") {
       continue;
     }
-    const length = flattenedParams.length;
-    const added = flattenedParams.push(...flattenedFragmentParams(fragment)) - length;
+    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(
@@ -1612,17 +1623,27 @@ var QueryInterpreter = class _QueryInterpreter {
     });
   }
   async run(queryPlan, options) {
-    const { value } = await this.interpretNode(queryPlan, {
-      ...options,
-      generators: this.#generators.snapshot()
-    }).catch((e) => rethrowAsUserFacing(e));
+    const generators = this.#generators.snapshot();
+    const context = { ...options, generators };
+    const purified = purifyQueryPlan(queryPlan, (node) => this.interpretNode(node, context))?.catch(
+      (e) => rethrowAsUserFacing(e)
+    );
+    if (purified) {
+      try {
+        return this.#interpretPureNode(await purified, context.scope, generators).value;
+      } catch (e) {
+        rethrowAsUserFacing(e);
+      }
+    }
+    const { value } = await this.interpretNode(queryPlan, context).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
   async interpretNode(node, context) {
     switch (node.type) {
       case "value": {
         return {
-          value: evaluateArg(node.args, context.scope, context.generators)
+          value: evaluateArg(node.args, context.scope, context.generators),
+          lastInsertId: node.lastInsertId
         };
       }
       case "seq": {
@@ -1632,9 +1653,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return result ?? { value: void 0 };
       }
-      case "get": {
-        return { value: context.scope[node.args.name] };
-      }
       case "let": {
         const nestedScope = Object.create(context.scope);
         for (const binding of node.args.bindings) {
@@ -1643,15 +1661,6 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return this.interpretNode(node.args.expr, { ...context, scope: nestedScope });
       }
-      case "getFirstNonEmpty": {
-        for (const name of node.args.names) {
-          const value = context.scope[name];
-          if (!isEmpty(value)) {
-            return { value };
-          }
-        }
-        return { value: [] };
-      }
       case "concat": {
         const parts = await Promise.all(
           node.args.map((arg) => this.interpretNode(arg, context).then((res) => res.value))
@@ -1698,7 +1707,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;
           }
         }
@@ -1778,9 +1787,6 @@ var QueryInterpreter = class _QueryInterpreter {
           return await this.interpretNode(node.args.else, context);
         }
       }
-      case "unit": {
-        return { value: void 0 };
-      }
       case "diff": {
         const { value: from } = await this.interpretNode(node.args.from, context);
         const { value: to } = await this.interpretNode(node.args.to, context);
@@ -1810,6 +1816,139 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         return { value: record, lastInsertId };
       }
+      default:
+        return this.#interpretPureNode(node, context.scope, context.generators);
+    }
+  }
+  #interpretPureNode(node, scope, generators) {
+    switch (node.type) {
+      case "value": {
+        return { value: evaluateArg(node.args, scope, generators), lastInsertId: node.lastInsertId };
+      }
+      case "seq": {
+        let result;
+        for (const arg of node.args) {
+          result = this.#interpretPureNode(arg, scope, generators);
+        }
+        return result ?? { value: void 0 };
+      }
+      case "get": {
+        return { value: scope[node.args.name] };
+      }
+      case "let": {
+        const nestedScope = Object.create(scope);
+        for (const binding of node.args.bindings) {
+          const { value } = this.#interpretPureNode(binding.expr, nestedScope, generators);
+          nestedScope[binding.name] = value;
+        }
+        return this.#interpretPureNode(node.args.expr, nestedScope, generators);
+      }
+      case "getFirstNonEmpty": {
+        for (const name of node.args.names) {
+          const value = scope[name];
+          if (!isEmpty(value)) {
+            return { value };
+          }
+        }
+        return { value: [] };
+      }
+      case "concat": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : []
+        };
+      }
+      case "sum": {
+        const parts = node.args.map((arg) => this.#interpretPureNode(arg, scope, generators).value);
+        return {
+          value: parts.length > 0 ? parts.reduce((acc, part) => asNumber2(acc) + asNumber2(part)) : 0
+        };
+      }
+      case "reverse": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        return { value: Array.isArray(value) ? value.reverse() : value, lastInsertId };
+      }
+      case "unique": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (!Array.isArray(value)) {
+          return { value, lastInsertId };
+        }
+        if (value.length > 1) {
+          throw new Error(`Expected zero or one element, got ${value.length}`);
+        }
+        return { value: value[0] ?? null, lastInsertId };
+      }
+      case "required": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args, scope, generators);
+        if (isEmpty(value)) {
+          throw new Error("Required value is empty");
+        }
+        return { value, lastInsertId };
+      }
+      case "mapField": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.records, scope, generators);
+        return { value: mapField2(value, node.args.field), lastInsertId };
+      }
+      case "join": {
+        const { value: parent, lastInsertId } = this.#interpretPureNode(node.args.parent, scope, generators);
+        if (parent === null) {
+          return { value: null, lastInsertId };
+        }
+        const children = node.args.children.map((joinExpr) => ({
+          joinExpr,
+          childRecords: this.#interpretPureNode(joinExpr.child, scope, generators).value
+        }));
+        return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
+      }
+      case "dataMap": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        return { value: applyDataMap(value, node.args.structure, node.args.enums), lastInsertId };
+      }
+      case "validate": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        performValidation(value, node.args.rules, node.args);
+        return { value, lastInsertId };
+      }
+      case "if": {
+        const { value } = this.#interpretPureNode(node.args.value, scope, generators);
+        if (doesSatisfyRule(value, node.args.rule)) {
+          return this.#interpretPureNode(node.args.then, scope, generators);
+        } else {
+          return this.#interpretPureNode(node.args.else, scope, generators);
+        }
+      }
+      case "unit": {
+        return { value: void 0 };
+      }
+      case "diff": {
+        const { value: from } = this.#interpretPureNode(node.args.from, scope, generators);
+        const { value: to } = this.#interpretPureNode(node.args.to, scope, generators);
+        const keyGetter = (item) => item !== null ? getRecordKey(asRecord(item), node.args.fields) : null;
+        const toSet = new Set(asList(to).map(keyGetter));
+        return { value: asList(from).filter((item) => !toSet.has(keyGetter(item))) };
+      }
+      case "process": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const ops = cloneObject(node.args.operations);
+        evaluateProcessingParameters(ops, scope, generators);
+        return { value: processRecords(value, ops), lastInsertId };
+      }
+      case "initializeRecord": {
+        const { lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = {};
+        for (const [key, initializer] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldInitializer(initializer, lastInsertId, scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
+      case "mapRecord": {
+        const { value, lastInsertId } = this.#interpretPureNode(node.args.expr, scope, generators);
+        const record = value === null ? {} : asRecord(value);
+        for (const [key, entry] of Object.entries(node.args.fields)) {
+          record[key] = evalFieldOperation(entry, record[key], scope, generators);
+        }
+        return { value: record, lastInsertId };
+      }
       default:
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
@@ -1987,6 +2126,112 @@ function evalFieldOperation(op, value, scope, generators) {
       assertNever(op, `Unexpected field operation type: ${op["type"]}`);
   }
 }
+function purifyQueryPlan(node, evalNode) {
+  const impureNode = findUniqueUnconditionalImpureNode(node);
+  if (!impureNode) {
+    return void 0;
+  }
+  return evalNode(impureNode).then((result) => {
+    const evaluated = {
+      type: "value",
+      args: result.value,
+      lastInsertId: result.lastInsertId
+    };
+    const purified = replaceImpureNode(node, impureNode, evaluated);
+    if (!purified) {
+      throw new Error("Could not substitute the evaluated impure node into the query plan");
+    }
+    return purified;
+  });
+}
+function replaceImpureNode(node, target, replacement) {
+  if (node === target) {
+    return replacement;
+  }
+  switch (node.type) {
+    case "seq":
+    case "sum":
+    case "concat": {
+      for (let i = 0; i < node.args.length; i++) {
+        const child = replaceImpureNode(node.args[i], target, replacement);
+        if (child) {
+          return { ...node, args: node.args.map((arg, j) => j === i ? child : arg) };
+        }
+      }
+      return void 0;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process": {
+      const expr = replaceImpureNode(node.args.expr, target, replacement);
+      return expr && { ...node, args: { ...node.args, expr } };
+    }
+    case "mapField": {
+      const records = replaceImpureNode(node.args.records, target, replacement);
+      return records && { ...node, args: { ...node.args, records } };
+    }
+    case "reverse":
+    case "unique":
+    case "required": {
+      const args = replaceImpureNode(node.args, target, replacement);
+      return args && { ...node, args };
+    }
+    default:
+      return void 0;
+  }
+}
+function findUniqueUnconditionalImpureNode(node) {
+  switch (node.type) {
+    case "query":
+    case "execute":
+      return node;
+    case "seq":
+    case "sum":
+    case "concat": {
+      let found = void 0;
+      for (const child of node.args) {
+        const childFound = findUniqueUnconditionalImpureNode(child);
+        if (childFound === null) {
+          return null;
+        }
+        if (childFound) {
+          if (found) {
+            return null;
+          }
+          found = childFound;
+        }
+      }
+      return found;
+    }
+    case "dataMap":
+    case "validate":
+    case "initializeRecord":
+    case "mapRecord":
+    case "process":
+      return findUniqueUnconditionalImpureNode(node.args.expr);
+    case "mapField":
+      return findUniqueUnconditionalImpureNode(node.args.records);
+    case "reverse":
+    case "unique":
+    case "required":
+      return findUniqueUnconditionalImpureNode(node.args);
+    case "let":
+    case "join":
+    case "diff":
+    case "if":
+    case "transaction":
+      return null;
+    case "value":
+    case "get":
+    case "getFirstNonEmpty":
+    case "unit":
+      return void 0;
+    default:
+      assertNever(node, `Unexpected node type: ${node.type}`);
+  }
+}
 function applyComments(query, sqlCommenter) {
   if (!sqlCommenter || sqlCommenter.plugins.length === 0) {
     return query;
@@ -2553,6 +2798,14 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
 
 // src/transaction-manager/transaction-manager.ts
 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 debug = (0, import_debug.Debug)("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
@@ -2572,6 +2825,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;
@@ -2635,56 +2891,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((e) => debug("error in discarded transaction:", e));
-          await this.#closeTransaction(transaction, "timed_out");
-          throw new TransactionStartTimeoutError();
+    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();
         }
-        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.");
+      }
+    } catch (e) {
+      debug("error in discarded transaction:", e);
     }
   }
   async commitTransaction(transactionId) {
@@ -2775,16 +3066,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++}`;
@@ -2937,6 +3233,14 @@ var TransactionManager = class {
 function createTimeoutIfDefined(cb, ms) {
   return ms !== void 0 ? setTimeout(cb, ms) : void 0;
 }
+function settleWithin(promise, timeout) {
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeout);
+    timer?.unref?.();
+  });
+  return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DataMapperError,