@prisma/client-engine-runtime 6.9.0-dev.5 → 6.9.0-dev.51

package/dist/index.js

@@ -30,26 +30,274 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DataMapperError: () => DataMapperError,
   QueryInterpreter: () => QueryInterpreter,
   TransactionManager: () => TransactionManager,
   TransactionManagerError: () => TransactionManagerError,
   UserFacingError: () => UserFacingError,
+  doKeysMatch: () => doKeysMatch,
+  isDeepStrictEqual: () => isDeepStrictEqual,
+  isPrismaValueBigInt: () => isPrismaValueBigInt,
   isPrismaValueBytes: () => isPrismaValueBytes,
   isPrismaValueGenerator: () => isPrismaValueGenerator,
   isPrismaValuePlaceholder: () => isPrismaValuePlaceholder,
-  noopTracingHelper: () => noopTracingHelper
+  noopTracingHelper: () => noopTracingHelper,
+  safeJsonStringify: () => safeJsonStringify
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/interpreter/QueryInterpreter.ts
-var import_api = require("@opentelemetry/api");
+// src/interpreter/DataMapper.ts
+var import_decimal2 = __toESM(require("decimal.js"));
 
 // src/utils.ts
+var import_decimal = __toESM(require("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 (import_decimal.default.isDecimal(lhs[key]) || import_decimal.default.isDecimal(rhs[key])) {
+        return new import_decimal.default(`${lhs[key]}`).equals(new import_decimal.default(`${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, enums) {
+  switch (structure.type) {
+    case "AffectedRows":
+      if (typeof data !== "number") {
+        throw new DataMapperError(`Expected an affected rows count, got: ${typeof data} (${data})`);
+      }
+      return { count: data };
+    case "Object":
+      return mapArrayOrObject(data, structure.fields, enums);
+    case "Value":
+      return mapValue(data, "<result>", structure.resultType, enums);
+    default:
+      assertNever(structure, `Invalid data mapping type: '${structure.type}'`);
+  }
+}
+function mapArrayOrObject(data, fields, enums) {
+  if (data === null) return null;
+  if (Array.isArray(data)) {
+    const rows = data;
+    return rows.map((row) => mapObject(row, fields, enums));
+  }
+  if (typeof data === "object") {
+    const row = data;
+    return mapObject(row, fields, enums);
+  }
+  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, enums);
+  }
+  throw new DataMapperError(`Expected an array or an object, got: ${typeof data}`);
+}
+function mapObject(data, fields, enums) {
+  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 "AffectedRows": {
+        throw new DataMapperError(`Unexpected 'AffectedRows' node in data mapping for field '${name}'`);
+      }
+      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, enums);
+        break;
+      }
+      case "Value":
+        {
+          const dbName = node.dbName;
+          if (Object.hasOwn(data, dbName)) {
+            result[name] = mapValue(data[dbName], dbName, node.resultType, enums);
+          } 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, enums) {
+  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" && !import_decimal2.default.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, enums));
+    }
+    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}`);
+    }
+    case "Enum": {
+      const enumDef = enums[resultType.inner];
+      if (enumDef === void 0) {
+        throw new DataMapperError(`Unknown enum '${resultType.inner}'`);
+      }
+      const enumValue = enumDef[`${value}`];
+      if (enumValue === void 0) {
+        throw new DataMapperError(`Unknown enum value '${value}' for enum '${resultType.inner}'`);
+      }
+      return enumValue;
+    }
+    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
+var import_api = require("@opentelemetry/api");
 var noopTracingHelper = {
   runInChildSpan(_, callback) {
     return callback();
@@ -67,6 +315,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: import_api.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
 var import_driver_adapter_utils = require("@prisma/driver-adapter-utils");
@@ -77,7 +356,7 @@ var UserFacingError = class extends Error {
   constructor(message, code, meta) {
     super(message);
     this.code = code;
-    this.meta = meta;
+    this.meta = meta ?? {};
   }
   toQueryResponseErrorObject() {
     return {
@@ -100,7 +379,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) {
@@ -211,101 +490,6 @@ function renderConstraint(constraint) {
   return "(not available)";
 }
 
-// src/interpreter/DataMapper.ts
-var import_decimal = __toESM(require("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 import_decimal.default(value) : new import_decimal.default(`${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
 var import_cuid = __toESM(require("@bugsnag/cuid"));
 var import_cuid2 = require("@paralleldrive/cuid2");
@@ -315,7 +499,6 @@ var import_uuid = require("uuid");
 var GeneratorRegistry = class {
   #generators = {};
   constructor() {
-    this.register("now", new NowGenerator());
     this.register("uuid", new UuidGenerator());
     this.register("cuid", new CuidGenerator());
     this.register("ulid", new UlidGenerator());
@@ -327,9 +510,11 @@ var GeneratorRegistry = class {
    * method being called, meaning that the built-in time-based generators will always return
    * the same value on repeated calls as long as the same snapshot is used.
    */
-  snapshot() {
+  snapshot(provider) {
     return Object.create(this.#generators, {
-      now: { value: new NowGenerator() }
+      now: {
+        value: provider === "mysql" ? new MysqlNowGenerator() : new NowGenerator()
+      }
     });
   }
   /**
@@ -345,6 +530,12 @@ var NowGenerator = class {
     return this.#now.toISOString();
   }
 };
+var MysqlNowGenerator = class {
+  #now = /* @__PURE__ */ new Date();
+  generate() {
+    return this.#now.toISOString().replace("T", " ").replace("Z", "");
+  }
+};
 var UuidGenerator = class {
   generate(arg) {
     if (arg === 4) {
@@ -410,6 +601,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) {
@@ -452,9 +646,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;
 }
@@ -548,6 +743,7 @@ function doesRequireEvaluation(param) {
 }
 
 // src/interpreter/serializeSql.ts
+var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
 function serializeSql(resultSet) {
   return resultSet.rows.map(
     (row) => row.reduce((acc, value, index) => {
@@ -568,6 +764,100 @@ 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}`);
+      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)))
+  };
+}
+function serializeColumnType(columnType) {
+  switch (columnType) {
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int32:
+      return "int";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int64:
+      return "bigint";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Float:
+      return "float";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Double:
+      return "double";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Text:
+      return "string";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Enum:
+      return "enum";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Bytes:
+      return "bytes";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Boolean:
+      return "bool";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Character:
+      return "char";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Numeric:
+      return "decimal";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Json:
+      return "json";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Uuid:
+      return "uuid";
+    case import_driver_adapter_utils2.ColumnTypeEnum.DateTime:
+      return "datetime";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Date:
+      return "date";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Time:
+      return "time";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int32Array:
+      return "int-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.Int64Array:
+      return "bigint-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.FloatArray:
+      return "float-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.DoubleArray:
+      return "double-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.TextArray:
+      return "string-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.EnumArray:
+      return "string-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.BytesArray:
+      return "bytes-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.BooleanArray:
+      return "bool-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.CharacterArray:
+      return "char-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.NumericArray:
+      return "decimal-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.JsonArray:
+      return "json-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.UuidArray:
+      return "uuid-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.DateTimeArray:
+      return "datetime-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.DateArray:
+      return "date-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.TimeArray:
+      return "time-array";
+    case import_driver_adapter_utils2.ColumnTypeEnum.UnknownNumber:
+      return "unknown";
+    /// The following PlanetScale type IDs are mapped into Set:
+    /// - SET (SET) -> e.g. `"foo,bar"` (String-encoded, comma-separated)
+    case import_driver_adapter_utils2.ColumnTypeEnum.Set:
+      return "string";
+    default:
+      assertNever(columnType, `Unexpected column type: ${columnType}`);
+  }
+}
 
 // src/interpreter/validation.ts
 function performValidation(data, rules, error) {
@@ -595,6 +885,8 @@ function doesSatisfyRule(data, rule) {
         return rule.args !== 0;
       }
       return rule.args !== 1;
+    case "affectedRowCountEq":
+      return data === rule.args;
     case "never":
       return false;
     default:
@@ -612,7 +904,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:
@@ -625,6 +919,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":
@@ -642,12 +938,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({
@@ -655,27 +960,36 @@ var QueryInterpreter = class _QueryInterpreter {
       placeholderValues: options.placeholderValues,
       onQuery: options.onQuery,
       tracingHelper: options.tracingHelper,
-      serializer: serializeSql
+      serializer: serializeSql,
+      rawSerializer: serializeRawSql
     });
   }
   async run(queryPlan, queryable) {
-    return this.interpretNode(queryPlan, queryable, this.#placeholderValues, this.#generators.snapshot()).catch(
-      (e) => rethrowAsUserFacing(e)
-    );
+    const { value } = await this.interpretNode(
+      queryPlan,
+      queryable,
+      this.#placeholderValues,
+      this.#generators.snapshot(queryable.provider)
+    ).catch((e) => rethrowAsUserFacing(e));
+    return value;
   }
   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 ?? { value: void 0 };
       }
       case "get": {
-        return scope[node.args.name];
+        return { value: scope[node.args.name] };
       }
       case "let": {
         const nestedScope = Object.create(scope);
         for (const binding of node.args.bindings) {
-          nestedScope[binding.name] = await this.interpretNode(binding.expr, queryable, nestedScope, generators);
+          const { value } = await this.interpretNode(binding.expr, queryable, nestedScope, generators);
+          nestedScope[binding.name] = value;
         }
         return this.interpretNode(node.args.expr, queryable, nestedScope, generators);
       }
@@ -683,71 +997,87 @@ var QueryInterpreter = class _QueryInterpreter {
         for (const name of node.args.names) {
           const value = scope[name];
           if (!isEmpty(value)) {
-            return value;
+            return { value };
           }
         }
-        return [];
+        return { value: [] };
       }
       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)), []);
+        const parts = await Promise.all(
+          node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators).then((res) => res.value))
+        );
+        return {
+          value: 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));
+        const parts = await Promise.all(
+          node.args.map((arg) => this.interpretNode(arg, queryable, scope, generators).then((res) => res.value))
+        );
+        return {
+          value: 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 await queryable.executeRaw(query);
+        return this.#withQuerySpanAndEvent(query, queryable, async () => {
+          return { value: 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 () => {
+          const result = await queryable.queryRaw(query);
+          if (node.args.type === "rawSql") {
+            return { value: this.#rawSerializer(result), lastInsertId: result.lastInsertId };
+          } else {
+            return { value: this.#serializer(result), lastInsertId: result.lastInsertId };
+          }
         });
       }
       case "reverse": {
-        const value = await this.interpretNode(node.args, queryable, scope, generators);
-        return Array.isArray(value) ? value.reverse() : value;
+        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
+        return { value: Array.isArray(value) ? value.reverse() : value, lastInsertId };
       }
       case "unique": {
-        const value = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
         if (!Array.isArray(value)) {
-          return value;
+          return { value, lastInsertId };
         }
         if (value.length > 1) {
           throw new Error(`Expected zero or one element, got ${value.length}`);
         }
-        return value[0] ?? null;
+        return { value: value[0] ?? null, lastInsertId };
       }
       case "required": {
-        const value = await this.interpretNode(node.args, queryable, scope, generators);
+        const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
-        return value;
+        return { value, lastInsertId };
       }
       case "mapField": {
-        const value = await this.interpretNode(node.args.records, queryable, scope, generators);
-        return mapField(value, node.args.field);
+        const { value, lastInsertId } = await this.interpretNode(node.args.records, queryable, scope, generators);
+        return { value: mapField(value, node.args.field), lastInsertId };
       }
       case "join": {
-        const parent = await this.interpretNode(node.args.parent, queryable, scope, generators);
+        const { value: parent, lastInsertId } = await this.interpretNode(node.args.parent, queryable, scope, generators);
+        if (parent === null) {
+          return { value: null, lastInsertId };
+        }
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: await this.interpretNode(joinExpr.child, queryable, scope, generators)
+            childRecords: (await this.interpretNode(joinExpr.child, queryable, scope, generators)).value
           }))
         );
         if (Array.isArray(parent)) {
           for (const record of parent) {
             attachChildrenToParent(asRecord(record), children);
           }
-          return parent;
+          return { value: parent, lastInsertId };
         }
-        return attachChildrenToParent(asRecord(parent), children);
+        return { value: attachChildrenToParent(asRecord(parent), children), lastInsertId };
       }
       case "transaction": {
         if (!this.#transactionManager.enabled) {
@@ -766,16 +1096,16 @@ var QueryInterpreter = class _QueryInterpreter {
         }
       }
       case "dataMap": {
-        const data = await this.interpretNode(node.args.expr, queryable, scope, generators);
-        return applyDataMap(data, node.args.structure);
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        return { value: applyDataMap(value, node.args.structure, node.args.enums), lastInsertId };
       }
       case "validate": {
-        const data = await this.interpretNode(node.args.expr, queryable, scope, generators);
-        performValidation(data, node.args.rules, node.args);
-        return data;
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        performValidation(value, node.args.rules, node.args);
+        return { value, lastInsertId };
       }
       case "if": {
-        const value = await this.interpretNode(node.args.value, queryable, scope, generators);
+        const { value } = await this.interpretNode(node.args.value, queryable, scope, generators);
         if (doesSatisfyRule(value, node.args.rule)) {
           return await this.interpretNode(node.args.then, queryable, scope, generators);
         } else {
@@ -783,42 +1113,73 @@ var QueryInterpreter = class _QueryInterpreter {
         }
       }
       case "unit": {
-        return void 0;
+        return { value: void 0 };
       }
       case "diff": {
-        const from = await this.interpretNode(node.args.from, queryable, scope, generators);
-        const to = await this.interpretNode(node.args.to, queryable, scope, generators);
+        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 asList(from).filter((item) => !toSet.has(item));
+        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 };
+      }
+      case "paginate": {
+        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 };
+      }
+      case "extendRecord": {
+        const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        const record = value === null ? {} : asRecord(value);
+        for (const [key, entry] of Object.entries(node.args.values)) {
+          if (entry.type === "lastInsertId") {
+            record[key] = lastInsertId;
+          } else {
+            record[key] = evaluateParam(entry.value, scope, generators);
+          }
+        }
+        return { value: record, lastInsertId };
       }
       default:
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
   }
-  #withQueryEvent(query, queryable, execute) {
-    return this.#tracingHelper.runInChildSpan(
-      {
-        name: "db_query",
-        kind: import_api.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) {
@@ -862,7 +1223,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 {
@@ -878,6 +1244,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
 var import_debug = require("@prisma/debug");
@@ -892,12 +1270,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() {
@@ -908,12 +1285,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 {
@@ -945,6 +1322,16 @@ var MAX_CLOSED_TRANSACTIONS = 100;
 var debug = (0, import_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();
@@ -954,14 +1341,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));
@@ -1065,14 +1455,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);
@@ -1093,15 +1489,29 @@ var TransactionManager = class {
       maxWait: options.maxWait
     };
   }
+  #withQuerySpanAndEvent(query, queryable, execute) {
+    return withQuerySpanAndEvent({
+      query,
+      queryable,
+      execute,
+      tracingHelper: this.tracingHelper,
+      onQuery: this.#onQuery
+    });
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DataMapperError,
   QueryInterpreter,
   TransactionManager,
   TransactionManagerError,
   UserFacingError,
+  doKeysMatch,
+  isDeepStrictEqual,
+  isPrismaValueBigInt,
   isPrismaValueBytes,
   isPrismaValueGenerator,
   isPrismaValuePlaceholder,
-  noopTracingHelper
+  noopTracingHelper,
+  safeJsonStringify
 });