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

package/dist/index.mjs

@@ -1,12 +1,236 @@
-// 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]);
+  });
+}
+function safeJsonStringify(obj) {
+  return JSON.stringify(obj, (_key, val) => {
+    if (typeof val === "bigint") {
+      return val.toString();
+    } else if (val instanceof Uint8Array) {
+      return Buffer.from(val).toString("base64");
+    }
+    return val;
+  });
+}
+
+// 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, "<result>", 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], 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, columnName, resultType) {
+  if (value === null) {
+    return resultType.type === "Array" ? [] : null;
+  }
+  switch (resultType.type) {
+    case "Any":
+      return value;
+    case "String": {
+      if (typeof value !== "string") {
+        throw new DataMapperError(`Expected a string in column '${columnName}', got ${typeof value}: ${value}`);
+      }
+      return value;
+    }
+    case "Int": {
+      switch (typeof value) {
+        case "number": {
+          return Math.trunc(value);
+        }
+        case "string": {
+          const numberValue = Math.trunc(Number(value));
+          if (Number.isNaN(numberValue) || !Number.isFinite(numberValue)) {
+            throw new DataMapperError(`Expected an integer in column '${columnName}', got string: ${value}`);
+          }
+          if (!Number.isSafeInteger(numberValue)) {
+            throw new DataMapperError(
+              `Integer value in column '${columnName}' is too large to represent as a JavaScript number without loss of precision, got: ${value}. Consider using BigInt type.`
+            );
+          }
+          return numberValue;
+        }
+        default:
+          throw new DataMapperError(`Expected an integer in column '${columnName}', got ${typeof value}: ${value}`);
+      }
+    }
+    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": {
+      if (typeof value === "number") return value;
+      if (typeof value === "string") {
+        const parsedValue = Number(value);
+        if (Number.isNaN(parsedValue) && !/^[-+]?nan$/.test(value.toLowerCase())) {
+          throw new DataMapperError(`Expected a float in column '${columnName}', got string: ${value}`);
+        }
+        return parsedValue;
+      }
+      throw new DataMapperError(`Expected a float in column '${columnName}', got ${typeof value}: ${value}`);
+    }
+    case "Boolean": {
+      if (typeof value === "boolean") return value;
+      if (typeof value === "number") return value === 1;
+      if (typeof value === "string") {
+        if (value === "true" || value === "TRUE" || value === "1") {
+          return true;
+        } else if (value === "false" || value === "FALSE" || value === "0") {
+          return false;
+        } else {
+          throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
+        }
+      }
+      throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
+    }
+    case "Decimal":
+      if (typeof value !== "number" && typeof value !== "string" && !Decimal2.isDecimal(value)) {
+        throw new DataMapperError(`Expected a decimal in column '${columnName}', got ${typeof value}: ${value}`);
+      }
+      return { $type: "Decimal", value };
+    case "Date": {
+      if (typeof value === "string") {
+        return { $type: "DateTime", value: ensureTimezoneInIsoString(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));
+    }
+    case "Object": {
+      const jsonValue = typeof value === "string" ? value : safeJsonStringify(value);
+      return { $type: "Json", value: jsonValue };
+    }
+    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") };
+      }
+      throw new DataMapperError(`Expected a byte array in column '${columnName}', got ${typeof value}: ${value}`);
+    }
+    default:
+      assertNever(resultType, `DataMapper: Unknown result type: ${resultType.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) {
+    return `${dt}Z`;
+  } else if (results[0] !== "Z" && results[1] === void 0) {
+    return `${dt}:00`;
+  } else {
+    return dt;
+  }
+}
 
 // src/tracing.ts
+import { SpanKind } from "@opentelemetry/api";
 var noopTracingHelper = {
   runInChildSpan(_, callback) {
     return callback();
@@ -24,6 +248,37 @@ function providerToOtelSystem(provider) {
       assertNever(provider, `Unknown provider: ${provider}`);
   }
 }
+async function withQuerySpanAndEvent({
+  query,
+  queryable,
+  tracingHelper,
+  onQuery,
+  execute
+}) {
+  return await tracingHelper.runInChildSpan(
+    {
+      name: "db_query",
+      kind: SpanKind.CLIENT,
+      attributes: {
+        "db.query.text": query.sql,
+        "db.system.name": providerToOtelSystem(queryable.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
 import { isDriverAdapterError } from "@prisma/driver-adapter-utils";
@@ -34,7 +289,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 +312,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,101 +423,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 (!node.flattened && !Object.hasOwn(data, name)) {
-          throw new Error(
-            `DataMapper: 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 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";
@@ -367,6 +527,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) {
@@ -409,9 +572,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;
 }
@@ -505,6 +669,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) => {
@@ -525,6 +690,96 @@ function serializeSql(resultSet) {
     }, {})
   );
 }
+function serializeRawSql(resultSet) {
+  const types = resultSet.columnTypes.map((type) => serializeColumnType(type));
+  const mappers = types.map((type) => {
+    switch (type) {
+      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}`);
+      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)))
+  };
+}
+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) {
@@ -552,6 +807,8 @@ function doesSatisfyRule(data, rule) {
         return rule.args !== 0;
       }
       return rule.args !== 1;
+    case "affectedRowCountEq":
+      return data === rule.args;
     case "never":
       return false;
     default:
@@ -569,7 +826,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:
@@ -582,6 +841,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":
@@ -599,12 +860,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({
@@ -612,7 +882,8 @@ var QueryInterpreter = class _QueryInterpreter {
       placeholderValues: options.placeholderValues,
       onQuery: options.onQuery,
       tracingHelper: options.tracingHelper,
-      serializer: serializeSql
+      serializer: serializeSql,
+      rawSerializer: serializeRawSql
     });
   }
   async run(queryPlan, queryable) {
@@ -623,8 +894,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];
@@ -647,22 +921,26 @@ 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);
-        return this.#withQueryEvent(query, queryable, async () => {
+        return this.#withQuerySpanAndEvent(query, queryable, async () => {
           return await queryable.executeRaw(query);
         });
       }
       case "query": {
         const query = renderQuery(node.args, scope, generators);
-        return this.#withQueryEvent(query, queryable, async () => {
-          return this.#serializer(await queryable.queryRaw(query));
+        return this.#withQuerySpanAndEvent(query, queryable, async () => {
+          if (node.args.type === "rawSql") {
+            return this.#rawSerializer(await queryable.queryRaw(query));
+          } else {
+            return this.#serializer(await queryable.queryRaw(query));
+          }
         });
       }
       case "reverse": {
@@ -692,6 +970,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,
@@ -748,34 +1029,50 @@ 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}`);
     }
   }
-  #withQueryEvent(query, queryable, execute) {
-    return this.#tracingHelper.runInChildSpan(
-      {
-        name: "db_query",
-        kind: SpanKind.CLIENT,
-        attributes: {
-          "db.query.text": query.sql,
-          "db.system.name": providerToOtelSystem(queryable.provider)
-        }
-      },
-      async () => {
-        const timestamp = /* @__PURE__ */ new Date();
-        const startInstant = performance.now();
-        const result = await execute();
-        const endInstant = performance.now();
-        this.#onQuery?.({
-          timestamp,
-          duration: endInstant - startInstant,
-          query: query.sql,
-          params: query.args
-        });
-        return result;
-      }
-    );
+  #withQuerySpanAndEvent(query, queryable, execute) {
+    return withQuerySpanAndEvent({
+      query,
+      queryable,
+      execute,
+      tracingHelper: this.#tracingHelper,
+      onQuery: this.#onQuery
+    });
   }
 };
 function isEmpty(value) {
@@ -819,7 +1116,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 {
@@ -835,6 +1137,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";
@@ -849,12 +1163,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() {
@@ -865,12 +1178,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 {
@@ -902,6 +1215,16 @@ var MAX_CLOSED_TRANSACTIONS = 100;
 var debug = Debug("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
+var PHANTOM_COMMIT_QUERY = () => ({
+  sql: '-- Implicit "COMMIT" query via underlying driver',
+  args: [],
+  argTypes: []
+});
+var PHANTOM_ROLLBACK_QUERY = () => ({
+  sql: '-- Implicit "ROLLBACK" query via underlying driver',
+  args: [],
+  argTypes: []
+});
 var TransactionManager = class {
   // The map of active transactions.
   transactions = /* @__PURE__ */ new Map();
@@ -911,14 +1234,17 @@ var TransactionManager = class {
   driverAdapter;
   transactionOptions;
   tracingHelper;
+  #onQuery;
   constructor({
     driverAdapter,
     transactionOptions,
-    tracingHelper
+    tracingHelper,
+    onQuery
   }) {
     this.driverAdapter = driverAdapter;
     this.transactionOptions = transactionOptions;
     this.tracingHelper = tracingHelper;
+    this.#onQuery = onQuery;
   }
   async startTransaction(options) {
     return await this.tracingHelper.runInChildSpan("start_transaction", () => this.#startTransactionImpl(options));
@@ -1022,14 +1348,20 @@ var TransactionManager = class {
     debug("Closing transaction.", { transactionId: tx.id, status });
     tx.status = status;
     if (tx.transaction && status === "committed") {
-      await tx.transaction.commit();
-      if (!tx.transaction.options.usePhantomQuery) {
-        await tx.transaction.executeRaw(COMMIT_QUERY());
+      if (tx.transaction.options.usePhantomQuery) {
+        await this.#withQuerySpanAndEvent(PHANTOM_COMMIT_QUERY(), tx.transaction, () => tx.transaction.commit());
+      } else {
+        await tx.transaction.commit();
+        const query = COMMIT_QUERY();
+        await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
       }
     } else if (tx.transaction) {
-      await tx.transaction.rollback();
-      if (!tx.transaction.options.usePhantomQuery) {
-        await tx.transaction.executeRaw(ROLLBACK_QUERY());
+      if (tx.transaction.options.usePhantomQuery) {
+        await this.#withQuerySpanAndEvent(PHANTOM_ROLLBACK_QUERY(), tx.transaction, () => tx.transaction.rollback());
+      } else {
+        await tx.transaction.rollback();
+        const query = ROLLBACK_QUERY();
+        await this.#withQuerySpanAndEvent(query, tx.transaction, () => tx.transaction.executeRaw(query));
       }
     }
     clearTimeout(tx.timer);
@@ -1050,14 +1382,28 @@ var TransactionManager = class {
       maxWait: options.maxWait
     };
   }
+  #withQuerySpanAndEvent(query, queryable, execute) {
+    return withQuerySpanAndEvent({
+      query,
+      queryable,
+      execute,
+      tracingHelper: this.tracingHelper,
+      onQuery: this.#onQuery
+    });
+  }
 };
 export {
+  DataMapperError,
   QueryInterpreter,
   TransactionManager,
   TransactionManagerError,
   UserFacingError,
+  doKeysMatch,
+  isDeepStrictEqual,
+  isPrismaValueBigInt,
   isPrismaValueBytes,
   isPrismaValueGenerator,
   isPrismaValuePlaceholder,
-  noopTracingHelper
+  noopTracingHelper,
+  safeJsonStringify
 };