@prisma/client-engine-runtime 7.5.0-dev.9 → 7.6.0-dev.1

package/dist/events.d.ts

@@ -1,6 +1,6 @@
 export type QueryEvent = {
     timestamp: Date;
     query: string;
-    params: unknown[];
+    params: readonly unknown[];
     duration: number;
 };

package/dist/index.d.mts

@@ -80,6 +80,10 @@ export declare type DecimalTaggedValue = {
     value: string;
 };
 
+declare type DeepReadonly<T> = T extends undefined | null | boolean | string | number | symbol | Function | Date ? T : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : unknown extends T ? unknown : {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+
 export declare function deserializeJsonObject(result: unknown): unknown;
 
 /**
@@ -155,6 +159,9 @@ export declare type Fragment = {
     type: 'parameter';
 } | {
     type: 'parameterTuple';
+    itemPrefix: string;
+    itemSeparator: string;
+    itemSuffix: string;
 } | {
     type: 'parameterTupleList';
     itemPrefix: string;
@@ -243,7 +250,7 @@ export declare type PrismaValuePlaceholder = {
 export declare type QueryEvent = {
     timestamp: Date;
     query: string;
-    params: unknown[];
+    params: readonly unknown[];
     duration: number;
 };
 
@@ -256,7 +263,7 @@ export declare class QueryInterpreter {
         provider?: SchemaProvider;
         connectionInfo?: ConnectionInfo;
     }): QueryInterpreter;
-    run(queryPlan: QueryPlanNode, options: QueryRuntimeOptions): Promise<unknown>;
+    run(queryPlan: DeepReadonly<QueryPlanNode>, options: QueryRuntimeOptions): Promise<unknown>;
     private interpretNode;
 }
 
@@ -348,6 +355,7 @@ export declare type QueryPlanNode = {
     args: {
         parent: QueryPlanNode;
         children: JoinExpression[];
+        canAssumeStrictEquality: boolean;
     };
 } | {
     type: 'mapField';
@@ -497,6 +505,7 @@ export declare type TransactionOptions = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
+    newTxId?: string;
 };
 
 export declare class UserFacingError extends Error {
@@ -516,14 +525,14 @@ export declare class UserFacingError extends Error {
 }
 
 export declare type ValidationError = {
-    error_identifier: 'RELATION_VIOLATION';
+    errorIdentifier: 'RELATION_VIOLATION';
     context: {
         relation: string;
         modelA: string;
         modelB: string;
     };
 } | {
-    error_identifier: 'MISSING_RELATED_RECORD';
+    errorIdentifier: 'MISSING_RELATED_RECORD';
     context: {
         model: string;
         relation: string;
@@ -532,24 +541,24 @@ export declare type ValidationError = {
         neededFor?: string;
     };
 } | {
-    error_identifier: 'MISSING_RECORD';
+    errorIdentifier: 'MISSING_RECORD';
     context: {
         operation: string;
     };
 } | {
-    error_identifier: 'INCOMPLETE_CONNECT_INPUT';
+    errorIdentifier: 'INCOMPLETE_CONNECT_INPUT';
     context: {
         expectedRows: number;
     };
 } | {
-    error_identifier: 'INCOMPLETE_CONNECT_OUTPUT';
+    errorIdentifier: 'INCOMPLETE_CONNECT_OUTPUT';
     context: {
         expectedRows: number;
         relation: string;
         relationType: string;
     };
 } | {
-    error_identifier: 'RECORDS_NOT_CONNECTED';
+    errorIdentifier: 'RECORDS_NOT_CONNECTED';
     context: {
         relation: string;
         parent: string;

package/dist/index.d.ts

@@ -80,6 +80,10 @@ export declare type DecimalTaggedValue = {
     value: string;
 };
 
+declare type DeepReadonly<T> = T extends undefined | null | boolean | string | number | symbol | Function | Date ? T : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : unknown extends T ? unknown : {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+
 export declare function deserializeJsonObject(result: unknown): unknown;
 
 /**
@@ -155,6 +159,9 @@ export declare type Fragment = {
     type: 'parameter';
 } | {
     type: 'parameterTuple';
+    itemPrefix: string;
+    itemSeparator: string;
+    itemSuffix: string;
 } | {
     type: 'parameterTupleList';
     itemPrefix: string;
@@ -243,7 +250,7 @@ export declare type PrismaValuePlaceholder = {
 export declare type QueryEvent = {
     timestamp: Date;
     query: string;
-    params: unknown[];
+    params: readonly unknown[];
     duration: number;
 };
 
@@ -256,7 +263,7 @@ export declare class QueryInterpreter {
         provider?: SchemaProvider;
         connectionInfo?: ConnectionInfo;
     }): QueryInterpreter;
-    run(queryPlan: QueryPlanNode, options: QueryRuntimeOptions): Promise<unknown>;
+    run(queryPlan: DeepReadonly<QueryPlanNode>, options: QueryRuntimeOptions): Promise<unknown>;
     private interpretNode;
 }
 
@@ -348,6 +355,7 @@ export declare type QueryPlanNode = {
     args: {
         parent: QueryPlanNode;
         children: JoinExpression[];
+        canAssumeStrictEquality: boolean;
     };
 } | {
     type: 'mapField';
@@ -497,6 +505,7 @@ export declare type TransactionOptions = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
+    newTxId?: string;
 };
 
 export declare class UserFacingError extends Error {
@@ -516,14 +525,14 @@ export declare class UserFacingError extends Error {
 }
 
 export declare type ValidationError = {
-    error_identifier: 'RELATION_VIOLATION';
+    errorIdentifier: 'RELATION_VIOLATION';
     context: {
         relation: string;
         modelA: string;
         modelB: string;
     };
 } | {
-    error_identifier: 'MISSING_RELATED_RECORD';
+    errorIdentifier: 'MISSING_RELATED_RECORD';
     context: {
         model: string;
         relation: string;
@@ -532,24 +541,24 @@ export declare type ValidationError = {
         neededFor?: string;
     };
 } | {
-    error_identifier: 'MISSING_RECORD';
+    errorIdentifier: 'MISSING_RECORD';
     context: {
         operation: string;
     };
 } | {
-    error_identifier: 'INCOMPLETE_CONNECT_INPUT';
+    errorIdentifier: 'INCOMPLETE_CONNECT_INPUT';
     context: {
         expectedRows: number;
     };
 } | {
-    error_identifier: 'INCOMPLETE_CONNECT_OUTPUT';
+    errorIdentifier: 'INCOMPLETE_CONNECT_OUTPUT';
     context: {
         expectedRows: number;
         relation: string;
         relationType: string;
     };
 } | {
-    error_identifier: 'RECORDS_NOT_CONNECTED';
+    errorIdentifier: 'RECORDS_NOT_CONNECTED';
     context: {
         relation: string;
         parent: string;

package/dist/index.js

@@ -757,6 +757,9 @@ function normalizeDateTime(dt) {
   return dtWithTz;
 }
 
+// src/interpreter/query-interpreter.ts
+var import_klona2 = require("klona");
+
 // src/sql-commenter.ts
 var import_klona = require("klona");
 function formatSqlComment(tags) {
@@ -893,8 +896,11 @@ var GeneratorRegistry = class {
   }
 };
 var NowGenerator = class {
-  #now = /* @__PURE__ */ new Date();
+  #now;
   generate() {
+    if (this.#now === void 0) {
+      this.#now = /* @__PURE__ */ new Date();
+    }
     return this.#now.toISOString();
   }
 };
@@ -1040,8 +1046,11 @@ function paginateSingleList(list, { cursor, skip, take }) {
   const end = take !== null ? start + take : list.length;
   return list.slice(start, end);
 }
-function getRecordKey(record, fields) {
-  return JSON.stringify(fields.map((field) => record[field]));
+function getRecordKey(record, fields, mappers) {
+  const array = fields.map(
+    (field, index) => mappers?.[index] ? record[field] !== null ? mappers[index](record[field]) : null : record[field]
+  );
+  return JSON.stringify(array);
 }
 
 // src/query-plan.ts
@@ -1078,7 +1087,11 @@ function evaluateArg(arg, scope, generators) {
       if (found === void 0) {
         throw new Error(`Missing value for query variable ${arg.prisma__value.name}`);
       }
-      arg = found;
+      if (arg.prisma__value.type === "DateTime" && typeof found === "string") {
+        arg = new Date(found);
+      } else {
+        arg = found;
+      }
     } else if (isPrismaValueGenerator(arg)) {
       const { name, args } = arg.prisma__value;
       const generator = generators[name];
@@ -1136,7 +1149,10 @@ function renderFragment(fragment, placeholderFormat, ctx) {
     case "stringChunk":
       return fragment.chunk;
     case "parameterTuple": {
-      const placeholders = fragment.value.length == 0 ? "NULL" : fragment.value.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(",");
+      const placeholders = fragment.value.length == 0 ? "NULL" : fragment.value.map(() => {
+        const item = formatPlaceholder(placeholderFormat, ctx.placeholderNumber++);
+        return `${fragment.itemPrefix}${item}${fragment.itemSuffix}`;
+      }).join(fragment.itemSeparator);
       return `(${placeholders})`;
     }
     case "parameterTupleList": {
@@ -1495,7 +1511,7 @@ function doesSatisfyRule(data, rule) {
   }
 }
 function renderMessage(data, error) {
-  switch (error.error_identifier) {
+  switch (error.errorIdentifier) {
     case "RELATION_VIOLATION":
       return `The change you are trying to make would violate the required relation '${error.context.relation}' between the \`${error.context.modelA}\` and \`${error.context.modelB}\` models.`;
     case "MISSING_RECORD":
@@ -1515,7 +1531,7 @@ function renderMessage(data, error) {
   }
 }
 function getErrorCode2(error) {
-  switch (error.error_identifier) {
+  switch (error.errorIdentifier) {
     case "RELATION_VIOLATION":
       return "P2014";
     case "RECORDS_NOT_CONNECTED":
@@ -1630,7 +1646,7 @@ var QueryInterpreter = class _QueryInterpreter {
           sum += await this.#withQuerySpanAndEvent(
             commentedQuery,
             context.queryable,
-            () => context.queryable.executeRaw(commentedQuery).catch(
+            () => context.queryable.executeRaw(cloneObject(commentedQuery)).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1645,7 +1661,7 @@ var QueryInterpreter = class _QueryInterpreter {
           const result = await this.#withQuerySpanAndEvent(
             commentedQuery,
             context.queryable,
-            () => context.queryable.queryRaw(commentedQuery).catch(
+            () => context.queryable.queryRaw(cloneObject(commentedQuery)).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1697,7 +1713,7 @@ var QueryInterpreter = class _QueryInterpreter {
             childRecords: (await this.interpretNode(joinExpr.child, context)).value
           }))
         );
-        return { value: attachChildrenToParents(parent, children), lastInsertId };
+        return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
       }
       case "transaction": {
         if (!context.transactionManager.enabled) {
@@ -1744,8 +1760,9 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "process": {
         const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
-        evaluateProcessingParameters(node.args.operations, context.scope, context.generators);
-        return { value: processRecords(value, node.args.operations), lastInsertId };
+        const ops = cloneObject(node.args.operations);
+        evaluateProcessingParameters(ops, context.scope, context.generators);
+        return { value: processRecords(value, ops), lastInsertId };
       }
       case "initializeRecord": {
         const { lastInsertId } = await this.interpretNode(node.args.expr, context);
@@ -1838,12 +1855,13 @@ function mapField2(value, field) {
   }
   return value;
 }
-function attachChildrenToParents(parentRecords, children) {
+function attachChildrenToParents(parentRecords, children, canAssumeStrictEquality) {
   for (const { joinExpr, childRecords } of children) {
     const parentKeys = joinExpr.on.map(([k]) => k);
     const childKeys = joinExpr.on.map(([, k]) => k);
     const parentMap = {};
-    for (const parent of Array.isArray(parentRecords) ? parentRecords : [parentRecords]) {
+    const parentArray = Array.isArray(parentRecords) ? parentRecords : [parentRecords];
+    for (const parent of parentArray) {
       const parentRecord = asRecord(parent);
       const key = getRecordKey(parentRecord, parentKeys);
       if (!parentMap[key]) {
@@ -1856,11 +1874,12 @@ function attachChildrenToParents(parentRecords, children) {
         parentRecord[joinExpr.parentField] = [];
       }
     }
+    const mappers = canAssumeStrictEquality ? void 0 : inferKeyCasts(parentArray, parentKeys);
     for (const childRecord of Array.isArray(childRecords) ? childRecords : [childRecords]) {
       if (childRecord === null) {
         continue;
       }
-      const key = getRecordKey(asRecord(childRecord), childKeys);
+      const key = getRecordKey(asRecord(childRecord), childKeys, mappers);
       for (const parentRecord of parentMap[key] ?? []) {
         if (joinExpr.isRelationUnique) {
           parentRecord[joinExpr.parentField] = childRecord;
@@ -1872,6 +1891,40 @@ function attachChildrenToParents(parentRecords, children) {
   }
   return parentRecords;
 }
+function inferKeyCasts(rows, keys) {
+  function getKeyCast(type) {
+    switch (type) {
+      case "number":
+        return Number;
+      case "string":
+        return String;
+      case "boolean":
+        return Boolean;
+      case "bigint":
+        return BigInt;
+      default:
+        return;
+    }
+  }
+  const keyCasts = Array.from({ length: keys.length });
+  let keysFound = 0;
+  for (const parent of rows) {
+    const parentRecord = asRecord(parent);
+    for (const [i, key] of keys.entries()) {
+      if (parentRecord[key] !== null && keyCasts[i] === void 0) {
+        const keyCast = getKeyCast(typeof parentRecord[key]);
+        if (keyCast !== void 0) {
+          keyCasts[i] = keyCast;
+        }
+        keysFound++;
+      }
+    }
+    if (keysFound === keys.length) {
+      break;
+    }
+  }
+  return keyCasts;
+}
 function evalFieldInitializer(initializer, lastInsertId, scope, generators) {
   switch (initializer.type) {
     case "value":
@@ -1931,6 +1984,9 @@ function evaluateProcessingParameters(ops, scope, generators) {
     evaluateProcessingParameters(nested, scope, generators);
   }
 }
+function cloneObject(value) {
+  return (0, import_klona2.klona)(value);
+}
 
 // src/raw-json-protocol.ts
 var import_client_runtime_utils4 = require("@prisma/client-runtime-utils");
@@ -2087,13 +2143,42 @@ var TransactionManager = class {
     );
   }
   async #startTransactionImpl(options) {
+    if (options.newTxId) {
+      return await this.#withActiveTransactionLock(options.newTxId, "start", async (existing) => {
+        if (existing.status !== "running") {
+          throw new TransactionInternalConsistencyError(
+            `Transaction in invalid state ${existing.status} when starting a nested transaction.`
+          );
+        }
+        if (!existing.transaction) {
+          throw new TransactionInternalConsistencyError(
+            `Transaction missing underlying driver transaction when starting a nested transaction.`
+          );
+        }
+        existing.depth += 1;
+        const savepointName = this.#nextSavepointName(existing);
+        existing.savepoints.push(savepointName);
+        try {
+          await this.#requiredCreateSavepoint(existing.transaction)(savepointName);
+        } catch (e) {
+          existing.depth -= 1;
+          existing.savepoints.pop();
+          throw e;
+        }
+        return { id: existing.id };
+      });
+    }
     const transaction = {
       id: await randomUUID(),
       status: "waiting",
       timer: void 0,
       timeout: options.timeout,
       startedAt: Date.now(),
-      transaction: void 0
+      transaction: void 0,
+      operationQueue: Promise.resolve(),
+      depth: 1,
+      savepoints: [],
+      savepointCounter: 0
     };
     const abortController = new AbortController();
     const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
@@ -2127,14 +2212,49 @@ var TransactionManager = class {
   }
   async commitTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "commit");
-      await this.#closeTransaction(txw, "committed");
+      await this.#withActiveTransactionLock(transactionId, "commit", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested commit. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "committed");
+      });
     });
   }
   async rollbackTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "rollback");
-      await this.#closeTransaction(txw, "rolled_back");
+      await this.#withActiveTransactionLock(transactionId, "rollback", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested rollback. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#requiredRollbackToSavepoint(txw.transaction)(savepointName);
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "rolled_back");
+      });
     });
   }
   async getTransaction(txInfo, operation) {
@@ -2178,22 +2298,90 @@ var TransactionManager = class {
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled([...this.transactions.values()].map((tx) => this.#closeTransaction(tx, "rolled_back")));
+    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");
+          }
+        })
+      )
+    );
+  }
+  #nextSavepointName(transaction) {
+    return `prisma_sp_${transaction.savepointCounter++}`;
+  }
+  #requiredCreateSavepoint(transaction) {
+    if (transaction.createSavepoint) {
+      return transaction.createSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): createSavepoint is not implemented.`
+    );
+  }
+  #requiredRollbackToSavepoint(transaction) {
+    if (transaction.rollbackToSavepoint) {
+      return transaction.rollbackToSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): rollbackToSavepoint is not implemented.`
+    );
+  }
+  async #releaseSavepoint(transaction, name) {
+    if (transaction.releaseSavepoint) {
+      await transaction.releaseSavepoint(name);
+    }
+  }
+  #debugTransactionAlreadyClosedOnTimeout(transactionId) {
+    debug("Transaction already committed or rolled back when timeout happened.", transactionId);
   }
   #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     const timer = createTimeoutIfDefined(async () => {
       debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
       const tx = this.transactions.get(transactionId);
-      if (tx && ["running", "waiting"].includes(tx.status)) {
-        await this.#closeTransaction(tx, "timed_out");
-      } else {
-        debug("Transaction already committed or rolled back when timeout happened.", transactionId);
-      }
+      if (!tx) {
+        this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        return;
+      }
+      await this.#runSerialized(tx, async () => {
+        const current = this.transactions.get(transactionId);
+        if (current && ["running", "waiting"].includes(current.status)) {
+          await this.#closeTransaction(current, "timed_out");
+        } else {
+          this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        }
+      });
     }, timeout);
     timer?.unref?.();
     return timer;
   }
+  // Any operation that mutates or closes a transaction must run through this lock so
+  // status/savepoint/depth checks and updates happen against a stable view of state.
+  async #withActiveTransactionLock(transactionId, operation, callback) {
+    const tx = this.#getActiveOrClosingTransaction(transactionId, operation);
+    return await this.#runSerialized(tx, async () => {
+      const current = this.#getActiveOrClosingTransaction(transactionId, operation);
+      return await callback(current);
+    });
+  }
+  // Serializes operations per transaction id to prevent interleaving across awaits.
+  // This avoids races where one operation mutates savepoint/depth state while another
+  // operation is suspended, which could otherwise corrupt cleanup logic.
+  async #runSerialized(tx, callback) {
+    const previousOperation = tx.operationQueue;
+    let releaseOperationLock;
+    tx.operationQueue = new Promise((resolve) => {
+      releaseOperationLock = resolve;
+    });
+    await previousOperation;
+    try {
+      return await callback();
+    } finally {
+      releaseOperationLock();
+    }
+  }
   async #closeTransaction(tx, status) {
     const createClosingPromise = async () => {
       debug("Closing transaction.", { transactionId: tx.id, status });

package/dist/index.mjs

@@ -706,6 +706,9 @@ function normalizeDateTime(dt) {
   return dtWithTz;
 }
 
+// src/interpreter/query-interpreter.ts
+import { klona as klona2 } from "klona";
+
 // src/sql-commenter.ts
 import { klona } from "klona";
 function formatSqlComment(tags) {
@@ -842,8 +845,11 @@ var GeneratorRegistry = class {
   }
 };
 var NowGenerator = class {
-  #now = /* @__PURE__ */ new Date();
+  #now;
   generate() {
+    if (this.#now === void 0) {
+      this.#now = /* @__PURE__ */ new Date();
+    }
     return this.#now.toISOString();
   }
 };
@@ -989,8 +995,11 @@ function paginateSingleList(list, { cursor, skip, take }) {
   const end = take !== null ? start + take : list.length;
   return list.slice(start, end);
 }
-function getRecordKey(record, fields) {
-  return JSON.stringify(fields.map((field) => record[field]));
+function getRecordKey(record, fields, mappers) {
+  const array = fields.map(
+    (field, index) => mappers?.[index] ? record[field] !== null ? mappers[index](record[field]) : null : record[field]
+  );
+  return JSON.stringify(array);
 }
 
 // src/query-plan.ts
@@ -1027,7 +1036,11 @@ function evaluateArg(arg, scope, generators) {
       if (found === void 0) {
         throw new Error(`Missing value for query variable ${arg.prisma__value.name}`);
       }
-      arg = found;
+      if (arg.prisma__value.type === "DateTime" && typeof found === "string") {
+        arg = new Date(found);
+      } else {
+        arg = found;
+      }
     } else if (isPrismaValueGenerator(arg)) {
       const { name, args } = arg.prisma__value;
       const generator = generators[name];
@@ -1085,7 +1098,10 @@ function renderFragment(fragment, placeholderFormat, ctx) {
     case "stringChunk":
       return fragment.chunk;
     case "parameterTuple": {
-      const placeholders = fragment.value.length == 0 ? "NULL" : fragment.value.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(",");
+      const placeholders = fragment.value.length == 0 ? "NULL" : fragment.value.map(() => {
+        const item = formatPlaceholder(placeholderFormat, ctx.placeholderNumber++);
+        return `${fragment.itemPrefix}${item}${fragment.itemSuffix}`;
+      }).join(fragment.itemSeparator);
       return `(${placeholders})`;
     }
     case "parameterTupleList": {
@@ -1444,7 +1460,7 @@ function doesSatisfyRule(data, rule) {
   }
 }
 function renderMessage(data, error) {
-  switch (error.error_identifier) {
+  switch (error.errorIdentifier) {
     case "RELATION_VIOLATION":
       return `The change you are trying to make would violate the required relation '${error.context.relation}' between the \`${error.context.modelA}\` and \`${error.context.modelB}\` models.`;
     case "MISSING_RECORD":
@@ -1464,7 +1480,7 @@ function renderMessage(data, error) {
   }
 }
 function getErrorCode2(error) {
-  switch (error.error_identifier) {
+  switch (error.errorIdentifier) {
     case "RELATION_VIOLATION":
       return "P2014";
     case "RECORDS_NOT_CONNECTED":
@@ -1579,7 +1595,7 @@ var QueryInterpreter = class _QueryInterpreter {
           sum += await this.#withQuerySpanAndEvent(
             commentedQuery,
             context.queryable,
-            () => context.queryable.executeRaw(commentedQuery).catch(
+            () => context.queryable.executeRaw(cloneObject(commentedQuery)).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1594,7 +1610,7 @@ var QueryInterpreter = class _QueryInterpreter {
           const result = await this.#withQuerySpanAndEvent(
             commentedQuery,
             context.queryable,
-            () => context.queryable.queryRaw(commentedQuery).catch(
+            () => context.queryable.queryRaw(cloneObject(commentedQuery)).catch(
               (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
             )
           );
@@ -1646,7 +1662,7 @@ var QueryInterpreter = class _QueryInterpreter {
             childRecords: (await this.interpretNode(joinExpr.child, context)).value
           }))
         );
-        return { value: attachChildrenToParents(parent, children), lastInsertId };
+        return { value: attachChildrenToParents(parent, children, node.args.canAssumeStrictEquality), lastInsertId };
       }
       case "transaction": {
         if (!context.transactionManager.enabled) {
@@ -1693,8 +1709,9 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "process": {
         const { value, lastInsertId } = await this.interpretNode(node.args.expr, context);
-        evaluateProcessingParameters(node.args.operations, context.scope, context.generators);
-        return { value: processRecords(value, node.args.operations), lastInsertId };
+        const ops = cloneObject(node.args.operations);
+        evaluateProcessingParameters(ops, context.scope, context.generators);
+        return { value: processRecords(value, ops), lastInsertId };
       }
       case "initializeRecord": {
         const { lastInsertId } = await this.interpretNode(node.args.expr, context);
@@ -1787,12 +1804,13 @@ function mapField2(value, field) {
   }
   return value;
 }
-function attachChildrenToParents(parentRecords, children) {
+function attachChildrenToParents(parentRecords, children, canAssumeStrictEquality) {
   for (const { joinExpr, childRecords } of children) {
     const parentKeys = joinExpr.on.map(([k]) => k);
     const childKeys = joinExpr.on.map(([, k]) => k);
     const parentMap = {};
-    for (const parent of Array.isArray(parentRecords) ? parentRecords : [parentRecords]) {
+    const parentArray = Array.isArray(parentRecords) ? parentRecords : [parentRecords];
+    for (const parent of parentArray) {
       const parentRecord = asRecord(parent);
       const key = getRecordKey(parentRecord, parentKeys);
       if (!parentMap[key]) {
@@ -1805,11 +1823,12 @@ function attachChildrenToParents(parentRecords, children) {
         parentRecord[joinExpr.parentField] = [];
       }
     }
+    const mappers = canAssumeStrictEquality ? void 0 : inferKeyCasts(parentArray, parentKeys);
     for (const childRecord of Array.isArray(childRecords) ? childRecords : [childRecords]) {
       if (childRecord === null) {
         continue;
       }
-      const key = getRecordKey(asRecord(childRecord), childKeys);
+      const key = getRecordKey(asRecord(childRecord), childKeys, mappers);
       for (const parentRecord of parentMap[key] ?? []) {
         if (joinExpr.isRelationUnique) {
           parentRecord[joinExpr.parentField] = childRecord;
@@ -1821,6 +1840,40 @@ function attachChildrenToParents(parentRecords, children) {
   }
   return parentRecords;
 }
+function inferKeyCasts(rows, keys) {
+  function getKeyCast(type) {
+    switch (type) {
+      case "number":
+        return Number;
+      case "string":
+        return String;
+      case "boolean":
+        return Boolean;
+      case "bigint":
+        return BigInt;
+      default:
+        return;
+    }
+  }
+  const keyCasts = Array.from({ length: keys.length });
+  let keysFound = 0;
+  for (const parent of rows) {
+    const parentRecord = asRecord(parent);
+    for (const [i, key] of keys.entries()) {
+      if (parentRecord[key] !== null && keyCasts[i] === void 0) {
+        const keyCast = getKeyCast(typeof parentRecord[key]);
+        if (keyCast !== void 0) {
+          keyCasts[i] = keyCast;
+        }
+        keysFound++;
+      }
+    }
+    if (keysFound === keys.length) {
+      break;
+    }
+  }
+  return keyCasts;
+}
 function evalFieldInitializer(initializer, lastInsertId, scope, generators) {
   switch (initializer.type) {
     case "value":
@@ -1880,6 +1933,9 @@ function evaluateProcessingParameters(ops, scope, generators) {
     evaluateProcessingParameters(nested, scope, generators);
   }
 }
+function cloneObject(value) {
+  return klona2(value);
+}
 
 // src/raw-json-protocol.ts
 import { Decimal as Decimal4 } from "@prisma/client-runtime-utils";
@@ -2036,13 +2092,42 @@ var TransactionManager = class {
     );
   }
   async #startTransactionImpl(options) {
+    if (options.newTxId) {
+      return await this.#withActiveTransactionLock(options.newTxId, "start", async (existing) => {
+        if (existing.status !== "running") {
+          throw new TransactionInternalConsistencyError(
+            `Transaction in invalid state ${existing.status} when starting a nested transaction.`
+          );
+        }
+        if (!existing.transaction) {
+          throw new TransactionInternalConsistencyError(
+            `Transaction missing underlying driver transaction when starting a nested transaction.`
+          );
+        }
+        existing.depth += 1;
+        const savepointName = this.#nextSavepointName(existing);
+        existing.savepoints.push(savepointName);
+        try {
+          await this.#requiredCreateSavepoint(existing.transaction)(savepointName);
+        } catch (e) {
+          existing.depth -= 1;
+          existing.savepoints.pop();
+          throw e;
+        }
+        return { id: existing.id };
+      });
+    }
     const transaction = {
       id: await randomUUID(),
       status: "waiting",
       timer: void 0,
       timeout: options.timeout,
       startedAt: Date.now(),
-      transaction: void 0
+      transaction: void 0,
+      operationQueue: Promise.resolve(),
+      depth: 1,
+      savepoints: [],
+      savepointCounter: 0
     };
     const abortController = new AbortController();
     const startTimer = createTimeoutIfDefined(() => abortController.abort(), options.maxWait);
@@ -2076,14 +2161,49 @@ var TransactionManager = class {
   }
   async commitTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "commit");
-      await this.#closeTransaction(txw, "committed");
+      await this.#withActiveTransactionLock(transactionId, "commit", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested commit. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "committed");
+      });
     });
   }
   async rollbackTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
-      const txw = this.#getActiveOrClosingTransaction(transactionId, "rollback");
-      await this.#closeTransaction(txw, "rolled_back");
+      await this.#withActiveTransactionLock(transactionId, "rollback", async (txw) => {
+        if (txw.depth > 1) {
+          if (!txw.transaction) throw new TransactionNotFoundError();
+          const savepointName = txw.savepoints.at(-1);
+          if (!savepointName) {
+            throw new TransactionInternalConsistencyError(
+              `Missing savepoint for nested rollback. Depth: ${txw.depth}, transactionId: ${txw.id}`
+            );
+          }
+          try {
+            await this.#requiredRollbackToSavepoint(txw.transaction)(savepointName);
+            await this.#releaseSavepoint(txw.transaction, savepointName);
+          } finally {
+            txw.savepoints.pop();
+            txw.depth -= 1;
+          }
+          return;
+        }
+        await this.#closeTransaction(txw, "rolled_back");
+      });
     });
   }
   async getTransaction(txInfo, operation) {
@@ -2127,22 +2247,90 @@ var TransactionManager = class {
     return transaction;
   }
   async cancelAllTransactions() {
-    await Promise.allSettled([...this.transactions.values()].map((tx) => this.#closeTransaction(tx, "rolled_back")));
+    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");
+          }
+        })
+      )
+    );
+  }
+  #nextSavepointName(transaction) {
+    return `prisma_sp_${transaction.savepointCounter++}`;
+  }
+  #requiredCreateSavepoint(transaction) {
+    if (transaction.createSavepoint) {
+      return transaction.createSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): createSavepoint is not implemented.`
+    );
+  }
+  #requiredRollbackToSavepoint(transaction) {
+    if (transaction.rollbackToSavepoint) {
+      return transaction.rollbackToSavepoint.bind(transaction);
+    }
+    throw new TransactionManagerError(
+      `Nested transactions are not supported by adapter "${transaction.adapterName}" (${transaction.provider}): rollbackToSavepoint is not implemented.`
+    );
+  }
+  async #releaseSavepoint(transaction, name) {
+    if (transaction.releaseSavepoint) {
+      await transaction.releaseSavepoint(name);
+    }
+  }
+  #debugTransactionAlreadyClosedOnTimeout(transactionId) {
+    debug("Transaction already committed or rolled back when timeout happened.", transactionId);
   }
   #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     const timer = createTimeoutIfDefined(async () => {
       debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
       const tx = this.transactions.get(transactionId);
-      if (tx && ["running", "waiting"].includes(tx.status)) {
-        await this.#closeTransaction(tx, "timed_out");
-      } else {
-        debug("Transaction already committed or rolled back when timeout happened.", transactionId);
-      }
+      if (!tx) {
+        this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        return;
+      }
+      await this.#runSerialized(tx, async () => {
+        const current = this.transactions.get(transactionId);
+        if (current && ["running", "waiting"].includes(current.status)) {
+          await this.#closeTransaction(current, "timed_out");
+        } else {
+          this.#debugTransactionAlreadyClosedOnTimeout(transactionId);
+        }
+      });
     }, timeout);
     timer?.unref?.();
     return timer;
   }
+  // Any operation that mutates or closes a transaction must run through this lock so
+  // status/savepoint/depth checks and updates happen against a stable view of state.
+  async #withActiveTransactionLock(transactionId, operation, callback) {
+    const tx = this.#getActiveOrClosingTransaction(transactionId, operation);
+    return await this.#runSerialized(tx, async () => {
+      const current = this.#getActiveOrClosingTransaction(transactionId, operation);
+      return await callback(current);
+    });
+  }
+  // Serializes operations per transaction id to prevent interleaving across awaits.
+  // This avoids races where one operation mutates savepoint/depth state while another
+  // operation is suspended, which could otherwise corrupt cleanup logic.
+  async #runSerialized(tx, callback) {
+    const previousOperation = tx.operationQueue;
+    let releaseOperationLock;
+    tx.operationQueue = new Promise((resolve) => {
+      releaseOperationLock = resolve;
+    });
+    await previousOperation;
+    try {
+      return await callback();
+    } finally {
+      releaseOperationLock();
+    }
+  }
   async #closeTransaction(tx, status) {
     const createClosingPromise = async () => {
       debug("Closing transaction.", { transactionId: tx.id, status });

package/dist/interpreter/in-memory-processing.d.ts

@@ -1,3 +1,3 @@
 import { InMemoryOps } from '../query-plan';
 export declare function processRecords(value: unknown, ops: InMemoryOps): unknown;
-export declare function getRecordKey(record: {}, fields: string[]): string;
+export declare function getRecordKey(record: {}, fields: readonly string[], mappers?: ((value: unknown) => unknown)[]): string;

package/dist/interpreter/query-interpreter.d.ts

@@ -5,6 +5,7 @@ import { QueryPlanNode } from '../query-plan';
 import { type SchemaProvider } from '../schema';
 import { type TracingHelper } from '../tracing';
 import { type TransactionManager } from '../transaction-manager/transaction-manager';
+import { DeepReadonly } from '../utils';
 import { Value } from './scope';
 export type QueryInterpreterTransactionManager = {
     enabled: true;
@@ -39,6 +40,6 @@ export declare class QueryInterpreter {
         provider?: SchemaProvider;
         connectionInfo?: ConnectionInfo;
     }): QueryInterpreter;
-    run(queryPlan: QueryPlanNode, options: QueryRuntimeOptions): Promise<unknown>;
+    run(queryPlan: DeepReadonly<QueryPlanNode>, options: QueryRuntimeOptions): Promise<unknown>;
     private interpretNode;
 }

package/dist/interpreter/render-query.d.ts

@@ -1,6 +1,7 @@
 import { SqlQuery } from '@prisma/driver-adapter-utils';
 import { type QueryPlanDbQuery } from '../query-plan';
+import { DeepReadonly } from '../utils';
 import { GeneratorRegistrySnapshot } from './generators';
 import { ScopeBindings } from './scope';
-export declare function renderQuery(dbQuery: QueryPlanDbQuery, scope: ScopeBindings, generators: GeneratorRegistrySnapshot, maxChunkSize?: number): SqlQuery[];
+export declare function renderQuery(dbQuery: DeepReadonly<QueryPlanDbQuery>, scope: ScopeBindings, generators: GeneratorRegistrySnapshot, maxChunkSize?: number): DeepReadonly<SqlQuery>[];
 export declare function evaluateArg(arg: unknown, scope: ScopeBindings, generators: GeneratorRegistrySnapshot): unknown;

package/dist/interpreter/validation.d.ts

@@ -1,3 +1,4 @@
 import { DataRule, ValidationError } from '../query-plan';
-export declare function performValidation(data: unknown, rules: DataRule[], error: ValidationError): void;
+import { DeepReadonly } from '../utils';
+export declare function performValidation(data: unknown, rules: DeepReadonly<DataRule[]>, error: ValidationError): void;
 export declare function doesSatisfyRule(data: unknown, rule: DataRule): boolean;

package/dist/query-plan.d.ts

@@ -56,6 +56,9 @@ export type Fragment = {
     type: 'parameter';
 } | {
     type: 'parameterTuple';
+    itemPrefix: string;
+    itemSeparator: string;
+    itemSuffix: string;
 } | {
     type: 'parameterTupleList';
     itemPrefix: string;
@@ -121,6 +124,7 @@ export type QueryPlanNode = {
     args: {
         parent: QueryPlanNode;
         children: JoinExpression[];
+        canAssumeStrictEquality: boolean;
     };
 } | {
     type: 'mapField';
@@ -227,14 +231,14 @@ export type DataRule = {
     type: 'never';
 };
 export type ValidationError = {
-    error_identifier: 'RELATION_VIOLATION';
+    errorIdentifier: 'RELATION_VIOLATION';
     context: {
         relation: string;
         modelA: string;
         modelB: string;
     };
 } | {
-    error_identifier: 'MISSING_RELATED_RECORD';
+    errorIdentifier: 'MISSING_RELATED_RECORD';
     context: {
         model: string;
         relation: string;
@@ -243,24 +247,24 @@ export type ValidationError = {
         neededFor?: string;
     };
 } | {
-    error_identifier: 'MISSING_RECORD';
+    errorIdentifier: 'MISSING_RECORD';
     context: {
         operation: string;
     };
 } | {
-    error_identifier: 'INCOMPLETE_CONNECT_INPUT';
+    errorIdentifier: 'INCOMPLETE_CONNECT_INPUT';
     context: {
         expectedRows: number;
     };
 } | {
-    error_identifier: 'INCOMPLETE_CONNECT_OUTPUT';
+    errorIdentifier: 'INCOMPLETE_CONNECT_OUTPUT';
     context: {
         expectedRows: number;
         relation: string;
         relationType: string;
     };
 } | {
-    error_identifier: 'RECORDS_NOT_CONNECTED';
+    errorIdentifier: 'RECORDS_NOT_CONNECTED';
     context: {
         relation: string;
         parent: string;

package/dist/tracing.d.ts

@@ -2,6 +2,7 @@ import { type Context, type Span, type SpanOptions } from '@opentelemetry/api';
 import type { SqlQuery } from '@prisma/driver-adapter-utils';
 import { QueryEvent } from './events';
 import type { SchemaProvider } from './schema';
+import { DeepReadonly } from './utils';
 export type SpanCallback<R> = (span?: Span, context?: Context) => R;
 export type ExtendedSpanOptions = SpanOptions & {
     name: string;
@@ -13,7 +14,7 @@ export interface TracingHelper {
 export declare const noopTracingHelper: TracingHelper;
 export declare function providerToOtelSystem(provider: SchemaProvider): string;
 export declare function withQuerySpanAndEvent<T>({ query, tracingHelper, provider, onQuery, execute, }: {
-    query: SqlQuery;
+    query: DeepReadonly<SqlQuery>;
     tracingHelper: TracingHelper;
     provider: SchemaProvider;
     onQuery?: (event: QueryEvent) => void;

package/dist/transaction-manager/transaction.d.ts

@@ -3,6 +3,7 @@ export type Options = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
+    newTxId?: string;
 };
 export type TransactionInfo = {
     id: string;

package/dist/utils.d.ts

@@ -1,3 +1,9 @@
+export type DeepReadonly<T> = T extends undefined | null | boolean | string | number | symbol | Function | Date ? T : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : unknown extends T ? unknown : {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+export type DeepUnreadonly<T> = T extends undefined | null | boolean | string | number | symbol | Function | Date ? T : T extends ReadonlyArray<infer U> ? Array<DeepUnreadonly<U>> : unknown extends T ? unknown : {
+    -readonly [K in keyof T]: DeepUnreadonly<T[K]>;
+};
 export declare function assertNever(_: never, message: string): never;
 /**
  * Checks if two objects are deeply equal, recursively checking all properties for strict equality.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "7.5.0-dev.9",
+  "version": "7.6.0-dev.1",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,19 +31,16 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/client-runtime-utils": "7.5.0-dev.9",
-    "@prisma/debug": "7.5.0-dev.9",
-    "@prisma/driver-adapter-utils": "7.5.0-dev.9",
-    "@prisma/sqlcommenter": "7.5.0-dev.9"
+    "@prisma/client-runtime-utils": "7.6.0-dev.1",
+    "@prisma/debug": "7.6.0-dev.1",
+    "@prisma/driver-adapter-utils": "7.6.0-dev.1",
+    "@prisma/sqlcommenter": "7.6.0-dev.1"
   },
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",
     "@types/benchmark": "2.1.5",
-    "@types/jest": "29.5.14",
     "@types/node": "~20.19.24",
-    "benchmark": "2.1.4",
-    "jest": "29.7.0",
-    "jest-junit": "16.0.0"
+    "benchmark": "2.1.4"
   },
   "files": [
     "dist"
@@ -52,6 +49,6 @@
   "scripts": {
     "dev": "DEV=true tsx helpers/build.ts",
     "build": "tsx helpers/build.ts",
-    "test": "jest"
+    "test": "vitest run"
   }
 }