@prisma/client-engine-runtime 6.9.0-dev.2 → 6.9.0-dev.21

package/dist/index.mjs

@@ -1,10 +1,144 @@
-// src/interpreter/QueryInterpreter.ts
-import { SpanKind } from "@opentelemetry/api";
+// src/interpreter/DataMapper.ts
+import Decimal2 from "decimal.js";
 
 // src/utils.ts
+import Decimal from "decimal.js";
 function assertNever(_, message) {
   throw new Error(message);
 }
+function isDeepStrictEqual(a, b) {
+  return a === b || a !== null && b !== null && typeof a === "object" && typeof b === "object" && Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((key) => isDeepStrictEqual(a[key], b[key]));
+}
+function doKeysMatch(lhs, rhs) {
+  const lhsKeys = Object.keys(lhs);
+  const rhsKeys = Object.keys(rhs);
+  const smallerKeyList = lhsKeys.length < rhsKeys.length ? lhsKeys : rhsKeys;
+  return smallerKeyList.every((key) => {
+    if (typeof lhs[key] !== typeof rhs[key]) {
+      if (typeof lhs[key] === "number" || typeof rhs[key] === "number") {
+        return `${lhs[key]}` === `${rhs[key]}`;
+      } else if (typeof lhs[key] === "bigint" || typeof rhs[key] === "bigint") {
+        return BigInt(`${lhs[key]}`.replace(/n$/, "")) === BigInt(`${rhs[key]}`.replace(/n$/, ""));
+      } else if (lhs[key] instanceof Date || rhs[key] instanceof Date) {
+        return (/* @__PURE__ */ new Date(`${lhs[key]}`)).getTime() === (/* @__PURE__ */ new Date(`${rhs[key]}`)).getTime();
+      } else if (Decimal.isDecimal(lhs[key]) || Decimal.isDecimal(rhs[key])) {
+        return new Decimal(`${lhs[key]}`).equals(new Decimal(`${rhs[key]}`));
+      }
+    }
+    return isDeepStrictEqual(lhs[key], rhs[key]);
+  });
+}
+
+// src/interpreter/DataMapper.ts
+var DataMapperError = class extends Error {
+  name = "DataMapperError";
+};
+function applyDataMap(data, structure) {
+  switch (structure.type) {
+    case "Object":
+      return mapArrayOrObject(data, structure.fields);
+    case "Value":
+      return mapValue(data, structure.resultType);
+    default:
+      assertNever(structure, `Invalid data mapping type: '${structure.type}'`);
+  }
+}
+function mapArrayOrObject(data, fields) {
+  if (data === null) return null;
+  if (Array.isArray(data)) {
+    const rows = data;
+    return rows.map((row) => mapObject(row, fields));
+  }
+  if (typeof data === "object") {
+    const row = data;
+    return mapObject(row, fields);
+  }
+  if (typeof data === "string") {
+    let decodedData;
+    try {
+      decodedData = JSON.parse(data);
+    } catch (error) {
+      throw new DataMapperError(`Expected an array or object, got a string that is not valid JSON`, {
+        cause: error
+      });
+    }
+    return mapArrayOrObject(decodedData, fields);
+  }
+  throw new DataMapperError(`Expected an array or an object, got: ${typeof data}`);
+}
+function mapObject(data, fields) {
+  if (typeof data !== "object") {
+    throw new DataMapperError(`Expected an object, but got '${typeof data}'`);
+  }
+  const result = {};
+  for (const [name, node] of Object.entries(fields)) {
+    switch (node.type) {
+      case "Object": {
+        if (!node.flattened && !Object.hasOwn(data, name)) {
+          throw new DataMapperError(
+            `Missing data field (Object): '${name}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
+          );
+        }
+        const target = node.flattened ? data : data[name];
+        result[name] = mapArrayOrObject(target, node.fields);
+        break;
+      }
+      case "Value":
+        {
+          const dbName = node.dbName;
+          if (Object.hasOwn(data, dbName)) {
+            result[name] = mapValue(data[dbName], node.resultType);
+          } else {
+            throw new DataMapperError(
+              `Missing data field (Value): '${dbName}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
+            );
+          }
+        }
+        break;
+      default:
+        assertNever(node, `DataMapper: Invalid data mapping node type: '${node.type}'`);
+    }
+  }
+  return result;
+}
+function mapValue(value, resultType) {
+  if (value === null) return null;
+  switch (resultType.type) {
+    case "Any":
+      return value;
+    case "String":
+      return typeof value === "string" ? value : `${value}`;
+    case "Int":
+      return typeof value === "number" ? value : parseInt(`${value}`, 10);
+    case "BigInt":
+      return typeof value === "bigint" ? value : BigInt(`${value}`);
+    case "Float":
+      return typeof value === "number" ? value : parseFloat(`${value}`);
+    case "Boolean":
+      return typeof value === "boolean" ? value : value !== "0";
+    case "Decimal":
+      return typeof value === "number" ? new Decimal2(value) : new Decimal2(`${value}`);
+    case "Date":
+      return value instanceof Date ? value : /* @__PURE__ */ new Date(`${value}`);
+    case "Array": {
+      const values = value;
+      return values.map((v) => mapValue(v, resultType.inner));
+    }
+    case "Object":
+      return typeof value === "string" ? value : JSON.stringify(value);
+    case "Bytes": {
+      if (!Array.isArray(value)) {
+        throw new DataMapperError(`Bytes data is invalid, got: ${typeof value}`);
+      }
+      return new Uint8Array(value);
+    }
+    default:
+      assertNever(resultType, `DataMapper: Unknown result type: ${resultType.type}`);
+  }
+}
+
+// src/interpreter/QueryInterpreter.ts
+import { SpanKind } from "@opentelemetry/api";
 
 // src/tracing.ts
 var noopTracingHelper = {
@@ -34,7 +168,7 @@ var UserFacingError = class extends Error {
   constructor(message, code, meta) {
     super(message);
     this.code = code;
-    this.meta = meta;
+    this.meta = meta ?? {};
   }
   toQueryResponseErrorObject() {
     return {
@@ -57,7 +191,7 @@ function rethrowAsUserFacing(error) {
   if (!code || !message) {
     throw error;
   }
-  throw new UserFacingError(message, code, error);
+  throw new UserFacingError(message, code, { driverAdapterError: error });
 }
 function getErrorCode(err) {
   switch (err.cause.kind) {
@@ -168,100 +302,6 @@ function renderConstraint(constraint) {
   return "(not available)";
 }
 
-// src/interpreter/DataMapper.ts
-import Decimal from "decimal.js";
-function applyDataMap(data, structure) {
-  switch (structure.type) {
-    case "Object":
-      return mapArrayOrObject(data, structure.fields);
-    case "Value":
-      return mapValue(data, structure.resultType);
-    default:
-      assertNever(structure, `Invalid data mapping type: '${structure.type}'`);
-  }
-}
-function mapArrayOrObject(data, fields) {
-  if (data === null) return null;
-  if (Array.isArray(data)) {
-    const rows = data;
-    return rows.map((row) => mapObject(row, fields));
-  }
-  if (typeof data === "object") {
-    const row = data;
-    return mapObject(row, fields);
-  }
-  throw new Error(`DataMapper: Expected an array or an object, got: ${typeof data}`);
-}
-function mapObject(data, fields) {
-  if (typeof data !== "object") {
-    throw new Error(`DataMapper: Expected an object, but got '${typeof data}'`);
-  }
-  const result = {};
-  for (const [name, node] of Object.entries(fields)) {
-    switch (node.type) {
-      case "Object":
-        if (Object.hasOwn(data, name)) {
-          result[name] = mapArrayOrObject(data[name], node.fields);
-        } else {
-          throw new Error(
-            `DataMapper: Missing data field (Object): '${name}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
-          );
-        }
-        break;
-      case "Value":
-        {
-          const dbName = node.dbName;
-          if (Object.hasOwn(data, dbName)) {
-            result[name] = mapValue(data[dbName], node.resultType);
-          } else {
-            throw new Error(
-              `DataMapper: Missing data field (Value): '${dbName}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
-            );
-          }
-        }
-        break;
-      default:
-        assertNever(node, `DataMapper: Invalid data mapping node type: '${node.type}'`);
-    }
-  }
-  return result;
-}
-function mapValue(value, resultType) {
-  if (value === null) return null;
-  switch (resultType.type) {
-    case "Any":
-      return value;
-    case "String":
-      return typeof value === "string" ? value : `${value}`;
-    case "Int":
-      return typeof value === "number" ? value : parseInt(`${value}`, 10);
-    case "BigInt":
-      return typeof value === "bigint" ? value : BigInt(`${value}`);
-    case "Float":
-      return typeof value === "number" ? value : parseFloat(`${value}`);
-    case "Boolean":
-      return typeof value === "boolean" ? value : value !== "0";
-    case "Decimal":
-      return typeof value === "number" ? new Decimal(value) : new Decimal(`${value}`);
-    case "Date":
-      return value instanceof Date ? value : /* @__PURE__ */ new Date(`${value}`);
-    case "Array": {
-      const values = value;
-      return values.map((v) => mapValue(v, resultType.inner));
-    }
-    case "Object":
-      return typeof value === "string" ? value : JSON.stringify(value);
-    case "Bytes": {
-      if (!Array.isArray(value)) {
-        throw new Error(`DataMapper: Bytes data is invalid, got: ${typeof value}`);
-      }
-      return new Uint8Array(value);
-    }
-    default:
-      assertNever(resultType, `DataMapper: Unknown result type: ${resultType.type}`);
-  }
-}
-
 // src/interpreter/generators.ts
 import cuid1 from "@bugsnag/cuid";
 import { createId as cuid2 } from "@paralleldrive/cuid2";
@@ -366,6 +406,9 @@ function isPrismaValueGenerator(value) {
 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/renderQuery.ts
 function renderQuery(dbQuery, scope, generators) {
@@ -408,9 +451,10 @@ function evaluateParam(param, scope, generators) {
   }
   if (Array.isArray(value)) {
     value = value.map((el) => evaluateParam(el, scope, generators));
-  }
-  if (isPrismaValueBytes(value)) {
+  } else if (isPrismaValueBytes(value)) {
     value = Buffer.from(value.prisma__value, "base64");
+  } else if (isPrismaValueBigInt(value)) {
+    value = BigInt(value.prisma__value);
   }
   return value;
 }
@@ -504,6 +548,7 @@ function doesRequireEvaluation(param) {
 }
 
 // src/interpreter/serializeSql.ts
+import { ColumnTypeEnum } from "@prisma/driver-adapter-utils";
 function serializeSql(resultSet) {
   return resultSet.rows.map(
     (row) => row.reduce((acc, value, index) => {
@@ -524,6 +569,85 @@ function serializeSql(resultSet) {
     }, {})
   );
 }
+function serializeRawSql(resultSet) {
+  return {
+    columns: resultSet.columnNames,
+    types: resultSet.columnTypes.map((type) => serializeColumnType(type)),
+    rows: resultSet.rows
+  };
+}
+function serializeColumnType(columnType) {
+  switch (columnType) {
+    case ColumnTypeEnum.Int32:
+      return "int";
+    case ColumnTypeEnum.Int64:
+      return "bigint";
+    case ColumnTypeEnum.Float:
+      return "float";
+    case ColumnTypeEnum.Double:
+      return "double";
+    case ColumnTypeEnum.Text:
+      return "string";
+    case ColumnTypeEnum.Enum:
+      return "enum";
+    case ColumnTypeEnum.Bytes:
+      return "bytes";
+    case ColumnTypeEnum.Boolean:
+      return "bool";
+    case ColumnTypeEnum.Character:
+      return "char";
+    case ColumnTypeEnum.Numeric:
+      return "decimal";
+    case ColumnTypeEnum.Json:
+      return "json";
+    case ColumnTypeEnum.Uuid:
+      return "uuid";
+    case ColumnTypeEnum.DateTime:
+      return "datetime";
+    case ColumnTypeEnum.Date:
+      return "date";
+    case ColumnTypeEnum.Time:
+      return "time";
+    case ColumnTypeEnum.Int32Array:
+      return "int-array";
+    case ColumnTypeEnum.Int64Array:
+      return "bigint-array";
+    case ColumnTypeEnum.FloatArray:
+      return "float-array";
+    case ColumnTypeEnum.DoubleArray:
+      return "double-array";
+    case ColumnTypeEnum.TextArray:
+      return "string-array";
+    case ColumnTypeEnum.EnumArray:
+      return "string-array";
+    case ColumnTypeEnum.BytesArray:
+      return "bytes-array";
+    case ColumnTypeEnum.BooleanArray:
+      return "bool-array";
+    case ColumnTypeEnum.CharacterArray:
+      return "char-array";
+    case ColumnTypeEnum.NumericArray:
+      return "decimal-array";
+    case ColumnTypeEnum.JsonArray:
+      return "json-array";
+    case ColumnTypeEnum.UuidArray:
+      return "uuid-array";
+    case ColumnTypeEnum.DateTimeArray:
+      return "datetime-array";
+    case ColumnTypeEnum.DateArray:
+      return "date-array";
+    case ColumnTypeEnum.TimeArray:
+      return "time-array";
+    case ColumnTypeEnum.UnknownNumber:
+      return "unknown";
+    /// The following PlanetScale type IDs are mapped into Set:
+    /// - SET (SET) -> e.g. `"foo,bar"` (String-encoded, comma-separated)
+    case ColumnTypeEnum.Set:
+      return "string";
+    default:
+      assertNever(columnType, `Unexpected column type: ${columnType}`);
+  }
+}
 
 // src/interpreter/validation.ts
 function performValidation(data, rules, error) {
@@ -551,6 +675,8 @@ function doesSatisfyRule(data, rule) {
         return rule.args !== 0;
       }
       return rule.args !== 1;
+    case "affectedRowCountEq":
+      return data === rule.args;
     case "never":
       return false;
     default:
@@ -568,7 +694,9 @@ function renderMessage(data, error) {
       return `An operation failed because it depends on one or more records that were required but not found. No '${error.context.model}' record${hint} was found for ${error.context.operation} on ${error.context.relationType} relation '${error.context.relation}'.`;
     }
     case "INCOMPLETE_CONNECT_INPUT":
-      return `An operation failed because it depends on one or more records that were required but not found. Expected ${error.context.expectedRows} records to be connected, found only ${Array.isArray(data) ? data.length : 0}.`;
+      return `An operation failed because it depends on one or more records that were required but not found. Expected ${error.context.expectedRows} records to be connected, found only ${Array.isArray(data) ? data.length : data}.`;
+    case "INCOMPLETE_CONNECT_OUTPUT":
+      return `The required connected records were not found. Expected ${error.context.expectedRows} records to be connected after connect operation on ${error.context.relationType} relation '${error.context.relation}', found ${Array.isArray(data) ? data.length : data}.`;
     case "RECORDS_NOT_CONNECTED":
       return `The records for relation \`${error.context.relation}\` between the \`${error.context.parent}\` and \`${error.context.child}\` models are not connected.`;
     default:
@@ -581,6 +709,8 @@ function getErrorCode2(error) {
       return "P2014";
     case "RECORDS_NOT_CONNECTED":
       return "P2017";
+    case "INCOMPLETE_CONNECT_OUTPUT":
+      return "P2018";
     case "MISSING_RECORD":
     case "MISSING_RELATED_RECORD":
     case "INCOMPLETE_CONNECT_INPUT":
@@ -598,12 +728,21 @@ var QueryInterpreter = class _QueryInterpreter {
   #generators = new GeneratorRegistry();
   #tracingHelper;
   #serializer;
-  constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer }) {
+  #rawSerializer;
+  constructor({
+    transactionManager,
+    placeholderValues,
+    onQuery,
+    tracingHelper,
+    serializer,
+    rawSerializer
+  }) {
     this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
     this.#tracingHelper = tracingHelper;
     this.#serializer = serializer;
+    this.#rawSerializer = rawSerializer ?? serializer;
   }
   static forSql(options) {
     return new _QueryInterpreter({
@@ -611,7 +750,8 @@ var QueryInterpreter = class _QueryInterpreter {
       placeholderValues: options.placeholderValues,
       onQuery: options.onQuery,
       tracingHelper: options.tracingHelper,
-      serializer: serializeSql
+      serializer: serializeSql,
+      rawSerializer: serializeRawSql
     });
   }
   async run(queryPlan, queryable) {
@@ -622,8 +762,11 @@ var QueryInterpreter = class _QueryInterpreter {
   async interpretNode(node, queryable, scope, generators) {
     switch (node.type) {
       case "seq": {
-        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
-        return results[results.length - 1];
+        let result;
+        for (const arg of node.args) {
+          result = await this.interpretNode(arg, queryable, scope, generators);
+        }
+        return result;
       }
       case "get": {
         return scope[node.args.name];
@@ -646,11 +789,11 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "concat": {
         const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
-        return parts.reduce((acc, part) => acc.concat(asList(part)), []);
+        return parts.length > 0 ? parts.reduce((acc, part) => acc.concat(asList(part)), []) : [];
       }
       case "sum": {
         const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators)));
-        return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
+        return parts.length > 0 ? parts.reduce((acc, part) => asNumber(acc) + asNumber(part)) : 0;
       }
       case "execute": {
         const query = renderQuery(node.args, scope, generators);
@@ -661,7 +804,11 @@ var QueryInterpreter = class _QueryInterpreter {
       case "query": {
         const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, queryable, async () => {
-          return this.#serializer(await queryable.queryRaw(query));
+          if (node.args.type === "rawSql") {
+            return this.#rawSerializer(await queryable.queryRaw(query));
+          } else {
+            return this.#serializer(await queryable.queryRaw(query));
+          }
         });
       }
       case "reverse": {
@@ -691,6 +838,9 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "join": {
         const parent = await this.interpretNode(node.args.parent, queryable, scope, generators);
+        if (parent === null) {
+          return null;
+        }
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
@@ -747,6 +897,38 @@ var QueryInterpreter = class _QueryInterpreter {
         const toSet = new Set(asList(to));
         return asList(from).filter((item) => !toSet.has(item));
       }
+      case "distinctBy": {
+        const value = 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 result;
+      }
+      case "paginate": {
+        const value = 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 groupList.flatMap(([, elems]) => paginate(elems, node.args.pagination));
+        }
+        return paginate(list, node.args.pagination);
+      }
       default:
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
@@ -818,7 +1000,12 @@ function attachChildrenToParent(parentRecord, children) {
 }
 function filterChildRecords(records, parentRecord, joinExpr) {
   if (Array.isArray(records)) {
-    return records.filter((record) => childRecordMatchesParent(asRecord(record), parentRecord, joinExpr));
+    const filtered = records.filter((record) => childRecordMatchesParent(asRecord(record), parentRecord, joinExpr));
+    if (joinExpr.isRelationUnique) {
+      return filtered.length > 0 ? filtered[0] : null;
+    } else {
+      return filtered;
+    }
   } else if (records === null) {
     return null;
   } else {
@@ -834,6 +1021,18 @@ function childRecordMatchesParent(childRecord, parentRecord, joinExpr) {
   }
   return true;
 }
+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]));
+}
 
 // src/transactionManager/TransactionManager.ts
 import { Debug } from "@prisma/debug";
@@ -848,12 +1047,11 @@ async function randomUUID() {
 }
 
 // src/transactionManager/TransactionManagerErrors.ts
-var TransactionManagerError = class extends Error {
+var TransactionManagerError = class extends UserFacingError {
+  name = "TransactionManagerError";
   constructor(message, meta) {
-    super("Transaction API error: " + message);
-    this.meta = meta;
+    super("Transaction API error: " + message, "P2028", meta);
   }
-  code = "P2028";
 };
 var TransactionNotFoundError = class extends TransactionManagerError {
   constructor() {
@@ -864,12 +1062,12 @@ var TransactionNotFoundError = class extends TransactionManagerError {
 };
 var TransactionClosedError = class extends TransactionManagerError {
   constructor(operation) {
-    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction.`);
   }
 };
 var TransactionRolledBackError = class extends TransactionManagerError {
   constructor(operation) {
-    super(`Transaction already closed: A ${operation} cannot be executed on a transaction that was rolled back`);
+    super(`Transaction already closed: A ${operation} cannot be executed on a transaction that was rolled back.`);
   }
 };
 var TransactionStartTimeoutError = class extends TransactionManagerError {
@@ -1051,10 +1249,14 @@ var TransactionManager = class {
   }
 };
 export {
+  DataMapperError,
   QueryInterpreter,
   TransactionManager,
   TransactionManagerError,
   UserFacingError,
+  doKeysMatch,
+  isDeepStrictEqual,
+  isPrismaValueBigInt,
   isPrismaValueBytes,
   isPrismaValueGenerator,
   isPrismaValuePlaceholder,

package/dist/interpreter/DataMapper.d.ts

@@ -1,3 +1,6 @@
 import { ResultNode } from '../QueryPlan';
 import { Value } from './scope';
+export declare class DataMapperError extends Error {
+    name: string;
+}
 export declare function applyDataMap(data: Value, structure: ResultNode): Value;

package/dist/interpreter/QueryInterpreter.d.ts

@@ -16,10 +16,11 @@ export type QueryInterpreterOptions = {
     onQuery?: (event: QueryEvent) => void;
     tracingHelper: TracingHelper;
     serializer: (results: SqlResultSet) => Value;
+    rawSerializer?: (results: SqlResultSet) => Value;
 };
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer }: QueryInterpreterOptions);
+    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, }: QueryInterpreterOptions);
     static forSql(options: {
         transactionManager: QueryInterpreterTransactionManager;
         placeholderValues: Record<string, unknown>;

package/dist/interpreter/serializeSql.d.ts

@@ -1,2 +1,3 @@
-import type { SqlResultSet } from '@prisma/driver-adapter-utils';
+import { type SqlResultSet } from '@prisma/driver-adapter-utils';
 export declare function serializeSql(resultSet: SqlResultSet): Record<string, unknown>[];
+export declare function serializeRawSql(resultSet: SqlResultSet): Record<string, unknown>;

package/dist/transactionManager/TransactionManagerErrors.d.ts

@@ -1,7 +1,7 @@
-export declare class TransactionManagerError extends Error {
-    meta?: Record<string, unknown> | undefined;
-    code: string;
-    constructor(message: string, meta?: Record<string, unknown> | undefined);
+import { UserFacingError } from '../UserFacingError';
+export declare class TransactionManagerError extends UserFacingError {
+    name: string;
+    constructor(message: string, meta?: Record<string, unknown>);
 }
 export declare class TransactionNotFoundError extends TransactionManagerError {
     constructor();

package/dist/utils.d.ts

@@ -1 +1,11 @@
 export declare function assertNever(_: never, message: string): never;
+/**
+ * Checks if two objects are deeply equal, recursively checking all properties for strict equality.
+ */
+export declare function isDeepStrictEqual(a: unknown, b: unknown): boolean;
+/**
+ * Checks if two objects representing the names and values of key columns match. A match is
+ * defined by one of the sets of keys being a subset of the other. This function also
+ * converts arguments to the types used by driver adapters if necessary.
+ */
+export declare function doKeysMatch(lhs: {}, rhs: {}): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "6.9.0-dev.2",
+  "version": "6.9.0-dev.21",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,8 +31,8 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/debug": "6.9.0-dev.2",
-    "@prisma/driver-adapter-utils": "6.9.0-dev.2"
+    "@prisma/debug": "6.9.0-dev.21",
+    "@prisma/driver-adapter-utils": "6.9.0-dev.21"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",