@prisma/client-engine-runtime 6.15.0-dev.2 → 6.15.0-dev.20

package/dist/index.js

@@ -39,8 +39,6 @@ __export(index_exports, {
   deserializeJsonResponse: () => deserializeJsonResponse,
   doKeysMatch: () => doKeysMatch,
   isDeepStrictEqual: () => isDeepStrictEqual,
-  isPrismaValueBigInt: () => isPrismaValueBigInt,
-  isPrismaValueBytes: () => isPrismaValueBytes,
   isPrismaValueGenerator: () => isPrismaValueGenerator,
   isPrismaValuePlaceholder: () => isPrismaValuePlaceholder,
   noopTracingHelper: () => noopTracingHelper,
@@ -172,7 +170,7 @@ function normalizeTaggedValue({ $type, value }) {
     case "BigInt":
       return { $type, value: String(value) };
     case "Bytes":
-      return { $type, value };
+      return { $type, value: Buffer.from(value, "base64").toString("base64") };
     case "DateTime":
       return { $type, value: new Date(value).toISOString() };
     case "Decimal":
@@ -447,15 +445,15 @@ var DataMapperError = class extends Error {
 };
 function applyDataMap(data, structure, enums) {
   switch (structure.type) {
-    case "AffectedRows":
+    case "affectedRows":
       if (typeof data !== "number") {
         throw new DataMapperError(`Expected an affected rows count, got: ${typeof data} (${data})`);
       }
       return { count: data };
-    case "Object":
+    case "object":
       return mapArrayOrObject(data, structure.fields, enums, structure.skipNulls);
-    case "Value":
-      return mapValue(data, "<result>", structure.resultType, enums);
+    case "field":
+      return mapValue(data, "<result>", structure.fieldType, enums);
     default:
       assertNever(structure, `Invalid data mapping type: '${structure.type}'`);
   }
@@ -493,10 +491,10 @@ function mapObject(data, fields, enums) {
   const result = {};
   for (const [name, node] of Object.entries(fields)) {
     switch (node.type) {
-      case "AffectedRows": {
+      case "affectedRows": {
         throw new DataMapperError(`Unexpected 'AffectedRows' node in data mapping for field '${name}'`);
       }
-      case "Object": {
+      case "object": {
         if (node.serializedName !== null && !Object.hasOwn(data, node.serializedName)) {
           throw new DataMapperError(
             `Missing data field (Object): '${name}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
@@ -506,11 +504,11 @@ function mapObject(data, fields, enums) {
         result[name] = mapArrayOrObject(target, node.fields, enums, node.skipNulls);
         break;
       }
-      case "Value":
+      case "field":
         {
           const dbName = node.dbName;
           if (Object.hasOwn(data, dbName)) {
-            result[name] = mapValue(data[dbName], dbName, node.resultType, enums);
+            result[name] = mapField(data[dbName], dbName, node.fieldType, enums);
           } else {
             throw new DataMapperError(
               `Missing data field (Value): '${dbName}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
@@ -524,20 +522,27 @@ function mapObject(data, fields, enums) {
   }
   return result;
 }
-function mapValue(value, columnName, resultType, enums) {
+function mapField(value, columnName, fieldType, enums) {
   if (value === null) {
-    return resultType.type === "Array" ? [] : null;
+    return fieldType.arity === "list" ? [] : null;
   }
-  switch (resultType.type) {
-    case "Any":
+  if (fieldType.arity === "list") {
+    const values = value;
+    return values.map((v, i) => mapValue(v, `${columnName}[${i}]`, fieldType, enums));
+  }
+  return mapValue(value, columnName, fieldType, enums);
+}
+function mapValue(value, columnName, scalarType, enums) {
+  switch (scalarType.type) {
+    case "unsupported":
       return value;
-    case "String": {
+    case "string": {
       if (typeof value !== "string") {
         throw new DataMapperError(`Expected a string in column '${columnName}', got ${typeof value}: ${value}`);
       }
       return value;
     }
-    case "Int": {
+    case "int": {
       switch (typeof value) {
         case "number": {
           return Math.trunc(value);
@@ -558,13 +563,13 @@ function mapValue(value, columnName, resultType, enums) {
           throw new DataMapperError(`Expected an integer in column '${columnName}', got ${typeof value}: ${value}`);
       }
     }
-    case "BigInt": {
+    case "bigint": {
       if (typeof value !== "number" && typeof value !== "string") {
         throw new DataMapperError(`Expected a bigint in column '${columnName}', got ${typeof value}: ${value}`);
       }
       return { $type: "BigInt", value };
     }
-    case "Float": {
+    case "float": {
       if (typeof value === "number") return value;
       if (typeof value === "string") {
         const parsedValue = Number(value);
@@ -575,7 +580,7 @@ function mapValue(value, columnName, resultType, enums) {
       }
       throw new DataMapperError(`Expected a float in column '${columnName}', got ${typeof value}: ${value}`);
     }
-    case "Boolean": {
+    case "boolean": {
       if (typeof value === "boolean") return value;
       if (typeof value === "number") return value === 1;
       if (typeof value === "string") {
@@ -587,7 +592,7 @@ function mapValue(value, columnName, resultType, enums) {
           throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
         }
       }
-      if (value instanceof Uint8Array) {
+      if (Array.isArray(value)) {
         for (const byte of value) {
           if (byte !== 0) return true;
         }
@@ -595,73 +600,87 @@ function mapValue(value, columnName, resultType, enums) {
       }
       throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
     }
-    case "Decimal":
+    case "decimal":
       if (typeof value !== "number" && typeof value !== "string" && !import_decimal3.default.isDecimal(value)) {
         throw new DataMapperError(`Expected a decimal in column '${columnName}', got ${typeof value}: ${value}`);
       }
       return { $type: "Decimal", value };
-    case "Date": {
+    case "datetime": {
       if (typeof value === "string") {
-        return { $type: "DateTime", value: ensureTimezoneInIsoString(value) };
+        return { $type: "DateTime", value: normalizeDateTime(value) };
       }
       if (typeof value === "number" || value instanceof Date) {
         return { $type: "DateTime", value };
       }
       throw new DataMapperError(`Expected a date in column '${columnName}', got ${typeof value}: ${value}`);
     }
-    case "Time": {
-      if (typeof value === "string") {
-        return { $type: "DateTime", value: `1970-01-01T${ensureTimezoneInIsoString(value)}` };
-      }
-      throw new DataMapperError(`Expected a time in column '${columnName}', got ${typeof value}: ${value}`);
-    }
-    case "Array": {
-      const values = value;
-      return values.map((v, i) => mapValue(v, `${columnName}[${i}]`, resultType.inner, enums));
-    }
-    case "Object": {
+    case "object": {
       return { $type: "Json", value: safeJsonStringify(value) };
     }
-    case "Json": {
+    case "json": {
       return { $type: "Json", value: `${value}` };
     }
-    case "Bytes": {
-      if (typeof value === "string" && value.startsWith("\\x")) {
-        return { $type: "Bytes", value: Buffer.from(value.slice(2), "hex").toString("base64") };
-      }
-      if (Array.isArray(value)) {
-        return { $type: "Bytes", value: Buffer.from(value).toString("base64") };
-      }
-      if (value instanceof Uint8Array) {
-        return { $type: "Bytes", value: Buffer.from(value).toString("base64") };
+    case "bytes": {
+      switch (scalarType.encoding) {
+        case "base64":
+          if (typeof value !== "string") {
+            throw new DataMapperError(
+              `Expected a base64-encoded byte array in column '${columnName}', got ${typeof value}: ${value}`
+            );
+          }
+          return { $type: "Bytes", value };
+        case "hex":
+          if (typeof value !== "string" || !value.startsWith("\\x")) {
+            throw new DataMapperError(
+              `Expected a hex-encoded byte array in column '${columnName}', got ${typeof value}: ${value}`
+            );
+          }
+          return { $type: "Bytes", value: Buffer.from(value.slice(2), "hex").toString("base64") };
+        case "array":
+          if (Array.isArray(value)) {
+            return { $type: "Bytes", value: Buffer.from(value).toString("base64") };
+          }
+          if (value instanceof Uint8Array) {
+            return { $type: "Bytes", value: Buffer.from(value).toString("base64") };
+          }
+          throw new DataMapperError(`Expected a byte array in column '${columnName}', got ${typeof value}: ${value}`);
+        default:
+          assertNever(scalarType.encoding, `DataMapper: Unknown bytes encoding: ${scalarType.encoding}`);
       }
-      throw new DataMapperError(`Expected a byte array in column '${columnName}', got ${typeof value}: ${value}`);
+      break;
     }
-    case "Enum": {
-      const enumDef = enums[resultType.inner];
+    case "enum": {
+      const enumDef = enums[scalarType.name];
       if (enumDef === void 0) {
-        throw new DataMapperError(`Unknown enum '${resultType.inner}'`);
+        throw new DataMapperError(`Unknown enum '${scalarType.name}'`);
       }
       const enumValue = enumDef[`${value}`];
       if (enumValue === void 0) {
-        throw new DataMapperError(`Value '${value}' not found in enum '${resultType.inner}'`);
+        throw new DataMapperError(`Value '${value}' not found in enum '${scalarType.name}'`);
       }
       return enumValue;
     }
     default:
-      assertNever(resultType, `DataMapper: Unknown result type: ${resultType.type}`);
+      assertNever(scalarType, `DataMapper: Unknown result type: ${scalarType["type"]}`);
   }
 }
-var TIMEZONE_PATTERN = /Z$|(?<!\d{4}-\d{2})[+-]\d{2}(:?\d{2})?$/;
-function ensureTimezoneInIsoString(dt) {
-  const results = TIMEZONE_PATTERN.exec(dt);
-  if (results === null) {
+var TIME_TZ_PATTERN = /\d{2}:\d{2}:\d{2}(?:\.\d+)?(Z|[+-]\d{2}(:?\d{2})?)?$/;
+function normalizeDateTime(dt) {
+  const matches = TIME_TZ_PATTERN.exec(dt);
+  if (matches === null) {
     return `${dt}Z`;
-  } else if (results[0] !== "Z" && results[1] === void 0) {
-    return `${dt}:00`;
-  } else {
-    return dt;
   }
+  let dtWithTz = dt;
+  const [timeTz, tz, tzMinuteOffset] = matches;
+  if (tz !== void 0 && tz !== "Z" && tzMinuteOffset === void 0) {
+    dtWithTz = `${dt}:00`;
+  } else if (tz === void 0) {
+    dtWithTz = `${dt}Z`;
+  }
+  if (timeTz.length === dt.length) {
+    return `1970-01-01T${dtWithTz}`;
+  }
+  return dtWithTz;
 }
 
 // src/tracing.ts
@@ -740,10 +759,10 @@ var GeneratorRegistry = class {
    * method being called, meaning that the built-in time-based generators will always return
    * the same value on repeated calls as long as the same snapshot is used.
    */
-  snapshot(provider) {
+  snapshot() {
     return Object.create(this.#generators, {
       now: {
-        value: provider === "mysql" ? new MysqlNowGenerator() : new NowGenerator()
+        value: new NowGenerator()
       }
     });
   }
@@ -760,12 +779,6 @@ var NowGenerator = class {
     return this.#now.toISOString();
   }
 };
-var MysqlNowGenerator = class {
-  #now = /* @__PURE__ */ new Date();
-  generate() {
-    return this.#now.toISOString().replace("T", " ").replace("Z", "");
-  }
-};
 var UuidGenerator = class {
   generate(arg) {
     if (arg === 4) {
@@ -919,74 +932,82 @@ function isPrismaValuePlaceholder(value) {
 function isPrismaValueGenerator(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "generatorCall";
 }
-function isPrismaValueBytes(value) {
-  return typeof value === "object" && value !== null && value["prisma__type"] === "bytes";
-}
-function isPrismaValueBigInt(value) {
-  return typeof value === "object" && value !== null && value["prisma__type"] === "bigint";
-}
 
 // src/interpreter/render-query.ts
 function renderQuery(dbQuery, scope, generators, maxChunkSize) {
-  const queryType = dbQuery.type;
-  const params = evaluateParams(dbQuery.params, scope, generators);
-  switch (queryType) {
+  const args = dbQuery.args.map((arg) => evaluateArg(arg, scope, generators));
+  switch (dbQuery.type) {
     case "rawSql":
-      return [renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators))];
+      return [renderRawSql(dbQuery.sql, args, dbQuery.argTypes)];
     case "templateSql": {
-      const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, params, maxChunkSize) : [params];
-      return chunks.map((params2) => {
-        if (maxChunkSize !== void 0 && params2.length > maxChunkSize) {
+      const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, args, maxChunkSize) : [args];
+      return chunks.map((params) => {
+        if (maxChunkSize !== void 0 && params.length > maxChunkSize) {
           throw new UserFacingError("The query parameter limit supported by your database is exceeded.", "P2029");
         }
-        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params2);
+        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params, dbQuery.argTypes);
       });
     }
     default:
-      assertNever(queryType, `Invalid query type`);
+      assertNever(dbQuery["type"], `Invalid query type`);
   }
 }
-function evaluateParams(params, scope, generators) {
-  return params.map((param) => evaluateParam(param, scope, generators));
-}
-function evaluateParam(param, scope, generators) {
-  let value = param;
-  while (doesRequireEvaluation(value)) {
-    if (isPrismaValuePlaceholder(value)) {
-      const found = scope[value.prisma__value.name];
+function evaluateArg(arg, scope, generators) {
+  while (doesRequireEvaluation(arg)) {
+    if (isPrismaValuePlaceholder(arg)) {
+      const found = scope[arg.prisma__value.name];
       if (found === void 0) {
-        throw new Error(`Missing value for query variable ${value.prisma__value.name}`);
+        throw new Error(`Missing value for query variable ${arg.prisma__value.name}`);
       }
-      value = found;
-    } else if (isPrismaValueGenerator(value)) {
-      const { name, args } = value.prisma__value;
+      arg = found;
+    } else if (isPrismaValueGenerator(arg)) {
+      const { name, args } = arg.prisma__value;
       const generator = generators[name];
       if (!generator) {
         throw new Error(`Encountered an unknown generator '${name}'`);
       }
-      value = generator.generate(...args.map((arg) => evaluateParam(arg, scope, generators)));
+      arg = generator.generate(...args.map((arg2) => evaluateArg(arg2, scope, generators)));
     } else {
-      assertNever(value, `Unexpected unevaluated value type: ${value}`);
+      assertNever(arg, `Unexpected unevaluated value type: ${arg}`);
     }
   }
-  if (Array.isArray(value)) {
-    value = value.map((el) => evaluateParam(el, scope, generators));
-  } else if (isPrismaValueBytes(value)) {
-    value = Buffer.from(value.prisma__value, "base64");
-  } else if (isPrismaValueBigInt(value)) {
-    value = BigInt(value.prisma__value);
+  if (Array.isArray(arg)) {
+    arg = arg.map((el) => evaluateArg(el, scope, generators));
   }
-  return value;
+  return arg;
 }
-function renderTemplateSql(fragments, placeholderFormat, params) {
+function renderTemplateSql(fragments, placeholderFormat, params, argTypes) {
   let sql = "";
   const ctx = { placeholderNumber: 1 };
   const flattenedParams = [];
-  for (const fragment of pairFragmentsWithParams(fragments, params)) {
-    flattenedParams.push(...flattenedFragmentParams(fragment));
+  const flattenedArgTypes = [];
+  for (const fragment of pairFragmentsWithParams(fragments, params, argTypes)) {
     sql += renderFragment(fragment, placeholderFormat, ctx);
+    if (fragment.type === "stringChunk") {
+      continue;
+    }
+    const length = flattenedParams.length;
+    const added = flattenedParams.push(...flattenedFragmentParams(fragment)) - length;
+    if (fragment.argType.arity === "tuple") {
+      if (added % fragment.argType.elements.length !== 0) {
+        throw new Error(
+          `Malformed query template. Expected the number of parameters to match the tuple arity, but got ${added} parameters for a tuple of arity ${fragment.argType.elements.length}.`
+        );
+      }
+      for (let i = 0; i < added / fragment.argType.elements.length; i++) {
+        flattenedArgTypes.push(...fragment.argType.elements);
+      }
+    } else {
+      for (let i = 0; i < added; i++) {
+        flattenedArgTypes.push(fragment.argType);
+      }
+    }
   }
-  return renderRawSql(sql, flattenedParams);
+  return {
+    sql,
+    args: flattenedParams,
+    argTypes: flattenedArgTypes
+  };
 }
 function renderFragment(fragment, placeholderFormat, ctx) {
   const fragmentType = fragment.type;
@@ -1012,36 +1033,17 @@ function renderFragment(fragment, placeholderFormat, ctx) {
 function formatPlaceholder(placeholderFormat, placeholderNumber) {
   return placeholderFormat.hasNumbering ? `${placeholderFormat.prefix}${placeholderNumber}` : placeholderFormat.prefix;
 }
-function renderRawSql(sql, params) {
-  const argTypes = params.map((param) => toArgType(param));
+function renderRawSql(sql, args, argTypes) {
   return {
     sql,
-    args: params,
+    args,
     argTypes
   };
 }
-function toArgType(value) {
-  if (typeof value === "string") {
-    return "Text";
-  }
-  if (typeof value === "number") {
-    return "Numeric";
-  }
-  if (typeof value === "boolean") {
-    return "Boolean";
-  }
-  if (Array.isArray(value)) {
-    return "Array";
-  }
-  if (Buffer.isBuffer(value)) {
-    return "Bytes";
-  }
-  return "Unknown";
-}
 function doesRequireEvaluation(param) {
   return isPrismaValuePlaceholder(param) || isPrismaValueGenerator(param);
 }
-function* pairFragmentsWithParams(fragments, params) {
+function* pairFragmentsWithParams(fragments, params, argTypes) {
   let index = 0;
   for (const fragment of fragments) {
     switch (fragment.type) {
@@ -1049,7 +1051,8 @@ function* pairFragmentsWithParams(fragments, params) {
         if (index >= params.length) {
           throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
         }
-        yield { ...fragment, value: params[index++] };
+        yield { ...fragment, value: params[index], argType: argTypes?.[index] };
+        index++;
         break;
       }
       case "stringChunk": {
@@ -1060,15 +1063,16 @@ function* pairFragmentsWithParams(fragments, params) {
         if (index >= params.length) {
           throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
         }
-        const value = params[index++];
-        yield { ...fragment, value: Array.isArray(value) ? value : [value] };
+        const value = params[index];
+        yield { ...fragment, value: Array.isArray(value) ? value : [value], argType: argTypes?.[index] };
+        index++;
         break;
       }
       case "parameterTupleList": {
         if (index >= params.length) {
           throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
         }
-        const value = params[index++];
+        const value = params[index];
         if (!Array.isArray(value)) {
           throw new Error(`Malformed query template. Tuple list expected.`);
         }
@@ -1080,7 +1084,8 @@ function* pairFragmentsWithParams(fragments, params) {
             throw new Error(`Malformed query template. Tuple expected.`);
           }
         }
-        yield { ...fragment, value };
+        yield { ...fragment, value, argType: argTypes?.[index] };
+        index++;
         break;
       }
     }
@@ -1106,7 +1111,7 @@ function* flattenedFragmentParams(fragment) {
 function chunkParams(fragments, params, maxChunkSize) {
   let totalParamCount = 0;
   let maxParamsPerFragment = 0;
-  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+  for (const fragment of pairFragmentsWithParams(fragments, params, void 0)) {
     let paramSize = 0;
     for (const _ of flattenedFragmentParams(fragment)) {
       void _;
@@ -1116,7 +1121,7 @@ function chunkParams(fragments, params, maxChunkSize) {
     totalParamCount += paramSize;
   }
   let chunkedParams = [[]];
-  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+  for (const fragment of pairFragmentsWithParams(fragments, params, void 0)) {
     switch (fragment.type) {
       case "parameter": {
         for (const params2 of chunkedParams) {
@@ -1182,16 +1187,8 @@ function chunkArray(array, chunkSize) {
 // src/interpreter/serialize-sql.ts
 var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
 function serializeSql(resultSet) {
-  const mappers = resultSet.columnTypes.map((type) => {
-    switch (type) {
-      case import_driver_adapter_utils2.ColumnTypeEnum.Bytes:
-        return (value) => Array.isArray(value) ? new Uint8Array(value) : value;
-      default:
-        return (value) => value;
-    }
-  });
   return resultSet.rows.map(
-    (row) => row.map((value, index) => mappers[index](value)).reduce((acc, value, index) => {
+    (row) => row.reduce((acc, value, index) => {
       const splitByDot = resultSet.columnNames[index].split(".");
       let nested = acc;
       for (let i = 0; i < splitByDot.length; i++) {
@@ -1485,14 +1482,14 @@ var QueryInterpreter = class _QueryInterpreter {
       queryPlan,
       queryable,
       this.#placeholderValues,
-      this.#generators.snapshot(queryable.provider)
+      this.#generators.snapshot()
     ).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
   async interpretNode(node, queryable, scope, generators) {
     switch (node.type) {
       case "value": {
-        return { value: evaluateParam(node.args, scope, generators) };
+        return { value: evaluateArg(node.args, scope, generators) };
       }
       case "seq": {
         let result;
@@ -1597,7 +1594,7 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "mapField": {
         const { value, lastInsertId } = await this.interpretNode(node.args.records, queryable, scope, generators);
-        return { value: mapField(value, node.args.field), lastInsertId };
+        return { value: mapField2(value, node.args.field), lastInsertId };
       }
       case "join": {
         const { value: parent, lastInsertId } = await this.interpretNode(node.args.parent, queryable, scope, generators);
@@ -1618,7 +1615,7 @@ var QueryInterpreter = class _QueryInterpreter {
         }
         const transactionManager = this.#transactionManager.manager;
         const transactionInfo = await transactionManager.startTransaction();
-        const transaction = transactionManager.getTransaction(transactionInfo, "query");
+        const transaction = await transactionManager.getTransaction(transactionInfo, "query");
         try {
           const value = await this.interpretNode(node.args, transaction, scope, generators);
           await transactionManager.commitTransaction(transactionInfo.id);
@@ -1740,9 +1737,9 @@ function asRecord(value) {
   }
   throw new Error(`Expected object, got ${typeof value}`);
 }
-function mapField(value, field) {
+function mapField2(value, field) {
   if (Array.isArray(value)) {
-    return value.map((element) => mapField(element, field));
+    return value.map((element) => mapField2(element, field));
   }
   if (typeof value === "object" && value !== null) {
     return value[field] ?? null;
@@ -1786,7 +1783,7 @@ function attachChildrenToParents(parentRecords, children) {
 function evalFieldInitializer(initializer, lastInsertId, scope, generators) {
   switch (initializer.type) {
     case "value":
-      return evaluateParam(initializer.value, scope, generators);
+      return evaluateArg(initializer.value, scope, generators);
     case "lastInsertId":
       return lastInsertId;
     default:
@@ -1796,16 +1793,16 @@ function evalFieldInitializer(initializer, lastInsertId, scope, generators) {
 function evalFieldOperation(op, value, scope, generators) {
   switch (op.type) {
     case "set":
-      return evaluateParam(op.value, scope, generators);
+      return evaluateArg(op.value, scope, generators);
     case "add":
-      return asNumber2(value) + asNumber2(evaluateParam(op.value, scope, generators));
+      return asNumber2(value) + asNumber2(evaluateArg(op.value, scope, generators));
     case "subtract":
-      return asNumber2(value) - asNumber2(evaluateParam(op.value, scope, generators));
+      return asNumber2(value) - asNumber2(evaluateArg(op.value, scope, generators));
     case "multiply":
-      return asNumber2(value) * asNumber2(evaluateParam(op.value, scope, generators));
+      return asNumber2(value) * asNumber2(evaluateArg(op.value, scope, generators));
     case "divide": {
       const lhs = asNumber2(value);
-      const rhs = asNumber2(evaluateParam(op.value, scope, generators));
+      const rhs = asNumber2(evaluateArg(op.value, scope, generators));
       if (rhs === 0) {
         return null;
       }
@@ -1876,11 +1873,6 @@ var TransactionClosedError = class extends TransactionManagerError {
     super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction.`);
   }
 };
-var TransactionClosingError = class extends TransactionManagerError {
-  constructor(operation) {
-    super(`Transaction is being closed: A ${operation} cannot be executed on a closing transaction.`);
-  }
-};
 var TransactionRolledBackError = class extends TransactionManagerError {
   constructor(operation) {
     super(`Transaction already closed: A ${operation} cannot be executed on a transaction that was rolled back.`);
@@ -1953,7 +1945,7 @@ var TransactionManager = class {
     return await this.tracingHelper.runInChildSpan("start_transaction", () => this.#startTransactionImpl(options));
   }
   async #startTransactionImpl(options) {
-    const validatedOptions = options !== void 0 ? this.validateOptions(options) : this.transactionOptions;
+    const validatedOptions = options !== void 0 ? this.#validateOptions(options) : this.transactionOptions;
     const transaction = {
       id: await randomUUID(),
       status: "waiting",
@@ -1970,13 +1962,12 @@ var TransactionManager = class {
     switch (transaction.status) {
       case "waiting":
         if (hasTimedOut) {
-          await this.closeTransaction(transaction, "timed_out");
+          await this.#closeTransaction(transaction, "timed_out");
           throw new TransactionStartTimeoutError();
         }
         transaction.status = "running";
-        transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.timeout);
+        transaction.timer = this.#startTransactionTimeout(transaction.id, validatedOptions.timeout);
         return { id: transaction.id };
-      case "closing":
       case "timed_out":
       case "running":
       case "committed":
@@ -1985,27 +1976,31 @@ var TransactionManager = class {
           `Transaction in invalid state ${transaction.status} although it just finished startup.`
         );
       default:
-        assertNever(transaction.status, "Unknown transaction status.");
+        assertNever(transaction["status"], "Unknown transaction status.");
     }
   }
   async commitTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
-      const txw = this.getActiveTransaction(transactionId, "commit");
-      await this.closeTransaction(txw, "committed");
+      const txw = this.#getActiveOrClosingTransaction(transactionId, "commit");
+      await this.#closeTransaction(txw, "committed");
     });
   }
   async rollbackTransaction(transactionId) {
     return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
-      const txw = this.getActiveTransaction(transactionId, "rollback");
-      await this.closeTransaction(txw, "rolled_back");
+      const txw = this.#getActiveOrClosingTransaction(transactionId, "rollback");
+      await this.#closeTransaction(txw, "rolled_back");
     });
   }
-  getTransaction(txInfo, operation) {
-    const tx = this.getActiveTransaction(txInfo.id, operation);
+  async getTransaction(txInfo, operation) {
+    let tx = this.#getActiveOrClosingTransaction(txInfo.id, operation);
+    if (tx.status === "closing") {
+      await tx.closing;
+      tx = this.#getActiveOrClosingTransaction(txInfo.id, operation);
+    }
     if (!tx.transaction) throw new TransactionNotFoundError();
     return tx.transaction;
   }
-  getActiveTransaction(transactionId, operation) {
+  #getActiveOrClosingTransaction(transactionId, operation) {
     const transaction = this.transactions.get(transactionId);
     if (!transaction) {
       const closedTransaction = this.closedTransactions.find((tx) => tx.id === transactionId);
@@ -2031,62 +2026,74 @@ var TransactionManager = class {
         throw new TransactionNotFoundError();
       }
     }
-    if (transaction.status === "closing") {
-      throw new TransactionClosingError(operation);
-    }
     if (["committed", "rolled_back", "timed_out"].includes(transaction.status)) {
       throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.");
     }
     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.#closeTransaction(tx, "rolled_back")));
   }
-  startTransactionTimeout(transactionId, timeout) {
+  #startTransactionTimeout(transactionId, timeout) {
     const timeoutStartedAt = Date.now();
     return setTimeout(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");
+        await this.#closeTransaction(tx, "timed_out");
       } else {
         debug("Transaction already committed or rolled back when timeout happened.", transactionId);
       }
     }, timeout);
   }
-  async closeTransaction(tx, status) {
-    debug("Closing transaction.", { transactionId: tx.id, status });
-    tx.status = "closing";
-    try {
-      if (tx.transaction && status === "committed") {
-        if (tx.transaction.options.usePhantomQuery) {
-          await this.#withQuerySpanAndEvent(PHANTOM_COMMIT_QUERY(), tx.transaction, () => tx.transaction.commit());
-        } else {
-          const query = COMMIT_QUERY();
-          await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
-          await tx.transaction.commit();
+  async #closeTransaction(tx, status) {
+    const createClosingPromise = async () => {
+      debug("Closing transaction.", { transactionId: tx.id, status });
+      try {
+        if (tx.transaction && status === "committed") {
+          if (tx.transaction.options.usePhantomQuery) {
+            await this.#withQuerySpanAndEvent(PHANTOM_COMMIT_QUERY(), tx.transaction, () => tx.transaction.commit());
+          } else {
+            const query = COMMIT_QUERY();
+            await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
+            await tx.transaction.commit();
+          }
+        } else if (tx.transaction) {
+          if (tx.transaction.options.usePhantomQuery) {
+            await this.#withQuerySpanAndEvent(
+              PHANTOM_ROLLBACK_QUERY(),
+              tx.transaction,
+              () => tx.transaction.rollback()
+            );
+          } else {
+            const query = ROLLBACK_QUERY();
+            await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
+            await tx.transaction.rollback();
+          }
         }
-      } else if (tx.transaction) {
-        if (tx.transaction.options.usePhantomQuery) {
-          await this.#withQuerySpanAndEvent(PHANTOM_ROLLBACK_QUERY(), tx.transaction, () => tx.transaction.rollback());
-        } else {
-          const query = ROLLBACK_QUERY();
-          await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
-          await tx.transaction.rollback();
+      } finally {
+        tx.status = status;
+        clearTimeout(tx.timer);
+        tx.timer = void 0;
+        this.transactions.delete(tx.id);
+        this.closedTransactions.push(tx);
+        if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
+          this.closedTransactions.shift();
         }
       }
-    } finally {
-      tx.status = status;
-      clearTimeout(tx.timer);
-      tx.timer = void 0;
-      this.transactions.delete(tx.id);
-      this.closedTransactions.push(tx);
-      if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
-        this.closedTransactions.shift();
-      }
+    };
+    if (tx.status === "closing") {
+      await tx.closing;
+      this.#getActiveOrClosingTransaction(tx.id, status === "committed" ? "commit" : "rollback");
+    } else {
+      await Object.assign(tx, {
+        status: "closing",
+        reason: status,
+        closing: createClosingPromise()
+      }).closing;
     }
   }
-  validateOptions(options) {
+  #validateOptions(options) {
     if (!options.timeout) throw new TransactionManagerError("timeout is required");
     if (!options.maxWait) throw new TransactionManagerError("maxWait is required");
     if (options.isolationLevel === "SNAPSHOT") throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
@@ -2117,8 +2124,6 @@ var TransactionManager = class {
   deserializeJsonResponse,
   doKeysMatch,
   isDeepStrictEqual,
-  isPrismaValueBigInt,
-  isPrismaValueBytes,
   isPrismaValueGenerator,
   isPrismaValuePlaceholder,
   noopTracingHelper,