@prisma/query-plan-executor 6.18.0 → 6.19.0-integration-next.1

package/dist/index.js

@@ -49798,11 +49798,11 @@ ${serverError}`);
         if (cacheRecord.accessToken) {
           if (cacheRecord.accessToken.tokenType === AuthenticationScheme.POP && !request3.popKid) {
             const popTokenGenerator = new PopTokenGenerator(cryptoObj);
-            const { secret, keyId } = cacheRecord.accessToken;
+            const { secret: secret2, keyId } = cacheRecord.accessToken;
             if (!keyId) {
               throw createClientAuthError(keyIdMissing);
             }
-            accessToken = await popTokenGenerator.signPopToken(secret, keyId, request3);
+            accessToken = await popTokenGenerator.signPopToken(secret2, keyId, request3);
           } else {
             accessToken = cacheRecord.accessToken.secret;
           }
@@ -52889,17 +52889,17 @@ var require_jwa = __commonJS({
       return thing;
     }
     function createHmacSigner(bits) {
-      return function sign2(thing, secret) {
-        checkIsSecretKey(secret);
+      return function sign2(thing, secret2) {
+        checkIsSecretKey(secret2);
         thing = normalizeInput(thing);
-        var hmac = crypto7.createHmac("sha" + bits, secret);
+        var hmac = crypto7.createHmac("sha" + bits, secret2);
         var sig = (hmac.update(thing), hmac.digest("base64"));
         return fromBase64(sig);
       };
     }
     function createHmacVerifier(bits) {
-      return function verify(thing, signature, secret) {
-        var computedSig = createHmacSigner(bits)(thing, secret);
+      return function verify(thing, signature, secret2) {
+        var computedSig = createHmacSigner(bits)(thing, secret2);
         return bufferEqual(Buffer2.from(signature), Buffer2.from(computedSig));
       };
     }
@@ -53048,8 +53048,8 @@ var require_sign_stream = __commonJS({
       return util2.format("%s.%s", securedInput, signature);
     }
     function SignStream(opts) {
-      var secret = opts.secret || opts.privateKey || opts.key;
-      var secretStream = new DataStream(secret);
+      var secret2 = opts.secret || opts.privateKey || opts.key;
+      var secretStream = new DataStream(secret2);
       this.readable = true;
       this.header = opts.header;
       this.encoding = opts.encoding;
@@ -58084,13 +58084,13 @@ var init_AzureArc = __esm({
           if (secretFileSize > AZURE_ARC_SECRET_FILE_MAX_SIZE_BYTES) {
             throw createManagedIdentityError(invalidSecret);
           }
-          let secret;
+          let secret2;
           try {
-            secret = (0, import_fs2.readFileSync)(secretFilePath, "utf-8");
+            secret2 = (0, import_fs2.readFileSync)(secretFilePath, "utf-8");
           } catch (e2) {
             throw createManagedIdentityError(unableToReadSecretFile);
           }
-          const authHeaderValue = `Basic ${secret}`;
+          const authHeaderValue = `Basic ${secret2}`;
           this.logger.info(`[Managed Identity] Adding authorization header to the request.`);
           networkRequest.headers[AUTHORIZATION_HEADER_NAME] = authHeaderValue;
           try {
@@ -92893,11 +92893,11 @@ var require_postgres_interval = __commonJS({
     "use strict";
     var extend3 = require_mutable();
     module2.exports = PostgresInterval;
-    function PostgresInterval(raw2) {
+    function PostgresInterval(raw3) {
       if (!(this instanceof PostgresInterval)) {
-        return new PostgresInterval(raw2);
+        return new PostgresInterval(raw3);
       }
-      extend3(this, parse5(raw2));
+      extend3(this, parse5(raw3));
     }
     var properties = ["seconds", "minutes", "hours", "days", "months", "years"];
     PostgresInterval.prototype.toPostgres = function() {
@@ -97612,7 +97612,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "6.18.0";
+var version = "6.19.0-integration-next.1";
 
 // ../../node_modules/.pnpm/temporal-polyfill@0.3.0/node_modules/temporal-polyfill/chunks/internal.js
 function clampProp(e2, n2, t2, o2, r2) {
@@ -102884,7 +102884,182 @@ var zValidator = (target, schema, hook, options) => (
   })
 );
 
-// ../../node_modules/.pnpm/decimal.js@10.5.0/node_modules/decimal.js/decimal.mjs
+// ../client-runtime-utils/dist/index.mjs
+function setClassName(classObject, name6) {
+  Object.defineProperty(classObject, "name", {
+    value: name6,
+    configurable: true
+  });
+}
+var PrismaClientInitializationError = class _PrismaClientInitializationError extends Error {
+  clientVersion;
+  errorCode;
+  retryable;
+  constructor(message, clientVersion, errorCode) {
+    super(message);
+    this.name = "PrismaClientInitializationError";
+    this.clientVersion = clientVersion;
+    this.errorCode = errorCode;
+    Error.captureStackTrace(_PrismaClientInitializationError);
+  }
+  get [Symbol.toStringTag]() {
+    return "PrismaClientInitializationError";
+  }
+};
+setClassName(PrismaClientInitializationError, "PrismaClientInitializationError");
+var PrismaClientKnownRequestError = class extends Error {
+  code;
+  meta;
+  clientVersion;
+  batchRequestIdx;
+  constructor(message, { code, clientVersion, meta, batchRequestIdx }) {
+    super(message);
+    this.name = "PrismaClientKnownRequestError";
+    this.code = code;
+    this.clientVersion = clientVersion;
+    this.meta = meta;
+    Object.defineProperty(this, "batchRequestIdx", {
+      value: batchRequestIdx,
+      enumerable: false,
+      writable: true
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "PrismaClientKnownRequestError";
+  }
+};
+setClassName(PrismaClientKnownRequestError, "PrismaClientKnownRequestError");
+function getBacktrace(log32) {
+  if (log32.fields?.message) {
+    let str = log32.fields?.message;
+    if (log32.fields?.file) {
+      str += ` in ${log32.fields.file}`;
+      if (log32.fields?.line) {
+        str += `:${log32.fields.line}`;
+      }
+      if (log32.fields?.column) {
+        str += `:${log32.fields.column}`;
+      }
+    }
+    if (log32.fields?.reason) {
+      str += `
+${log32.fields?.reason}`;
+    }
+    return str;
+  }
+  return "Unknown error";
+}
+function isPanic(err) {
+  return err.fields?.message === "PANIC";
+}
+var PrismaClientRustError = class extends Error {
+  clientVersion;
+  _isPanic;
+  constructor({ clientVersion, error: error44 }) {
+    const backtrace = getBacktrace(error44);
+    super(backtrace ?? "Unknown error");
+    this._isPanic = isPanic(error44);
+    this.clientVersion = clientVersion;
+  }
+  get [Symbol.toStringTag]() {
+    return "PrismaClientRustError";
+  }
+  isPanic() {
+    return this._isPanic;
+  }
+};
+setClassName(PrismaClientRustError, "PrismaClientRustError");
+var PrismaClientRustPanicError = class extends Error {
+  clientVersion;
+  constructor(message, clientVersion) {
+    super(message);
+    this.name = "PrismaClientRustPanicError";
+    this.clientVersion = clientVersion;
+  }
+  get [Symbol.toStringTag]() {
+    return "PrismaClientRustPanicError";
+  }
+};
+setClassName(PrismaClientRustPanicError, "PrismaClientRustPanicError");
+var PrismaClientUnknownRequestError = class extends Error {
+  clientVersion;
+  batchRequestIdx;
+  constructor(message, { clientVersion, batchRequestIdx }) {
+    super(message);
+    this.name = "PrismaClientUnknownRequestError";
+    this.clientVersion = clientVersion;
+    Object.defineProperty(this, "batchRequestIdx", {
+      value: batchRequestIdx,
+      writable: true,
+      enumerable: false
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "PrismaClientUnknownRequestError";
+  }
+};
+setClassName(PrismaClientUnknownRequestError, "PrismaClientUnknownRequestError");
+var PrismaClientValidationError = class extends Error {
+  name = "PrismaClientValidationError";
+  clientVersion;
+  constructor(message, { clientVersion }) {
+    super(message);
+    this.clientVersion = clientVersion;
+  }
+  get [Symbol.toStringTag]() {
+    return "PrismaClientValidationError";
+  }
+};
+setClassName(PrismaClientValidationError, "PrismaClientValidationError");
+var secret = Symbol();
+var representations = /* @__PURE__ */ new WeakMap();
+var ObjectEnumValue = class {
+  constructor(arg) {
+    if (arg === secret) {
+      representations.set(this, `Prisma.${this._getName()}`);
+    } else {
+      representations.set(this, `new Prisma.${this._getNamespace()}.${this._getName()}()`);
+    }
+  }
+  _getName() {
+    return this.constructor.name;
+  }
+  toString() {
+    return representations.get(this);
+  }
+};
+function setClassName2(classObject, name6) {
+  Object.defineProperty(classObject, "name", {
+    value: name6,
+    configurable: true
+  });
+}
+var NullTypesEnumValue = class extends ObjectEnumValue {
+  _getNamespace() {
+    return "NullTypes";
+  }
+};
+var DbNullClass = class extends NullTypesEnumValue {
+  // Phantom private property to prevent structural type equality
+  // eslint-disable-next-line no-unused-private-class-members
+  #_brand_DbNull;
+};
+setClassName2(DbNullClass, "DbNull");
+var JsonNullClass = class extends NullTypesEnumValue {
+  // Phantom private property to prevent structural type equality
+  // eslint-disable-next-line no-unused-private-class-members
+  #_brand_JsonNull;
+};
+setClassName2(JsonNullClass, "JsonNull");
+var AnyNullClass = class extends NullTypesEnumValue {
+  // Phantom private property to prevent structural type equality
+  // eslint-disable-next-line no-unused-private-class-members
+  #_brand_AnyNull;
+};
+setClassName2(AnyNullClass, "AnyNull");
+var DbNull = new DbNullClass(secret);
+var JsonNull = new JsonNullClass(secret);
+var AnyNull = new AnyNullClass(secret);
 var EXP_LIMIT = 9e15;
 var MAX_DIGITS = 1e9;
 var NUMERALS = "0123456789abcdef";
@@ -104764,7 +104939,7 @@ function cosh(x2) {
 function clone(obj) {
   var i2, p2, ps;
   function Decimal2(v2) {
-    var e2, i3, t2, x2 = this;
+    var e2, i22, t2, x2 = this;
     if (!(x2 instanceof Decimal2)) return new Decimal2(v2);
     x2.constructor = Decimal2;
     if (isDecimalInstance(v2)) {
@@ -104801,7 +104976,7 @@ function clone(obj) {
         x2.s = 1;
       }
       if (v2 === ~~v2 && v2 < 1e7) {
-        for (e2 = 0, i3 = v2; i3 >= 10; i3 /= 10) e2++;
+        for (e2 = 0, i22 = v2; i22 >= 10; i22 /= 10) e2++;
         if (external) {
           if (e2 > Decimal2.maxE) {
             x2.e = NaN;
@@ -104828,11 +105003,11 @@ function clone(obj) {
       return parseDecimal(x2, v2.toString());
     }
     if (t2 === "string") {
-      if ((i3 = v2.charCodeAt(0)) === 45) {
+      if ((i22 = v2.charCodeAt(0)) === 45) {
         v2 = v2.slice(1);
         x2.s = -1;
       } else {
-        if (i3 === 43) v2 = v2.slice(1);
+        if (i22 === 43) v2 = v2.slice(1);
         x2.s = 1;
       }
       return isDecimal.test(v2) ? parseDecimal(x2, v2) : parseOther(x2, v2);
@@ -105059,7 +105234,73 @@ P2[Symbol.toStringTag] = "Decimal";
 var Decimal = P2.constructor = clone(DEFAULTS);
 LN10 = new Decimal(LN10);
 PI = new Decimal(PI);
-var decimal_default = Decimal;
+var Sql = class _Sql {
+  constructor(rawStrings, rawValues) {
+    if (rawStrings.length - 1 !== rawValues.length) {
+      if (rawStrings.length === 0) {
+        throw new TypeError("Expected at least 1 string");
+      }
+      throw new TypeError(`Expected ${rawStrings.length} strings to have ${rawStrings.length - 1} values`);
+    }
+    const valuesLength = rawValues.reduce((len, value) => len + (value instanceof _Sql ? value.values.length : 1), 0);
+    this.values = new Array(valuesLength);
+    this.strings = new Array(valuesLength + 1);
+    this.strings[0] = rawStrings[0];
+    let i2 = 0, pos = 0;
+    while (i2 < rawValues.length) {
+      const child = rawValues[i2++];
+      const rawString = rawStrings[i2];
+      if (child instanceof _Sql) {
+        this.strings[pos] += child.strings[0];
+        let childIndex = 0;
+        while (childIndex < child.values.length) {
+          this.values[pos++] = child.values[childIndex++];
+          this.strings[pos] = child.strings[childIndex];
+        }
+        this.strings[pos] += rawString;
+      } else {
+        this.values[pos++] = child;
+        this.strings[pos] = rawString;
+      }
+    }
+  }
+  get sql() {
+    const len = this.strings.length;
+    let i2 = 1;
+    let value = this.strings[0];
+    while (i2 < len)
+      value += `?${this.strings[i2++]}`;
+    return value;
+  }
+  get statement() {
+    const len = this.strings.length;
+    let i2 = 1;
+    let value = this.strings[0];
+    while (i2 < len)
+      value += `:${i2}${this.strings[i2++]}`;
+    return value;
+  }
+  get text() {
+    const len = this.strings.length;
+    let i2 = 1;
+    let value = this.strings[0];
+    while (i2 < len)
+      value += `$${i2}${this.strings[i2++]}`;
+    return value;
+  }
+  inspect() {
+    return {
+      sql: this.sql,
+      statement: this.statement,
+      text: this.text,
+      values: this.values
+    };
+  }
+};
+function raw(value) {
+  return new Sql([value], []);
+}
+var empty = raw("");
 
 // ../debug/dist/index.mjs
 var __defProp2 = Object.defineProperty;
@@ -105623,7 +105864,7 @@ function doKeysMatch(lhs, rhs) {
     if (typeof lhs[key] === typeof rhs[key] && typeof lhs[key] !== "object") {
       return lhs[key] === rhs[key];
     }
-    if (decimal_default.isDecimal(lhs[key]) || decimal_default.isDecimal(rhs[key])) {
+    if (Decimal.isDecimal(lhs[key]) || Decimal.isDecimal(rhs[key])) {
       const lhsDecimal = asDecimal(lhs[key]);
       const rhsDecimal = asDecimal(rhs[key]);
       return lhsDecimal && rhsDecimal && lhsDecimal.equals(rhsDecimal);
@@ -105642,10 +105883,10 @@ function doKeysMatch(lhs, rhs) {
   });
 }
 function asDecimal(value) {
-  if (decimal_default.isDecimal(value)) {
+  if (Decimal.isDecimal(value)) {
     return value;
   } else if (typeof value === "number" || typeof value === "string") {
-    return new decimal_default(value);
+    return new Decimal(value);
   } else {
     return;
   }
@@ -106090,7 +106331,7 @@ function mapValue(value, columnName, scalarType, enums) {
       throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
     }
     case "decimal":
-      if (typeof value !== "number" && typeof value !== "string" && !decimal_default.isDecimal(value)) {
+      if (typeof value !== "number" && typeof value !== "string" && !Decimal.isDecimal(value)) {
         throw new DataMapperError(`Expected a decimal in column '${columnName}', got ${typeof value}: ${value}`);
       }
       return { $type: "Decimal", value };
@@ -107724,7 +107965,7 @@ var HonoRequest = class {
     return this.bodyCache.parsedBody ??= await parseBody(this, options);
   }
   #cachedBody = (key) => {
-    const { bodyCache, raw: raw2 } = this;
+    const { bodyCache, raw: raw3 } = this;
     const cachedBody = bodyCache[key];
     if (cachedBody) {
       return cachedBody;
@@ -107738,7 +107979,7 @@ var HonoRequest = class {
         return new Response(body)[key]();
       });
     }
-    return bodyCache[key] = raw2[key]();
+    return bodyCache[key] = raw3[key]();
   };
   json() {
     return this.#cachedBody("text").then((text) => JSON.parse(text));
@@ -107784,7 +108025,7 @@ var HtmlEscapedCallbackPhase = {
   BeforeStream: 2,
   Stream: 3
 };
-var raw = (value, callbacks) => {
+var raw2 = (value, callbacks) => {
   const escapedString = new String(value);
   escapedString.isEscaped = true;
   escapedString.callbacks = callbacks;
@@ -107814,7 +108055,7 @@ var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) =>
     ).then(() => buffer[0])
   );
   if (preserveCallbacks) {
-    return raw(await resStr, callbacks);
+    return raw2(await resStr, callbacks);
   } else {
     return resStr;
   }
@@ -123731,6 +123972,17 @@ function getErrorResponse(error44, ctx) {
 });
 /*! Bundled license information:
 
+decimal.js/decimal.mjs:
+  (*!
+   *  decimal.js v10.5.0
+   *  An arbitrary-precision Decimal type for JavaScript.
+   *  https://github.com/MikeMcl/decimal.js
+   *  Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  MIT Licence
+   *)
+*/
+/*! Bundled license information:
+
 @noble/hashes/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
@@ -123903,13 +124155,4 @@ js-md4/src/md4.js:
    * @copyright (c) 2015-present, Philipp Thürwächter, Pattrick Hüper & js-joda contributors
    * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
    *)
-
-decimal.js/decimal.mjs:
-  (*!
-   *  decimal.js v10.5.0
-   *  An arbitrary-precision Decimal type for JavaScript.
-   *  https://github.com/MikeMcl/decimal.js
-   *  Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>
-   *  MIT Licence
-   *)
 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/query-plan-executor",
-  "version": "6.18.0",
+  "version": "6.19.0-integration-next.1",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,11 +20,11 @@
     "temporal-polyfill": "0.3.0",
     "vitest": "3.2.4",
     "zod": "4.1.3",
-    "@prisma/adapter-pg": "6.18.0",
-    "@prisma/adapter-mariadb": "6.18.0",
-    "@prisma/client-engine-runtime": "6.18.0",
-    "@prisma/adapter-mssql": "6.18.0",
-    "@prisma/driver-adapter-utils": "6.18.0"
+    "@prisma/adapter-pg": "6.19.0-integration-next.1",
+    "@prisma/adapter-mssql": "6.19.0-integration-next.1",
+    "@prisma/adapter-mariadb": "6.19.0-integration-next.1",
+    "@prisma/client-engine-runtime": "6.19.0-integration-next.1",
+    "@prisma/driver-adapter-utils": "6.19.0-integration-next.1"
   },
   "files": [
     "dist"