@prisma/client-engine-runtime 6.14.0-dev.4 → 6.14.0-dev.41

package/dist/index.js

@@ -35,6 +35,8 @@ __export(index_exports, {
   TransactionManager: () => TransactionManager,
   TransactionManagerError: () => TransactionManagerError,
   UserFacingError: () => UserFacingError,
+  convertCompactedRows: () => convertCompactedRows,
+  deserializeJsonResponse: () => deserializeJsonResponse,
   doKeysMatch: () => doKeysMatch,
   isDeepStrictEqual: () => isDeepStrictEqual,
   isPrismaValueBigInt: () => isPrismaValueBigInt,
@@ -43,12 +45,13 @@ __export(index_exports, {
   isPrismaValuePlaceholder: () => isPrismaValuePlaceholder,
   noopTracingHelper: () => noopTracingHelper,
   normalizeJsonProtocolValues: () => normalizeJsonProtocolValues,
+  normalizeRawJsonProtocolResponse: () => normalizeRawJsonProtocolResponse,
   safeJsonStringify: () => safeJsonStringify
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/interpreter/DataMapper.ts
-var import_decimal2 = __toESM(require("decimal.js"));
+// src/json-protocol.ts
+var import_decimal2 = require("decimal.js");
 
 // src/utils.ts
 var import_decimal = __toESM(require("decimal.js"));
@@ -142,7 +145,303 @@ function safeJsonStringify(obj) {
   });
 }
 
-// src/interpreter/DataMapper.ts
+// src/json-protocol.ts
+function normalizeJsonProtocolValues(result) {
+  if (result === null) {
+    return result;
+  }
+  if (Array.isArray(result)) {
+    return result.map(normalizeJsonProtocolValues);
+  }
+  if (typeof result === "object") {
+    if (isTaggedValue(result)) {
+      return normalizeTaggedValue(result);
+    }
+    if (result.constructor !== null && result.constructor.name !== "Object") {
+      return result;
+    }
+    return mapObjectValues(result, normalizeJsonProtocolValues);
+  }
+  return result;
+}
+function isTaggedValue(value) {
+  return value !== null && typeof value == "object" && typeof value["$type"] === "string";
+}
+function normalizeTaggedValue({ $type, value }) {
+  switch ($type) {
+    case "BigInt":
+      return { $type, value: String(value) };
+    case "Bytes":
+      return { $type, value };
+    case "DateTime":
+      return { $type, value: new Date(value).toISOString() };
+    case "Decimal":
+      return { $type, value: String(new import_decimal2.Decimal(value)) };
+    case "Json":
+      return { $type, value: JSON.stringify(JSON.parse(value)) };
+    default:
+      assertNever(value, "Unknown tagged value");
+  }
+}
+function mapObjectValues(object, mapper) {
+  const result = {};
+  for (const key of Object.keys(object)) {
+    result[key] = mapper(object[key], key);
+  }
+  return result;
+}
+function deserializeJsonResponse(result) {
+  if (result === null) {
+    return result;
+  }
+  if (Array.isArray(result)) {
+    return result.map(deserializeJsonResponse);
+  }
+  if (typeof result === "object") {
+    if (isTaggedValue(result)) {
+      return deserializeTaggedValue(result);
+    }
+    if (result.constructor !== null && result.constructor.name !== "Object") {
+      return result;
+    }
+    return mapObjectValues(result, deserializeJsonResponse);
+  }
+  return result;
+}
+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 "DateTime":
+      return new Date(value);
+    case "Decimal":
+      return new import_decimal2.Decimal(value);
+    case "Json":
+      return JSON.parse(value);
+    default:
+      assertNever(value, "Unknown tagged value");
+  }
+}
+
+// src/user-facing-error.ts
+var import_driver_adapter_utils = require("@prisma/driver-adapter-utils");
+var UserFacingError = class extends Error {
+  name = "UserFacingError";
+  code;
+  meta;
+  constructor(message, code, meta) {
+    super(message);
+    this.code = code;
+    this.meta = meta ?? {};
+  }
+  toQueryResponseErrorObject() {
+    return {
+      error: this.message,
+      user_facing_error: {
+        is_panic: false,
+        message: this.message,
+        meta: this.meta,
+        error_code: this.code
+      }
+    };
+  }
+};
+function rethrowAsUserFacing(error) {
+  if (!(0, import_driver_adapter_utils.isDriverAdapterError)(error)) {
+    throw error;
+  }
+  const code = getErrorCode(error);
+  const message = renderErrorMessage(error);
+  if (!code || !message) {
+    throw error;
+  }
+  throw new UserFacingError(message, code, { driverAdapterError: error });
+}
+function rethrowAsUserFacingRawError(error) {
+  if (!(0, import_driver_adapter_utils.isDriverAdapterError)(error)) {
+    throw error;
+  }
+  throw new UserFacingError(
+    `Raw query failed. Code: \`${error.cause.originalCode ?? "N/A"}\`. Message: \`${error.cause.originalMessage ?? renderErrorMessage(error)}\``,
+    "P2010",
+    { driverAdapterError: error }
+  );
+}
+function getErrorCode(err) {
+  switch (err.cause.kind) {
+    case "AuthenticationFailed":
+      return "P1000";
+    case "DatabaseNotReachable":
+      return "P1001";
+    case "DatabaseDoesNotExist":
+      return "P1003";
+    case "SocketTimeout":
+      return "P1008";
+    case "DatabaseAlreadyExists":
+      return "P1009";
+    case "DatabaseAccessDenied":
+      return "P1010";
+    case "TlsConnectionError":
+      return "P1011";
+    case "ConnectionClosed":
+      return "P1017";
+    case "TransactionAlreadyClosed":
+      return "P1018";
+    case "LengthMismatch":
+      return "P2000";
+    case "UniqueConstraintViolation":
+      return "P2002";
+    case "ForeignKeyConstraintViolation":
+      return "P2003";
+    case "UnsupportedNativeDataType":
+      return "P2010";
+    case "NullConstraintViolation":
+      return "P2011";
+    case "ValueOutOfRange":
+      return "P2020";
+    case "TableDoesNotExist":
+      return "P2021";
+    case "ColumnNotFound":
+      return "P2022";
+    case "InvalidIsolationLevel":
+    case "InconsistentColumnData":
+      return "P2023";
+    case "MissingFullTextSearchIndex":
+      return "P2030";
+    case "TransactionWriteConflict":
+      return "P2034";
+    case "GenericJs":
+      return "P2036";
+    case "TooManyConnections":
+      return "P2037";
+    case "postgres":
+    case "sqlite":
+    case "mysql":
+    case "mssql":
+      return;
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
+  }
+}
+function renderErrorMessage(err) {
+  switch (err.cause.kind) {
+    case "AuthenticationFailed": {
+      const user = err.cause.user ?? "(not available)";
+      return `Authentication failed against the database server, the provided database credentials for \`${user}\` are not valid`;
+    }
+    case "DatabaseNotReachable": {
+      const address = err.cause.host && err.cause.port ? `${err.cause.host}:${err.cause.port}` : err.cause.host;
+      return `Can't reach database server${address ? ` at ${address}` : ""}`;
+    }
+    case "DatabaseDoesNotExist": {
+      const db = err.cause.db ?? "(not available)";
+      return `Database \`${db}\` does not exist on the database server`;
+    }
+    case "SocketTimeout":
+      return `Operation has timed out`;
+    case "DatabaseAlreadyExists": {
+      const db = err.cause.db ?? "(not available)";
+      return `Database \`${db}\` already exists on the database server`;
+    }
+    case "DatabaseAccessDenied": {
+      const db = err.cause.db ?? "(not available)";
+      return `User was denied access on the database \`${db}\``;
+    }
+    case "TlsConnectionError": {
+      return `Error opening a TLS connection: ${err.cause.reason}`;
+    }
+    case "ConnectionClosed": {
+      return "Server has closed the connection.";
+    }
+    case "TransactionAlreadyClosed":
+      return err.cause.cause;
+    case "LengthMismatch": {
+      const column = err.cause.column ?? "(not available)";
+      return `The provided value for the column is too long for the column's type. Column: ${column}`;
+    }
+    case "UniqueConstraintViolation":
+      return `Unique constraint failed on the ${renderConstraint(err.cause.constraint)}`;
+    case "ForeignKeyConstraintViolation":
+      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\`.`;
+    case "NullConstraintViolation":
+      return `Null constraint violation on the ${renderConstraint(err.cause.constraint)}`;
+    case "ValueOutOfRange":
+      return `Value out of range for the type: ${err.cause.cause}`;
+    case "TableDoesNotExist": {
+      const table = err.cause.table ?? "(not available)";
+      return `The table \`${table}\` does not exist in the current database.`;
+    }
+    case "ColumnNotFound": {
+      const column = err.cause.column ?? "(not available)";
+      return `The column \`${column}\` does not exist in the current database.`;
+    }
+    case "InvalidIsolationLevel":
+      return `Error in connector: Conversion error: ${err.cause.level}`;
+    case "InconsistentColumnData":
+      return `Inconsistent column data: ${err.cause.cause}`;
+    case "MissingFullTextSearchIndex":
+      return "Cannot find a fulltext index to use for the native search, try adding a @@fulltext([Fields...]) to your schema";
+    case "TransactionWriteConflict":
+      return `Transaction failed due to a write conflict or a deadlock. Please retry your transaction`;
+    case "GenericJs":
+      return `Error in external connector (id ${err.cause.id})`;
+    case "TooManyConnections":
+      return `Too many database connections opened: ${err.cause.cause}`;
+    case "sqlite":
+    case "postgres":
+    case "mysql":
+    case "mssql":
+      return;
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
+  }
+}
+function renderConstraint(constraint) {
+  if (constraint && "fields" in constraint) {
+    return `fields: (${constraint.fields.map((field) => `\`${field}\``).join(", ")})`;
+  } else if (constraint && "index" in constraint) {
+    return `constraint: \`${constraint.index}\``;
+  } else if (constraint && "foreignKey" in constraint) {
+    return `foreign key`;
+  }
+  return "(not available)";
+}
+
+// src/batch.ts
+function convertCompactedRows(rows, compiledBatch) {
+  const keysPerRow = rows.map(
+    (item) => compiledBatch.keys.reduce((acc, key) => {
+      acc[key] = deserializeJsonResponse(item[key]);
+      return acc;
+    }, {})
+  );
+  const selection = new Set(compiledBatch.nestedSelection);
+  return compiledBatch.arguments.map((args) => {
+    const rowIndex = keysPerRow.findIndex((rowKeys) => doKeysMatch(rowKeys, args));
+    if (rowIndex === -1) {
+      if (compiledBatch.expectNonEmpty) {
+        return new UserFacingError(
+          "An operation failed because it depends on one or more records that were required but not found",
+          "P2025"
+        );
+      } else {
+        return null;
+      }
+    } else {
+      const selected = Object.entries(rows[rowIndex]).filter(([k]) => selection.has(k));
+      return Object.fromEntries(selected);
+    }
+  });
+}
+
+// src/interpreter/data-mapper.ts
+var import_decimal3 = __toESM(require("decimal.js"));
 var DataMapperError = class extends Error {
   name = "DataMapperError";
 };
@@ -154,17 +453,20 @@ function applyDataMap(data, structure, enums) {
       }
       return { count: data };
     case "Object":
-      return mapArrayOrObject(data, structure.fields, enums);
+      return mapArrayOrObject(data, structure.fields, enums, structure.skipNulls);
     case "Value":
       return mapValue(data, "<result>", structure.resultType, enums);
     default:
       assertNever(structure, `Invalid data mapping type: '${structure.type}'`);
   }
 }
-function mapArrayOrObject(data, fields, enums) {
+function mapArrayOrObject(data, fields, enums, skipNulls) {
   if (data === null) return null;
   if (Array.isArray(data)) {
-    const rows = data;
+    let rows = data;
+    if (skipNulls) {
+      rows = rows.filter((row) => row !== null);
+    }
     return rows.map((row) => mapObject(row, fields, enums));
   }
   if (typeof data === "object") {
@@ -180,7 +482,7 @@ function mapArrayOrObject(data, fields, enums) {
         cause: error
       });
     }
-    return mapArrayOrObject(decodedData, fields, enums);
+    return mapArrayOrObject(decodedData, fields, enums, skipNulls);
   }
   throw new DataMapperError(`Expected an array or an object, got: ${typeof data}`);
 }
@@ -201,7 +503,7 @@ function mapObject(data, fields, enums) {
           );
         }
         const target = node.serializedName !== null ? data[node.serializedName] : data;
-        result[name] = mapArrayOrObject(target, node.fields, enums);
+        result[name] = mapArrayOrObject(target, node.fields, enums, node.skipNulls);
         break;
       }
       case "Value":
@@ -294,7 +596,7 @@ function mapValue(value, columnName, resultType, enums) {
       throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
     }
     case "Decimal":
-      if (typeof value !== "number" && typeof value !== "string" && !import_decimal2.default.isDecimal(value)) {
+      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 };
@@ -318,8 +620,10 @@ function mapValue(value, columnName, resultType, enums) {
       return values.map((v, i) => mapValue(v, `${columnName}[${i}]`, resultType.inner, enums));
     }
     case "Object": {
-      const jsonValue = typeof value === "string" ? value : safeJsonStringify(value);
-      return { $type: "Json", value: jsonValue };
+      return { $type: "Json", value: safeJsonStringify(value) };
+    }
+    case "Json": {
+      return { $type: "Json", value: `${value}` };
     }
     case "Bytes": {
       if (typeof value === "string" && value.startsWith("\\x")) {
@@ -340,7 +644,7 @@ function mapValue(value, columnName, resultType, enums) {
       }
       const enumValue = enumDef[`${value}`];
       if (enumValue === void 0) {
-        throw new DataMapperError(`Unknown enum value '${value}' for enum '${resultType.inner}'`);
+        throw new DataMapperError(`Value '${value}' not found in enum '${resultType.inner}'`);
       }
       return enumValue;
     }
@@ -395,201 +699,25 @@ async function withQuerySpanAndEvent({
     {
       name: "db_query",
       kind: import_api.SpanKind.CLIENT,
-      attributes: {
-        "db.query.text": query.sql,
-        "db.system.name": providerToOtelSystem(provider)
-      }
-    },
-    async () => {
-      const timestamp = /* @__PURE__ */ new Date();
-      const startInstant = performance.now();
-      const result = await execute();
-      const endInstant = performance.now();
-      onQuery?.({
-        timestamp,
-        duration: endInstant - startInstant,
-        query: query.sql,
-        params: query.args
-      });
-      return result;
-    }
-  );
-}
-
-// src/UserFacingError.ts
-var import_driver_adapter_utils = require("@prisma/driver-adapter-utils");
-var UserFacingError = class extends Error {
-  name = "UserFacingError";
-  code;
-  meta;
-  constructor(message, code, meta) {
-    super(message);
-    this.code = code;
-    this.meta = meta ?? {};
-  }
-  toQueryResponseErrorObject() {
-    return {
-      error: this.message,
-      user_facing_error: {
-        is_panic: false,
-        message: this.message,
-        meta: this.meta,
-        error_code: this.code
-      }
-    };
-  }
-};
-function rethrowAsUserFacing(error) {
-  if (!(0, import_driver_adapter_utils.isDriverAdapterError)(error)) {
-    throw error;
-  }
-  const code = getErrorCode(error);
-  const message = renderErrorMessage(error);
-  if (!code || !message) {
-    throw error;
-  }
-  throw new UserFacingError(message, code, { driverAdapterError: error });
-}
-function getErrorCode(err) {
-  switch (err.cause.kind) {
-    case "AuthenticationFailed":
-      return "P1000";
-    case "DatabaseNotReachable":
-      return "P1001";
-    case "DatabaseDoesNotExist":
-      return "P1003";
-    case "SocketTimeout":
-      return "P1008";
-    case "DatabaseAlreadyExists":
-      return "P1009";
-    case "DatabaseAccessDenied":
-      return "P1010";
-    case "TlsConnectionError":
-      return "P1011";
-    case "ConnectionClosed":
-      return "P1017";
-    case "TransactionAlreadyClosed":
-      return "P1018";
-    case "LengthMismatch":
-      return "P2000";
-    case "UniqueConstraintViolation":
-      return "P2002";
-    case "ForeignKeyConstraintViolation":
-      return "P2003";
-    case "UnsupportedNativeDataType":
-      return "P2010";
-    case "NullConstraintViolation":
-      return "P2011";
-    case "ValueOutOfRange":
-      return "P2020";
-    case "TableDoesNotExist":
-      return "P2021";
-    case "ColumnNotFound":
-      return "P2022";
-    case "InvalidIsolationLevel":
-    case "InconsistentColumnData":
-      return "P2023";
-    case "MissingFullTextSearchIndex":
-      return "P2030";
-    case "TransactionWriteConflict":
-      return "P2034";
-    case "GenericJs":
-      return "P2036";
-    case "TooManyConnections":
-      return "P2037";
-    case "postgres":
-    case "sqlite":
-    case "mysql":
-    case "mssql":
-      return;
-    default:
-      assertNever(err.cause, `Unknown error: ${err.cause}`);
-  }
-}
-function renderErrorMessage(err) {
-  switch (err.cause.kind) {
-    case "AuthenticationFailed": {
-      const user = err.cause.user ?? "(not available)";
-      return `Authentication failed against the database server, the provided database credentials for \`${user}\` are not valid`;
-    }
-    case "DatabaseNotReachable": {
-      const address = err.cause.host && err.cause.port ? `${err.cause.host}:${err.cause.port}` : err.cause.host;
-      return `Can't reach database server${address ? ` at ${address}` : ""}`;
-    }
-    case "DatabaseDoesNotExist": {
-      const db = err.cause.db ?? "(not available)";
-      return `Database \`${db}\` does not exist on the database server`;
-    }
-    case "SocketTimeout":
-      return `Operation has timed out`;
-    case "DatabaseAlreadyExists": {
-      const db = err.cause.db ?? "(not available)";
-      return `Database \`${db}\` already exists on the database server`;
-    }
-    case "DatabaseAccessDenied": {
-      const db = err.cause.db ?? "(not available)";
-      return `User was denied access on the database \`${db}\``;
-    }
-    case "TlsConnectionError": {
-      return `Error opening a TLS connection: ${err.cause.reason}`;
-    }
-    case "ConnectionClosed": {
-      return "Server has closed the connection.";
-    }
-    case "TransactionAlreadyClosed":
-      return err.cause.cause;
-    case "LengthMismatch": {
-      const column = err.cause.column ?? "(not available)";
-      return `The provided value for the column is too long for the column's type. Column: ${column}`;
-    }
-    case "UniqueConstraintViolation":
-      return `Unique constraint failed on the ${renderConstraint(err.cause.constraint)}`;
-    case "ForeignKeyConstraintViolation":
-      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\`.`;
-    case "NullConstraintViolation":
-      return `Null constraint violation on the ${renderConstraint(err.cause.constraint)}`;
-    case "ValueOutOfRange":
-      return `Value out of range for the type: ${err.cause.cause}`;
-    case "TableDoesNotExist": {
-      const table = err.cause.table ?? "(not available)";
-      return `The table \`${table}\` does not exist in the current database.`;
-    }
-    case "ColumnNotFound": {
-      const column = err.cause.column ?? "(not available)";
-      return `The column \`${column}\` does not exist in the current database.`;
-    }
-    case "InvalidIsolationLevel":
-      return `Invalid isolation level \`${err.cause.level}\``;
-    case "InconsistentColumnData":
-      return `Inconsistent column data: ${err.cause.cause}`;
-    case "MissingFullTextSearchIndex":
-      return "Cannot find a fulltext index to use for the native search, try adding a @@fulltext([Fields...]) to your schema";
-    case "TransactionWriteConflict":
-      return `Transaction failed due to a write conflict or a deadlock. Please retry your transaction`;
-    case "GenericJs":
-      return `Error in external connector (id ${err.cause.id})`;
-    case "TooManyConnections":
-      return `Too many database connections opened: ${err.cause.cause}`;
-    case "sqlite":
-    case "postgres":
-    case "mysql":
-    case "mssql":
-      return;
-    default:
-      assertNever(err.cause, `Unknown error: ${err.cause}`);
-  }
-}
-function renderConstraint(constraint) {
-  if (constraint && "fields" in constraint) {
-    return `fields: (${constraint.fields.map((field) => `\`${field}\``).join(", ")})`;
-  } else if (constraint && "index" in constraint) {
-    return `constraint: \`${constraint.index}\``;
-  } else if (constraint && "foreignKey" in constraint) {
-    return `foreign key`;
-  }
-  return "(not available)";
+      attributes: {
+        "db.query.text": query.sql,
+        "db.system.name": providerToOtelSystem(provider)
+      }
+    },
+    async () => {
+      const timestamp = /* @__PURE__ */ new Date();
+      const startInstant = performance.now();
+      const result = await execute();
+      const endInstant = performance.now();
+      onQuery?.({
+        timestamp,
+        duration: endInstant - startInstant,
+        query: query.sql,
+        params: query.args
+      });
+      return result;
+    }
+  );
 }
 
 // src/interpreter/generators.ts
@@ -693,7 +821,98 @@ var ProductGenerator = class {
   }
 };
 
-// src/QueryPlan.ts
+// src/interpreter/in-memory-processing.ts
+function processRecords(value, ops) {
+  if (value == null) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return processRecords(JSON.parse(value), ops);
+  }
+  if (Array.isArray(value)) {
+    return processManyRecords(value, ops);
+  }
+  return processOneRecord(value, ops);
+}
+function processOneRecord(record, ops) {
+  if (ops.pagination) {
+    const { skip, take, cursor } = ops.pagination;
+    if (skip !== null && skip > 0) {
+      return null;
+    }
+    if (take === 0) {
+      return null;
+    }
+    if (cursor !== null && !doKeysMatch(record, cursor)) {
+      return null;
+    }
+  }
+  return processNestedRecords(record, ops.nested);
+}
+function processNestedRecords(record, opsMap) {
+  for (const [key, ops] of Object.entries(opsMap)) {
+    record[key] = processRecords(record[key], ops);
+  }
+  return record;
+}
+function processManyRecords(records, ops) {
+  if (ops.distinct !== null) {
+    const fields = ops.linkingFields !== null ? [...ops.distinct, ...ops.linkingFields] : ops.distinct;
+    records = distinctBy(records, fields);
+  }
+  if (ops.pagination) {
+    records = paginate(records, ops.pagination, ops.linkingFields);
+  }
+  if (ops.reverse) {
+    records.reverse();
+  }
+  if (Object.keys(ops.nested).length === 0) {
+    return records;
+  }
+  return records.map((record) => processNestedRecords(record, ops.nested));
+}
+function distinctBy(records, fields) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const record of records) {
+    const key = getRecordKey(record, fields);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(record);
+    }
+  }
+  return result;
+}
+function paginate(records, pagination, linkingFields) {
+  if (linkingFields === null) {
+    return paginateSingleList(records, pagination);
+  }
+  const groupedByParent = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const parentKey = getRecordKey(record, linkingFields);
+    if (!groupedByParent.has(parentKey)) {
+      groupedByParent.set(parentKey, []);
+    }
+    groupedByParent.get(parentKey).push(record);
+  }
+  const groupList = Array.from(groupedByParent.entries());
+  groupList.sort(([aId], [bId]) => aId < bId ? -1 : aId > bId ? 1 : 0);
+  return groupList.flatMap(([, elems]) => paginateSingleList(elems, pagination));
+}
+function paginateSingleList(list, { cursor, skip, take }) {
+  const cursorIndex = cursor !== null ? list.findIndex((item) => doKeysMatch(item, cursor)) : 0;
+  if (cursorIndex === -1) {
+    return [];
+  }
+  const start = cursorIndex + (skip ?? 0);
+  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]));
+}
+
+// src/query-plan.ts
 function isPrismaValuePlaceholder(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "param";
 }
@@ -707,18 +926,22 @@ function isPrismaValueBigInt(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "bigint";
 }
 
-// src/interpreter/renderQuery.ts
-function renderQuery(dbQuery, scope, generators) {
+// src/interpreter/render-query.ts
+function renderQuery(dbQuery, scope, generators, maxChunkSize) {
   const queryType = dbQuery.type;
+  const params = evaluateParams(dbQuery.params, scope, generators);
   switch (queryType) {
     case "rawSql":
-      return renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators));
-    case "templateSql":
-      return renderTemplateSql(
-        dbQuery.fragments,
-        dbQuery.placeholderFormat,
-        evaluateParams(dbQuery.params, scope, generators)
-      );
+      return [renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators))];
+    case "templateSql": {
+      const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, params, maxChunkSize) : [params];
+      return chunks.map((params2) => {
+        if (maxChunkSize !== void 0 && params2.length > maxChunkSize) {
+          throw new UserFacingError("The query parameter limit supported by your database is exceeded.", "P2029");
+        }
+        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params2);
+      });
+    }
     default:
       assertNever(queryType, `Invalid query type`);
   }
@@ -756,61 +979,36 @@ function evaluateParam(param, scope, generators) {
   return value;
 }
 function renderTemplateSql(fragments, placeholderFormat, params) {
-  let paramIndex = 0;
-  let placeholderNumber = 1;
+  let sql = "";
+  const ctx = { placeholderNumber: 1 };
   const flattenedParams = [];
-  const sql = fragments.map((fragment) => {
-    const fragmentType = fragment.type;
-    switch (fragmentType) {
-      case "parameter":
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        flattenedParams.push(params[paramIndex++]);
-        return formatPlaceholder(placeholderFormat, placeholderNumber++);
-      case "stringChunk":
-        return fragment.chunk;
-      case "parameterTuple": {
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        const paramValue = params[paramIndex++];
-        const paramArray = Array.isArray(paramValue) ? paramValue : [paramValue];
-        const placeholders = paramArray.length == 0 ? "NULL" : paramArray.map((value) => {
-          flattenedParams.push(value);
-          return formatPlaceholder(placeholderFormat, placeholderNumber++);
-        }).join(",");
-        return `(${placeholders})`;
-      }
-      case "parameterTupleList": {
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        const paramValue = params[paramIndex++];
-        if (!Array.isArray(paramValue)) {
-          throw new Error(`Malformed query template. Tuple list expected.`);
-        }
-        if (paramValue.length === 0) {
-          throw new Error(`Malformed query template. Tuple list cannot be empty.`);
-        }
-        const tupleList = paramValue.map((tuple) => {
-          if (!Array.isArray(tuple)) {
-            throw new Error(`Malformed query template. Tuple expected.`);
-          }
-          const elements = tuple.map((value) => {
-            flattenedParams.push(value);
-            return formatPlaceholder(placeholderFormat, placeholderNumber++);
-          }).join(fragment.itemSeparator);
-          return `${fragment.itemPrefix}${elements}${fragment.itemSuffix}`;
-        }).join(fragment.groupSeparator);
-        return tupleList;
-      }
-      default:
-        assertNever(fragmentType, "Invalid fragment type");
-    }
-  }).join("");
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    flattenedParams.push(...flattenedFragmentParams(fragment));
+    sql += renderFragment(fragment, placeholderFormat, ctx);
+  }
   return renderRawSql(sql, flattenedParams);
 }
+function renderFragment(fragment, placeholderFormat, ctx) {
+  const fragmentType = fragment.type;
+  switch (fragmentType) {
+    case "parameter":
+      return formatPlaceholder(placeholderFormat, ctx.placeholderNumber++);
+    case "stringChunk":
+      return fragment.chunk;
+    case "parameterTuple": {
+      const placeholders = fragment.value.length == 0 ? "NULL" : fragment.value.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(",");
+      return `(${placeholders})`;
+    }
+    case "parameterTupleList": {
+      return fragment.value.map((tuple) => {
+        const elements = tuple.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(fragment.itemSeparator);
+        return `${fragment.itemPrefix}${elements}${fragment.itemSuffix}`;
+      }).join(fragment.groupSeparator);
+    }
+    default:
+      assertNever(fragmentType, "Invalid fragment type");
+  }
+}
 function formatPlaceholder(placeholderFormat, placeholderNumber) {
   return placeholderFormat.hasNumbering ? `${placeholderFormat.prefix}${placeholderNumber}` : placeholderFormat.prefix;
 }
@@ -843,8 +1041,145 @@ function toArgType(value) {
 function doesRequireEvaluation(param) {
   return isPrismaValuePlaceholder(param) || isPrismaValueGenerator(param);
 }
+function* pairFragmentsWithParams(fragments, params) {
+  let index = 0;
+  for (const fragment of fragments) {
+    switch (fragment.type) {
+      case "parameter": {
+        if (index >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        yield { ...fragment, value: params[index++] };
+        break;
+      }
+      case "stringChunk": {
+        yield fragment;
+        break;
+      }
+      case "parameterTuple": {
+        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] };
+        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++];
+        if (!Array.isArray(value)) {
+          throw new Error(`Malformed query template. Tuple list expected.`);
+        }
+        if (value.length === 0) {
+          throw new Error(`Malformed query template. Tuple list cannot be empty.`);
+        }
+        for (const tuple of value) {
+          if (!Array.isArray(tuple)) {
+            throw new Error(`Malformed query template. Tuple expected.`);
+          }
+        }
+        yield { ...fragment, value };
+        break;
+      }
+    }
+  }
+}
+function* flattenedFragmentParams(fragment) {
+  switch (fragment.type) {
+    case "parameter":
+      yield fragment.value;
+      break;
+    case "stringChunk":
+      break;
+    case "parameterTuple":
+      yield* fragment.value;
+      break;
+    case "parameterTupleList":
+      for (const tuple of fragment.value) {
+        yield* tuple;
+      }
+      break;
+  }
+}
+function chunkParams(fragments, params, maxChunkSize) {
+  let totalParamCount = 0;
+  let maxParamsPerFragment = 0;
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    let paramSize = 0;
+    for (const _ of flattenedFragmentParams(fragment)) {
+      void _;
+      paramSize++;
+    }
+    maxParamsPerFragment = Math.max(maxParamsPerFragment, paramSize);
+    totalParamCount += paramSize;
+  }
+  let chunkedParams = [[]];
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    switch (fragment.type) {
+      case "parameter": {
+        for (const params2 of chunkedParams) {
+          params2.push(fragment.value);
+        }
+        break;
+      }
+      case "stringChunk": {
+        break;
+      }
+      case "parameterTuple": {
+        const thisParamCount = fragment.value.length;
+        let chunks = [];
+        if (maxChunkSize && // Have we split the parameters into chunks already?
+        chunkedParams.length === 1 && // Is this the fragment that has the most parameters?
+        thisParamCount === maxParamsPerFragment && // Do we need chunking to fit the parameters?
+        totalParamCount > maxChunkSize && // Would chunking enable us to fit the parameters?
+        totalParamCount - thisParamCount < maxChunkSize) {
+          const availableSize = maxChunkSize - (totalParamCount - thisParamCount);
+          chunks = chunkArray(fragment.value, availableSize);
+        } else {
+          chunks = [fragment.value];
+        }
+        chunkedParams = chunkedParams.flatMap((params2) => chunks.map((chunk) => [...params2, chunk]));
+        break;
+      }
+      case "parameterTupleList": {
+        const thisParamCount = fragment.value.reduce((acc, tuple) => acc + tuple.length, 0);
+        const completeChunks = [];
+        let currentChunk = [];
+        let currentChunkParamCount = 0;
+        for (const tuple of fragment.value) {
+          if (maxChunkSize && // Have we split the parameters into chunks already?
+          chunkedParams.length === 1 && // Is this the fragment that has the most parameters?
+          thisParamCount === maxParamsPerFragment && // Is there anything in the current chunk?
+          currentChunk.length > 0 && // Will adding this tuple exceed the max chunk size?
+          totalParamCount - thisParamCount + currentChunkParamCount + tuple.length > maxChunkSize) {
+            completeChunks.push(currentChunk);
+            currentChunk = [];
+            currentChunkParamCount = 0;
+          }
+          currentChunk.push(tuple);
+          currentChunkParamCount += tuple.length;
+        }
+        if (currentChunk.length > 0) {
+          completeChunks.push(currentChunk);
+        }
+        chunkedParams = chunkedParams.flatMap((params2) => completeChunks.map((chunk) => [...params2, chunk]));
+        break;
+      }
+    }
+  }
+  return chunkedParams;
+}
+function chunkArray(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
 
-// src/interpreter/serializeSql.ts
+// src/interpreter/serialize-sql.ts
 var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
 function serializeSql(resultSet) {
   const mappers = resultSet.columnTypes.map((type) => {
@@ -875,29 +1210,90 @@ function serializeSql(resultSet) {
   );
 }
 function serializeRawSql(resultSet) {
-  const types = resultSet.columnTypes.map((type) => serializeColumnType(type));
-  const mappers = types.map((type) => {
-    switch (type) {
-      case "bytes":
-        return (value) => Array.isArray(value) ? new Uint8Array(value) : value;
-      case "int":
-        return (value) => value === null ? null : typeof value === "number" ? value : parseInt(`${value}`, 10);
-      case "bigint":
-        return (value) => value === null ? null : typeof value === "bigint" ? value : BigInt(`${value}`);
-      case "json":
-        return (value) => typeof value === "string" ? JSON.parse(value) : value;
-      case "bool":
-        return (value) => typeof value === "string" ? value === "true" || value === "1" : typeof value === "number" ? value === 1 : value;
-      default:
-        return (value) => value;
-    }
-  });
   return {
     columns: resultSet.columnNames,
     types: resultSet.columnTypes.map((type) => serializeColumnType(type)),
-    rows: resultSet.rows.map((row) => row.map((value, index) => mappers[index](value)))
+    rows: resultSet.rows.map(
+      (row) => row.map((value, index) => serializeRawValue(value, resultSet.columnTypes[index]))
+    )
   };
 }
+function serializeRawValue(value, type) {
+  if (value === null) {
+    return null;
+  }
+  switch (type) {
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int32:
+      switch (typeof value) {
+        case "number":
+          return Math.trunc(value);
+        case "string":
+          return Math.trunc(Number(value));
+        default:
+          throw new Error(`Cannot serialize value of type ${typeof value} as Int32`);
+      }
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int32Array:
+      if (!Array.isArray(value)) {
+        throw new Error(`Cannot serialize value of type ${typeof value} as Int32Array`);
+      }
+      return value.map((v) => serializeRawValue(v, import_driver_adapter_utils2.ColumnTypeEnum.Int32));
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int64:
+      switch (typeof value) {
+        case "number":
+          return BigInt(Math.trunc(value));
+        case "string":
+          return value;
+        default:
+          throw new Error(`Cannot serialize value of type ${typeof value} as Int64`);
+      }
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int64Array:
+      if (!Array.isArray(value)) {
+        throw new Error(`Cannot serialize value of type ${typeof value} as Int64Array`);
+      }
+      return value.map((v) => serializeRawValue(v, import_driver_adapter_utils2.ColumnTypeEnum.Int64));
+    case import_driver_adapter_utils2.ColumnTypeEnum.Json:
+      switch (typeof value) {
+        case "string":
+          return JSON.parse(value);
+        default:
+          throw new Error(`Cannot serialize value of type ${typeof value} as Json`);
+      }
+    case import_driver_adapter_utils2.ColumnTypeEnum.JsonArray:
+      if (!Array.isArray(value)) {
+        throw new Error(`Cannot serialize value of type ${typeof value} as JsonArray`);
+      }
+      return value.map((v) => serializeRawValue(v, import_driver_adapter_utils2.ColumnTypeEnum.Json));
+    case import_driver_adapter_utils2.ColumnTypeEnum.Bytes:
+      if (Array.isArray(value)) {
+        return new Uint8Array(value);
+      } else {
+        throw new Error(`Cannot serialize value of type ${typeof value} as Bytes`);
+      }
+    case import_driver_adapter_utils2.ColumnTypeEnum.BytesArray:
+      if (!Array.isArray(value)) {
+        throw new Error(`Cannot serialize value of type ${typeof value} as BytesArray`);
+      }
+      return value.map((v) => serializeRawValue(v, import_driver_adapter_utils2.ColumnTypeEnum.Bytes));
+    case import_driver_adapter_utils2.ColumnTypeEnum.Boolean:
+      switch (typeof value) {
+        case "boolean":
+          return value;
+        case "string":
+          return value === "true" || value === "1";
+        case "number":
+          return value === 1;
+        default:
+          throw new Error(`Cannot serialize value of type ${typeof value} as Boolean`);
+      }
+    case import_driver_adapter_utils2.ColumnTypeEnum.BooleanArray:
+      if (!Array.isArray(value)) {
+        throw new Error(`Cannot serialize value of type ${typeof value} as BooleanArray`);
+      }
+      return value.map((v) => serializeRawValue(v, import_driver_adapter_utils2.ColumnTypeEnum.Boolean));
+    default:
+      return value;
+  }
+}
 function serializeColumnType(columnType) {
   switch (columnType) {
     case import_driver_adapter_utils2.ColumnTypeEnum.Int32:
@@ -1042,7 +1438,7 @@ function getErrorCode2(error) {
   }
 }
 
-// src/interpreter/QueryInterpreter.ts
+// src/interpreter/query-interpreter.ts
 var QueryInterpreter = class _QueryInterpreter {
   #transactionManager;
   #placeholderValues;
@@ -1052,6 +1448,7 @@ var QueryInterpreter = class _QueryInterpreter {
   #serializer;
   #rawSerializer;
   #provider;
+  #connectioInfo;
   constructor({
     transactionManager,
     placeholderValues,
@@ -1059,7 +1456,8 @@ var QueryInterpreter = class _QueryInterpreter {
     tracingHelper,
     serializer,
     rawSerializer,
-    provider
+    provider,
+    connectionInfo
   }) {
     this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
@@ -1068,6 +1466,7 @@ var QueryInterpreter = class _QueryInterpreter {
     this.#serializer = serializer;
     this.#rawSerializer = rawSerializer ?? serializer;
     this.#provider = provider;
+    this.#connectioInfo = connectionInfo;
   }
   static forSql(options) {
     return new _QueryInterpreter({
@@ -1077,7 +1476,8 @@ var QueryInterpreter = class _QueryInterpreter {
       tracingHelper: options.tracingHelper,
       serializer: serializeSql,
       rawSerializer: serializeRawSql,
-      provider: options.provider
+      provider: options.provider,
+      connectionInfo: options.connectionInfo
     });
   }
   async run(queryPlan, queryable) {
@@ -1138,21 +1538,41 @@ var QueryInterpreter = class _QueryInterpreter {
         };
       }
       case "execute": {
-        const query = renderQuery(node.args, scope, generators);
-        return this.#withQuerySpanAndEvent(query, queryable, async () => {
-          return { value: await queryable.executeRaw(query) };
-        });
+        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        let sum = 0;
+        for (const query of queries) {
+          sum += await this.#withQuerySpanAndEvent(
+            query,
+            queryable,
+            () => queryable.executeRaw(query).catch(
+              (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
+            )
+          );
+        }
+        return { value: sum };
       }
       case "query": {
-        const query = renderQuery(node.args, scope, generators);
-        return this.#withQuerySpanAndEvent(query, queryable, async () => {
-          const result = await queryable.queryRaw(query);
-          if (node.args.type === "rawSql") {
-            return { value: this.#rawSerializer(result), lastInsertId: result.lastInsertId };
+        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        let results;
+        for (const query of queries) {
+          const result = await this.#withQuerySpanAndEvent(
+            query,
+            queryable,
+            () => queryable.queryRaw(query).catch(
+              (err) => node.args.type === "rawSql" ? rethrowAsUserFacingRawError(err) : rethrowAsUserFacing(err)
+            )
+          );
+          if (results === void 0) {
+            results = result;
           } else {
-            return { value: this.#serializer(result), lastInsertId: result.lastInsertId };
+            results.rows.push(...result.rows);
+            results.lastInsertId = result.lastInsertId;
           }
-        });
+        }
+        return {
+          value: node.args.type === "rawSql" ? this.#rawSerializer(results) : this.#serializer(results),
+          lastInsertId: results?.lastInsertId
+        };
       }
       case "reverse": {
         const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
@@ -1231,43 +1651,12 @@ var QueryInterpreter = class _QueryInterpreter {
       case "diff": {
         const { value: from } = await this.interpretNode(node.args.from, queryable, scope, generators);
         const { value: to } = await this.interpretNode(node.args.to, queryable, scope, generators);
-        const toSet = new Set(asList(to));
-        return { value: asList(from).filter((item) => !toSet.has(item)) };
-      }
-      case "distinctBy": {
-        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
-        const seen = /* @__PURE__ */ new Set();
-        const result = [];
-        for (const item of asList(value)) {
-          const key = getRecordKey(item, node.args.fields);
-          if (!seen.has(key)) {
-            seen.add(key);
-            result.push(item);
-          }
-        }
-        return { value: result, lastInsertId };
+        const toSet = new Set(asList(to).map((item) => JSON.stringify(item)));
+        return { value: asList(from).filter((item) => !toSet.has(JSON.stringify(item))) };
       }
-      case "paginate": {
+      case "process": {
         const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
-        const list = asList(value);
-        const linkingFields = node.args.pagination.linkingFields;
-        if (linkingFields !== null) {
-          const groupedByParent = /* @__PURE__ */ new Map();
-          for (const item of list) {
-            const parentKey = getRecordKey(item, linkingFields);
-            if (!groupedByParent.has(parentKey)) {
-              groupedByParent.set(parentKey, []);
-            }
-            groupedByParent.get(parentKey).push(item);
-          }
-          const groupList = Array.from(groupedByParent.entries());
-          groupList.sort(([aId], [bId]) => aId < bId ? -1 : aId > bId ? 1 : 0);
-          return {
-            value: groupList.flatMap(([, elems]) => paginate(elems, node.args.pagination)),
-            lastInsertId
-          };
-        }
-        return { value: paginate(list, node.args.pagination), lastInsertId };
+        return { value: processRecords(value, node.args.operations), lastInsertId };
       }
       case "initializeRecord": {
         const { lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
@@ -1289,6 +1678,34 @@ var QueryInterpreter = class _QueryInterpreter {
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
   }
+  #maxChunkSize() {
+    if (this.#connectioInfo?.maxBindValues !== void 0) {
+      return this.#connectioInfo.maxBindValues;
+    }
+    return this.#providerMaxChunkSize();
+  }
+  #providerMaxChunkSize() {
+    if (this.#provider === void 0) {
+      return void 0;
+    }
+    switch (this.#provider) {
+      case "cockroachdb":
+      case "postgres":
+      case "postgresql":
+      case "prisma+postgres":
+        return 32766;
+      case "mysql":
+        return 65535;
+      case "sqlite":
+        return 999;
+      case "sqlserver":
+        return 2098;
+      case "mongodb":
+        return void 0;
+      default:
+        assertNever(this.#provider, `Unexpected provider: ${this.#provider}`);
+    }
+  }
   #withQuerySpanAndEvent(query, queryable, execute) {
     return withQuerySpanAndEvent({
       query,
@@ -1366,18 +1783,6 @@ function attachChildrenToParents(parentRecords, children) {
   }
   return parentRecords;
 }
-function paginate(list, { cursor, skip, take }) {
-  const cursorIndex = cursor !== null ? list.findIndex((item) => doKeysMatch(item, cursor)) : 0;
-  if (cursorIndex === -1) {
-    return [];
-  }
-  const start = cursorIndex + (skip ?? 0);
-  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 evalFieldInitializer(initializer, lastInsertId, scope, generators) {
   switch (initializer.type) {
     case "value":
@@ -1411,54 +1816,36 @@ function evalFieldOperation(op, value, scope, generators) {
   }
 }
 
-// src/json-protocol.ts
-var import_decimal3 = require("decimal.js");
-function normalizeJsonProtocolValues(result) {
-  if (result === null) {
-    return result;
-  }
-  if (Array.isArray(result)) {
-    return result.map(normalizeJsonProtocolValues);
-  }
-  if (typeof result === "object") {
-    if (isTaggedValue(result)) {
-      return normalizeTaggedValue(result);
-    }
-    if (result.constructor !== null && result.constructor.name !== "Object") {
-      return result;
+// src/raw-json-protocol.ts
+var import_decimal4 = __toESM(require("decimal.js"));
+function normalizeRawJsonProtocolResponse(response) {
+  for (let i = 0; i < response.rows.length; i++) {
+    const row = response.rows[i];
+    for (let j = 0; j < row.length; j++) {
+      row[j] = normalizeValue(response.types[j], row[j]);
     }
-    return mapObjectValues(result, normalizeJsonProtocolValues);
   }
-  return result;
-}
-function isTaggedValue(value) {
-  return value !== null && typeof value == "object" && typeof value["$type"] === "string";
+  return response;
 }
-function normalizeTaggedValue({ $type, value }) {
-  switch ($type) {
-    case "BigInt":
-      return { $type, value: String(value) };
-    case "Bytes":
-      return { $type, value };
-    case "DateTime":
-      return { $type, value: new Date(value).toISOString() };
-    case "Decimal":
-      return { $type, value: String(new import_decimal3.Decimal(value)) };
-    case "Json":
-      return { $type, value: JSON.stringify(JSON.parse(value)) };
-    default:
-      assertNever(value, "Unknown tagged value");
+function normalizeValue(type, value) {
+  if (value === null) {
+    return value;
   }
-}
-function mapObjectValues(object, mapper) {
-  const result = {};
-  for (const key of Object.keys(object)) {
-    result[key] = mapper(object[key], key);
+  switch (type) {
+    case "bigint":
+      return String(BigInt(value));
+    case "decimal":
+      return String(new import_decimal4.default(value));
+    case "bigint-array":
+      return value.map((v) => normalizeValue("bigint", v));
+    case "decimal-array":
+      return value.map((v) => normalizeValue("decimal", v));
+    default:
+      return value;
   }
-  return result;
 }
 
-// src/transactionManager/TransactionManager.ts
+// src/transaction-manager/transaction-manager.ts
 var import_debug = require("@prisma/debug");
 
 // src/crypto.ts
@@ -1470,7 +1857,7 @@ async function randomUUID() {
   return crypto.randomUUID();
 }
 
-// src/transactionManager/TransactionManagerErrors.ts
+// src/transaction-manager/transaction-manager-error.ts
 var TransactionManagerError = class extends UserFacingError {
   name = "TransactionManagerError";
   constructor(message, meta) {
@@ -1507,7 +1894,7 @@ var TransactionStartTimeoutError = class extends TransactionManagerError {
 var TransactionExecutionTimeoutError = class extends TransactionManagerError {
   constructor(operation, { timeout, timeTaken }) {
     super(
-      `A ${operation} cannot be executed on an expired transaction. The timeout for this transaction was ${timeout} ms, however ${timeTaken} ms passed since the start of the transaction. Consider increasing the interactive transaction timeout or doing less work in the transaction`,
+      `A ${operation} cannot be executed on an expired transaction. The timeout for this transaction was ${timeout} ms, however ${timeTaken} ms passed since the start of the transaction. Consider increasing the interactive transaction timeout or doing less work in the transaction.`,
       { operation, timeout, timeTaken }
     );
   }
@@ -1523,7 +1910,7 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
   }
 };
 
-// src/transactionManager/TransactionManager.ts
+// src/transaction-manager/transaction-manager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
 var debug = (0, import_debug.Debug)("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
@@ -1578,7 +1965,7 @@ var TransactionManager = class {
     this.transactions.set(transaction.id, transaction);
     let hasTimedOut = false;
     const startTimer = setTimeout(() => hasTimedOut = true, validatedOptions.maxWait);
-    transaction.transaction = await this.driverAdapter.startTransaction(validatedOptions.isolationLevel);
+    transaction.transaction = await this.driverAdapter.startTransaction(validatedOptions.isolationLevel).catch(rethrowAsUserFacing);
     clearTimeout(startTimer);
     switch (transaction.status) {
       case "waiting":
@@ -1726,6 +2113,8 @@ var TransactionManager = class {
   TransactionManager,
   TransactionManagerError,
   UserFacingError,
+  convertCompactedRows,
+  deserializeJsonResponse,
   doKeysMatch,
   isDeepStrictEqual,
   isPrismaValueBigInt,
@@ -1734,5 +2123,6 @@ var TransactionManager = class {
   isPrismaValuePlaceholder,
   noopTracingHelper,
   normalizeJsonProtocolValues,
+  normalizeRawJsonProtocolResponse,
   safeJsonStringify
 });