@prisma/query-plan-executor 6.17.0-dev.3 → 6.17.0-dev.30

package/dist/index.js

@@ -19658,14 +19658,14 @@ var require_pool = __commonJS({
        * @param {Function} onError - Error callback
        * @param {number} timeoutEnd - Timestamp when connection attempt should time out
        */
-      _createPoolConnection(onSuccess, onError2, timeoutEnd) {
+      _createPoolConnection(onSuccess, onError, timeoutEnd) {
         const minTimeout = timeoutEnd - Date.now();
         const connectionOpts = Object.assign({}, this.opts.connOptions, {
           connectTimeout: Math.max(1, Math.min(minTimeout, this.opts.connOptions.connectTimeout || Number.MAX_SAFE_INTEGER))
         });
         const conn = new Connection(connectionOpts);
         this._connectionCreationTask = null;
-        conn.connect().then((conn2) => this._prepareNewConnection(conn2, onSuccess, onError2)).catch((err) => this._handleConnectionCreationError(err, onSuccess, onError2, timeoutEnd));
+        conn.connect().then((conn2) => this._prepareNewConnection(conn2, onSuccess, onError)).catch((err) => this._handleConnectionCreationError(err, onSuccess, onError, timeoutEnd));
       }
       /**
        * Sets up a newly created connection for use in the pool
@@ -19673,10 +19673,10 @@ var require_pool = __commonJS({
        * @param {Function} onSuccess - Success callback
        * @param {Function} onError - Error callback
        */
-      _prepareNewConnection(conn, onSuccess, onError2) {
+      _prepareNewConnection(conn, onSuccess, onError) {
         if (this.#closed) {
           this._cleanupConnection(conn, "pool_closed");
-          onError2(
+          onError(
             new Errors2.createFatalError(
               "Cannot create new connection to pool, pool closed",
               Errors2.ER_ADD_CONNECTION_CLOSED_POOL
@@ -19750,7 +19750,7 @@ var require_pool = __commonJS({
        * @param {Function} onError - Error callback
        * @param {number} timeoutEnd - Timestamp when connection attempt should time out
        */
-      _handleConnectionCreationError(err, onSuccess, onError2, timeoutEnd) {
+      _handleConnectionCreationError(err, onSuccess, onError, timeoutEnd) {
         if (err instanceof AggregateError) {
           err = err.errors[0];
         }
@@ -19759,11 +19759,11 @@ var require_pool = __commonJS({
         if (isFatalError) {
           err.message = err.message + this._errorMsgAddon();
           this._connectionCreationTask = null;
-          onError2(err);
+          onError(err);
           return;
         }
         this._connectionCreationTask = setTimeout(
-          () => this._createPoolConnection(onSuccess, onError2, timeoutEnd),
+          () => this._createPoolConnection(onSuccess, onError, timeoutEnd),
           Math.min(500, timeoutEnd - Date.now())
         );
       }
@@ -39561,6 +39561,542 @@ var init_formDataPolicy = __esm({
   }
 });
 
+// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/common.js
+var require_common2 = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/common.js"(exports2, module2) {
+    "use strict";
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable2;
+      createDebug.enable = enable2;
+      createDebug.enabled = enabled2;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy2;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash2 = 0;
+        for (let i2 = 0; i2 < namespace.length; i2++) {
+          hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i2);
+          hash2 |= 0;
+        }
+        return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug7(...args) {
+          if (!debug7.enabled) {
+            return;
+          }
+          const self2 = debug7;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self2.diff = ms;
+          self2.prev = prevTime;
+          self2.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self2, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self2, args);
+          const logFn = self2.log || createDebug.log;
+          logFn.apply(self2, args);
+        }
+        debug7.namespace = namespace;
+        debug7.useColors = createDebug.useColors();
+        debug7.color = createDebug.selectColor(namespace);
+        debug7.extend = extend3;
+        debug7.destroy = createDebug.destroy;
+        Object.defineProperty(debug7, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v2) => {
+            enableOverride = v2;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug7);
+        }
+        return debug7;
+      }
+      function extend3(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable2(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable2() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled2(name6) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name6, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name6, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy2() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module2.exports = setup;
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/browser.js
+var require_browser2 = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/browser.js"(exports2, module2) {
+    "use strict";
+    exports2.formatArgs = formatArgs;
+    exports2.save = save;
+    exports2.load = load;
+    exports2.useColors = useColors;
+    exports2.storage = localstorage();
+    exports2.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports2.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m2;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m2 = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m2[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c2 = "color: " + this.color;
+      args.splice(1, 0, c2, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c2);
+    }
+    exports2.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports2.storage.setItem("debug", namespaces);
+        } else {
+          exports2.storage.removeItem("debug");
+        }
+      } catch (error44) {
+      }
+    }
+    function load() {
+      let r2;
+      try {
+        r2 = exports2.storage.getItem("debug") || exports2.storage.getItem("DEBUG");
+      } catch (error44) {
+      }
+      if (!r2 && typeof process !== "undefined" && "env" in process) {
+        r2 = process.env.DEBUG;
+      }
+      return r2;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error44) {
+      }
+    }
+    module2.exports = require_common2()(exports2);
+    var { formatters } = module2.exports;
+    formatters.j = function(v2) {
+      try {
+        return JSON.stringify(v2);
+      } catch (error44) {
+        return "[UnexpectedJSONParseError]: " + error44.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/node.js
+var require_node2 = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/node.js"(exports2, module2) {
+    "use strict";
+    var tty = require("tty");
+    var util2 = require("util");
+    exports2.init = init3;
+    exports2.log = log4;
+    exports2.formatArgs = formatArgs;
+    exports2.save = save;
+    exports2.load = load;
+    exports2.useColors = useColors;
+    exports2.destroy = util2.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports2.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = require_supports_color();
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports2.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error44) {
+    }
+    exports2.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_3, k2) => {
+        return k2.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name6, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c2 = this.color;
+        const colorCode = "\x1B[3" + (c2 < 8 ? c2 : "8;5;" + c2);
+        const prefix = `  ${colorCode};1m${name6} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name6 + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports2.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log4(...args) {
+      return process.stderr.write(util2.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init3(debug7) {
+      debug7.inspectOpts = {};
+      const keys = Object.keys(exports2.inspectOpts);
+      for (let i2 = 0; i2 < keys.length; i2++) {
+        debug7.inspectOpts[keys[i2]] = exports2.inspectOpts[keys[i2]];
+      }
+    }
+    module2.exports = require_common2()(exports2);
+    var { formatters } = module2.exports;
+    formatters.o = function(v2) {
+      this.inspectOpts.colors = this.useColors;
+      return util2.inspect(v2, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v2) {
+      this.inspectOpts.colors = this.useColors;
+      return util2.inspect(v2, this.inspectOpts);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/index.js
+var require_src3 = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/index.js"(exports2, module2) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module2.exports = require_browser2();
+    } else {
+      module2.exports = require_node2();
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/agent-base@6.0.2/node_modules/agent-base/dist/src/promisify.js
 var require_promisify = __commonJS({
   "../../node_modules/.pnpm/agent-base@6.0.2/node_modules/agent-base/dist/src/promisify.js"(exports2) {
@@ -39584,14 +40120,14 @@ var require_promisify = __commonJS({
 });
 
 // ../../node_modules/.pnpm/agent-base@6.0.2/node_modules/agent-base/dist/src/index.js
-var require_src3 = __commonJS({
+var require_src4 = __commonJS({
   "../../node_modules/.pnpm/agent-base@6.0.2/node_modules/agent-base/dist/src/index.js"(exports2, module2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod2) {
       return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
     };
     var events_1 = require("events");
-    var debug_1 = __importDefault(require_src2());
+    var debug_1 = __importDefault(require_src3());
     var promisify_1 = __importDefault(require_promisify());
     var debug7 = debug_1.default("agent-base");
     function isAgent(v2) {
@@ -39774,7 +40310,7 @@ var require_parse_proxy_response = __commonJS({
       return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var debug_1 = __importDefault(require_src2());
+    var debug_1 = __importDefault(require_src3());
     var debug7 = debug_1.default("https-proxy-agent:parse-proxy-response");
     function parseProxyResponse(socket) {
       return new Promise((resolve, reject) => {
@@ -39871,8 +40407,8 @@ var require_agent = __commonJS({
     var tls_1 = __importDefault(require("tls"));
     var url_1 = __importDefault(require("url"));
     var assert_1 = __importDefault(require("assert"));
-    var debug_1 = __importDefault(require_src2());
-    var agent_base_1 = require_src3();
+    var debug_1 = __importDefault(require_src3());
+    var agent_base_1 = require_src4();
     var parse_proxy_response_1 = __importDefault(require_parse_proxy_response());
     var debug7 = debug_1.default("https-proxy-agent:agent");
     var HttpsProxyAgent2 = class extends agent_base_1.Agent {
@@ -40021,19 +40557,19 @@ var require_dist2 = __commonJS({
         function cleanup() {
           signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", cleanup);
           emitter.removeListener(name6, onEvent);
-          emitter.removeListener("error", onError2);
+          emitter.removeListener("error", onError);
         }
         function onEvent(...args) {
           cleanup();
           resolve(args);
         }
-        function onError2(err) {
+        function onError(err) {
           cleanup();
           reject(err);
         }
         signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", cleanup);
         emitter.on(name6, onEvent);
-        emitter.on("error", onError2);
+        emitter.on("error", onError);
       });
     }
     exports2.default = once;
@@ -40078,9 +40614,9 @@ var require_agent2 = __commonJS({
     var net_1 = __importDefault(require("net"));
     var tls_1 = __importDefault(require("tls"));
     var url_1 = __importDefault(require("url"));
-    var debug_1 = __importDefault(require_src2());
+    var debug_1 = __importDefault(require_src3());
     var once_1 = __importDefault(require_dist2());
-    var agent_base_1 = require_src3();
+    var agent_base_1 = require_src4();
     var debug7 = (0, debug_1.default)("http-proxy-agent");
     function isHTTPS(protocol) {
       return typeof protocol === "string" ? /^https:?$/i.test(protocol) : false;
@@ -53639,8 +54175,8 @@ var require_lrucache = __commonJS({
         const deleted = this.delete(key);
         if (!deleted && value !== void 0) {
           if (this.map.size >= this.max) {
-            const firstKey = this.map.keys().next().value;
-            this.delete(firstKey);
+            const firstKey2 = this.map.keys().next().value;
+            this.delete(firstKey2);
           }
           this.map.set(key, value);
         }
@@ -61846,7 +62382,7 @@ var require_sender = __commonJS({
       return await new Promise((resolve, reject) => {
         const sockets = [];
         let errorCount = 0;
-        const onError2 = (err) => {
+        const onError = (err) => {
           errorCount++;
           if (errorCount === addresses.length) {
             signal.removeEventListener("abort", onAbort);
@@ -61865,7 +62401,7 @@ var require_sender = __commonJS({
         };
         const clearSockets = () => {
           for (const socket of sockets) {
-            socket.removeListener("error", onError2);
+            socket.removeListener("error", onError);
             socket.removeListener("message", onMessage);
             socket.close();
           }
@@ -61877,7 +62413,7 @@ var require_sender = __commonJS({
           const udpType = addresses[j2].family === 6 ? "udp6" : "udp4";
           const socket = _dgram.default.createSocket(udpType);
           sockets.push(socket);
-          socket.on("error", onError2);
+          socket.on("error", onError);
           socket.on("message", onMessage);
           socket.send(request3, 0, request3.length, port, addresses[j2].address);
         }
@@ -69106,12 +69642,12 @@ var require_pipeline = __commonJS({
         const end = reading || (opts === null || opts === void 0 ? void 0 : opts.end) !== false;
         const isLastStream = i2 === streams.length - 1;
         if (isNodeStream(stream)) {
-          let onError3 = function(err) {
+          let onError2 = function(err) {
             if (err && err.name !== "AbortError" && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
               finish(err);
             }
           };
-          var onError2 = onError3;
+          var onError = onError2;
           if (end) {
             const { destroy: destroy2, cleanup } = destroyer(stream, reading, writing);
             destroys.push(destroy2);
@@ -69119,10 +69655,10 @@ var require_pipeline = __commonJS({
               lastStreamCleanup.push(cleanup);
             }
           }
-          stream.on("error", onError3);
+          stream.on("error", onError2);
           if (isReadable(stream) && isLastStream) {
             lastStreamCleanup.push(() => {
-              stream.removeListener("error", onError3);
+              stream.removeListener("error", onError2);
             });
           }
         }
@@ -70800,7 +71336,7 @@ var require_message_io = __commonJS({
           };
           const onSecureConnect = () => {
             securePair.encrypted.removeListener("readable", onReadable);
-            securePair.cleartext.removeListener("error", onError2);
+            securePair.cleartext.removeListener("error", onError);
             securePair.cleartext.removeListener("secureConnect", onSecureConnect);
             securePair.cleartext.once("error", (err) => {
               this.socket.destroy(err);
@@ -70820,9 +71356,9 @@ var require_message_io = __commonJS({
             this.tlsNegotiationComplete = true;
             resolve();
           };
-          const onError2 = (err) => {
+          const onError = (err) => {
             securePair.encrypted.removeListener("readable", onReadable);
-            securePair.cleartext.removeListener("error", onError2);
+            securePair.cleartext.removeListener("error", onError);
             securePair.cleartext.removeListener("secureConnect", onSecureConnect);
             securePair.cleartext.destroy();
             securePair.encrypted.destroy();
@@ -70844,9 +71380,9 @@ var require_message_io = __commonJS({
               for await (const data of response) {
                 securePair.encrypted.write(data);
               }
-            }).catch(onError2);
+            }).catch(onError);
           };
-          securePair.cleartext.once("error", onError2);
+          securePair.cleartext.once("error", onError);
           securePair.cleartext.once("secureConnect", onSecureConnect);
           securePair.encrypted.once("readable", onReadable);
         });
@@ -87366,9 +87902,9 @@ var require_connector = __commonJS({
       return await new Promise((resolve, reject) => {
         const sockets = new Array(addresses.length);
         const errors = [];
-        function onError2(err) {
+        function onError(err) {
           errors.push(err);
-          this.removeListener("error", onError2);
+          this.removeListener("error", onError);
           this.removeListener("connect", onConnect);
           this.destroy();
           if (errors.length === addresses.length) {
@@ -87383,7 +87919,7 @@ var require_connector = __commonJS({
             if (this === socket) {
               continue;
             }
-            socket.removeListener("error", onError2);
+            socket.removeListener("error", onError);
             socket.removeListener("connect", onConnect);
             socket.destroy();
           }
@@ -87392,7 +87928,7 @@ var require_connector = __commonJS({
         const onAbort = () => {
           for (let j2 = 0; j2 < sockets.length; j2++) {
             const socket = sockets[j2];
-            socket.removeListener("error", onError2);
+            socket.removeListener("error", onError);
             socket.removeListener("connect", onConnect);
             socket.destroy();
           }
@@ -87404,7 +87940,7 @@ var require_connector = __commonJS({
             host: addresses[i2].address,
             family: addresses[i2].family
           });
-          socket.on("error", onError2);
+          socket.on("error", onError);
           socket.on("connect", onConnect);
         }
         signal.addEventListener("abort", onAbort, {
@@ -87427,28 +87963,28 @@ var require_connector = __commonJS({
               family: address.family
             });
             const onAbort = () => {
-              socket.removeListener("error", onError2);
+              socket.removeListener("error", onError);
               socket.removeListener("connect", onConnect);
               socket.destroy();
               reject(new _abortError.default());
             };
-            const onError2 = (err) => {
+            const onError = (err) => {
               signal.removeEventListener("abort", onAbort);
-              socket.removeListener("error", onError2);
+              socket.removeListener("error", onError);
               socket.removeListener("connect", onConnect);
               socket.destroy();
               reject(err);
             };
             const onConnect = () => {
               signal.removeEventListener("abort", onAbort);
-              socket.removeListener("error", onError2);
+              socket.removeListener("error", onError);
               socket.removeListener("connect", onConnect);
               resolve(socket);
             };
             signal.addEventListener("abort", onAbort, {
               once: true
             });
-            socket.on("error", onError2);
+            socket.on("error", onError);
             socket.on("connect", onConnect);
           });
         } catch (err) {
@@ -88940,15 +89476,15 @@ var require_connection2 = __commonJS({
         }
         if (connectListener) {
           const onConnect = (err) => {
-            this.removeListener("error", onError2);
+            this.removeListener("error", onError);
             connectListener(err);
           };
-          const onError2 = (err) => {
+          const onError = (err) => {
             this.removeListener("connect", onConnect);
             connectListener(err);
           };
           this.once("connect", onConnect);
-          this.once("error", onError2);
+          this.once("error", onError);
         }
         this.transitionTo(this.STATE.CONNECTING);
       }
@@ -89150,28 +89686,28 @@ var require_connection2 = __commonJS({
           };
           const encryptsocket = tls.connect(encryptOptions);
           const onAbort = () => {
-            encryptsocket.removeListener("error", onError2);
+            encryptsocket.removeListener("error", onError);
             encryptsocket.removeListener("connect", onConnect);
             encryptsocket.destroy();
             reject(signal.reason);
           };
-          const onError2 = (err) => {
+          const onError = (err) => {
             signal.removeEventListener("abort", onAbort);
-            encryptsocket.removeListener("error", onError2);
+            encryptsocket.removeListener("error", onError);
             encryptsocket.removeListener("connect", onConnect);
             encryptsocket.destroy();
             reject(err);
           };
           const onConnect = () => {
             signal.removeEventListener("abort", onAbort);
-            encryptsocket.removeListener("error", onError2);
+            encryptsocket.removeListener("error", onError);
             encryptsocket.removeListener("connect", onConnect);
             resolve(encryptsocket);
           };
           signal.addEventListener("abort", onAbort, {
             once: true
           });
-          encryptsocket.on("error", onError2);
+          encryptsocket.on("error", onError);
           encryptsocket.on("secureConnect", onConnect);
         });
       }
@@ -96458,7 +96994,7 @@ var require_pg_pool = __commonJS({
             return cb(err);
           }
           let clientReleased = false;
-          const onError2 = (err2) => {
+          const onError = (err2) => {
             if (clientReleased) {
               return;
             }
@@ -96466,12 +97002,12 @@ var require_pg_pool = __commonJS({
             client.release(err2);
             cb(err2);
           };
-          client.once("error", onError2);
+          client.once("error", onError);
           this.log("dispatching query");
           try {
             client.query(text, values, (err2, res) => {
               this.log("query dispatched");
-              client.removeListener("error", onError2);
+              client.removeListener("error", onError);
               if (clientReleased) {
                 return;
               }
@@ -106552,8 +107088,9 @@ var QueryInterpreter = class _QueryInterpreter {
       case "diff": {
         const { value: from } = await this.interpretNode(node.args.from, queryable, scope, generators);
         const { value: to2 } = await this.interpretNode(node.args.to, queryable, scope, generators);
-        const toSet = new Set(asList(to2).map((item) => JSON.stringify(item)));
-        return { value: asList(from).filter((item) => !toSet.has(JSON.stringify(item))) };
+        const keyGetter = (item) => item !== null ? getRecordKey(asRecord(item), node.args.fields) : null;
+        const toSet = new Set(asList(to2).map(keyGetter));
+        return { value: asList(from).filter((item) => !toSet.has(keyGetter(item))) };
       }
       case "process": {
         const { value, lastInsertId } = await this.interpretNode(node.args.expr, queryable, scope, generators);
@@ -106823,7 +107360,7 @@ var TransactionManager = class {
     this.transactions.set(transaction.id, transaction);
     let hasTimedOut = false;
     const startTimer = setTimeout(() => hasTimedOut = true, validatedOptions.maxWait);
-    startTimer.unref();
+    startTimer.unref?.();
     transaction.transaction = await this.driverAdapter.startTransaction(validatedOptions.isolationLevel).catch(rethrowAsUserFacing);
     clearTimeout(startTimer);
     switch (transaction.status) {
@@ -106912,7 +107449,7 @@ var TransactionManager = class {
         debug3("Transaction already committed or rolled back when timeout happened.", transactionId);
       }
     }, timeout);
-    timer.unref();
+    timer.unref?.();
     return timer;
   }
   async #closeTransaction(tx, status) {
@@ -106984,7 +107521,7 @@ var TransactionManager = class {
 };
 
 // ../../node_modules/.pnpm/hono@4.9.4/node_modules/hono/dist/compose.js
-var compose = (middleware, onError2, onNotFound) => {
+var compose = (middleware, onError, onNotFound) => {
   return (context2, next) => {
     let index = -1;
     return dispatch(0);
@@ -107006,9 +107543,9 @@ var compose = (middleware, onError2, onNotFound) => {
         try {
           res = await handler(context2, () => dispatch(i2 + 1));
         } catch (err) {
-          if (err instanceof Error && onError2) {
+          if (err instanceof Error && onError) {
             context2.error = err;
-            res = await onError2(err, context2);
+            res = await onError(err, context2);
             isError2 = true;
           } else {
             throw err;
@@ -108555,7 +109092,7 @@ function isPromiseLike(value) {
 }
 
 // package.json
-var version = "6.17.0-dev.3";
+var version = "6.17.0-dev.30";
 
 // src/utils/error.ts
 function extractErrorFromUnknown(value) {
@@ -108625,7 +109162,10 @@ function mapColumnType(field) {
     case "BLOB":
     case "TINY_BLOB":
     case "MEDIUM_BLOB":
-      if (field.flags.valueOf() & BINARY_FLAG) {
+    case "LONG_BLOB":
+      if (field["dataTypeFormat"] === "json") {
+        return ColumnTypeEnum.Json;
+      } else if (field.flags.valueOf() & BINARY_FLAG) {
         return ColumnTypeEnum.Bytes;
       } else {
         return ColumnTypeEnum.Text;
@@ -108870,6 +109410,8 @@ var MariaDbQueryable = class {
         sql: sql4,
         rowsAsArray: true,
         dateStrings: true,
+        // Disable automatic conversion of JSON blobs to objects.
+        autoJsonMap: false,
         // Return JSON strings as strings, not objects.
         // Available in the driver, but not provided in the typings.
         jsonStrings: true,
@@ -108882,25 +109424,28 @@ var MariaDbQueryable = class {
       return await this.client.query(req, values);
     } catch (e2) {
       const error44 = e2;
-      onError(error44);
+      this.onError(error44);
     }
   }
+  onError(error44) {
+    debug4("Error in performIO: %O", error44);
+    throw new DriverAdapterError(convertDriverError(error44));
+  }
 };
-function onError(error44) {
-  debug4("Error in performIO: %O", error44);
-  throw new DriverAdapterError(convertDriverError(error44));
-}
 var MariaDbTransaction = class extends MariaDbQueryable {
-  constructor(conn, options) {
+  constructor(conn, options, cleanup) {
     super(conn);
     this.options = options;
+    this.cleanup = cleanup;
   }
   async commit() {
     debug4(`[js::commit]`);
+    this.cleanup?.();
     await this.client.end();
   }
   async rollback() {
     debug4(`[js::rollback]`);
+    this.cleanup?.();
     await this.client.end();
   }
 };
@@ -108925,13 +109470,17 @@ var PrismaMariaDbAdapter = class extends MariaDbQueryable {
     };
     const tag2 = "[js::startTransaction]";
     debug4("%s options: %O", tag2, options);
-    const conn = await this.client.getConnection().catch((error44) => onError(error44));
-    conn.on("error", (err) => {
+    const conn = await this.client.getConnection().catch((error44) => this.onError(error44));
+    const onError = (err) => {
       debug4(`Error from connection: ${err.message} %O`, err);
       this.options?.onConnectionError?.(err);
-    });
+    };
+    conn.on("error", onError);
+    const cleanup = () => {
+      conn.removeListener("error", onError);
+    };
     try {
-      const tx = new MariaDbTransaction(conn, options);
+      const tx = new MariaDbTransaction(conn, options, cleanup);
       if (isolationLevel) {
         await tx.executeRaw({
           sql: `SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`,
@@ -108943,7 +109492,8 @@ var PrismaMariaDbAdapter = class extends MariaDbQueryable {
       return tx;
     } catch (error44) {
       await conn.end();
-      onError(error44);
+      cleanup();
+      this.onError(error44);
     }
   }
   async dispose() {
@@ -109265,97 +109815,200 @@ function parseConnectionString(connectionString) {
     }
     config3.port = port;
   }
+  const parameters = {};
   for (const part of paramParts) {
     const [key, value] = part.split("=", 2);
     if (!key) continue;
     const trimmedKey = key.trim();
-    const trimmedValue = value.trim();
-    switch (trimmedKey) {
-      case "database":
-      case "initial catalog":
-        config3.database = trimmedValue;
-        break;
-      case "user":
-      case "username":
-      case "uid":
-      case "userid":
-        config3.user = trimmedValue;
-        break;
-      case "password":
-      case "pwd":
-        config3.password = trimmedValue;
-        break;
-      case "encrypt":
-        config3.options = config3.options || {};
-        config3.options.encrypt = trimmedValue.toLowerCase() === "true";
-        break;
-      case "trustServerCertificate":
-        config3.options = config3.options || {};
-        config3.options.trustServerCertificate = trimmedValue.toLowerCase() === "true";
-        break;
-      case "connectionLimit": {
-        config3.pool = config3.pool || {};
-        const limit = parseInt(trimmedValue, 10);
-        if (isNaN(limit)) {
-          throw new Error(`Invalid connection limit: ${trimmedValue}`);
-        }
-        config3.pool.max = limit;
-        break;
-      }
-      case "connectTimeout":
-      case "connectionTimeout": {
-        const connectTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(connectTimeout)) {
-          throw new Error(`Invalid connection timeout: ${trimmedValue}`);
-        }
-        config3.connectionTimeout = connectTimeout;
-        break;
-      }
-      case "loginTimeout": {
-        const loginTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(loginTimeout)) {
-          throw new Error(`Invalid login timeout: ${trimmedValue}`);
-        }
-        config3.connectionTimeout = loginTimeout;
-        break;
+    if (trimmedKey in parameters) {
+      throw new Error(`Duplication configuration parameter: ${trimmedKey}`);
+    }
+    parameters[trimmedKey] = value.trim();
+    if (!handledParameters.includes(trimmedKey)) {
+      debug5(`Unknown connection string parameter: ${trimmedKey}`);
+    }
+  }
+  const database = firstKey(parameters, "database", "initial catalog");
+  if (database !== null) {
+    config3.database = database;
+  }
+  const user = firstKey(parameters, "user", "username", "uid", "userid");
+  if (user !== null) {
+    config3.user = user;
+  }
+  const password = firstKey(parameters, "password", "pwd");
+  if (password !== null) {
+    config3.password = password;
+  }
+  const encrypt = firstKey(parameters, "encrypt");
+  if (encrypt !== null) {
+    config3.options = config3.options || {};
+    config3.options.encrypt = encrypt.toLowerCase() === "true";
+  }
+  const trustServerCertificate = firstKey(parameters, "trustServerCertificate");
+  if (trustServerCertificate !== null) {
+    config3.options = config3.options || {};
+    config3.options.trustServerCertificate = trustServerCertificate.toLowerCase() === "true";
+  }
+  const connectionLimit = firstKey(parameters, "connectionLimit");
+  if (connectionLimit !== null) {
+    config3.pool = config3.pool || {};
+    const limit = parseInt(connectionLimit, 10);
+    if (isNaN(limit)) {
+      throw new Error(`Invalid connection limit: ${connectionLimit}`);
+    }
+    config3.pool.max = limit;
+  }
+  const connectionTimeout = firstKey(parameters, "connectionTimeout", "connectTimeout");
+  if (connectionTimeout !== null) {
+    const timeout = parseInt(connectionTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid connection timeout: ${connectionTimeout}`);
+    }
+    config3.connectionTimeout = timeout;
+  }
+  const loginTimeout = firstKey(parameters, "loginTimeout");
+  if (loginTimeout !== null) {
+    const timeout = parseInt(loginTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid login timeout: ${loginTimeout}`);
+    }
+    config3.connectionTimeout = timeout;
+  }
+  const socketTimeout = firstKey(parameters, "socketTimeout");
+  if (socketTimeout !== null) {
+    const timeout = parseInt(socketTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid socket timeout: ${socketTimeout}`);
+    }
+    config3.requestTimeout = timeout;
+  }
+  const poolTimeout = firstKey(parameters, "poolTimeout");
+  if (poolTimeout !== null) {
+    const timeout = parseInt(poolTimeout, 10);
+    if (isNaN(timeout)) {
+      throw new Error(`Invalid pool timeout: ${poolTimeout}`);
+    }
+    config3.pool = config3.pool || {};
+    config3.pool.acquireTimeoutMillis = timeout * 1e3;
+  }
+  const appName = firstKey(parameters, "applicationName", "application name");
+  if (appName !== null) {
+    config3.options = config3.options || {};
+    config3.options.appName = appName;
+  }
+  const isolationLevel = firstKey(parameters, "isolationLevel");
+  if (isolationLevel !== null) {
+    config3.options = config3.options || {};
+    config3.options.isolationLevel = mapIsolationLevelFromString(isolationLevel);
+  }
+  const authentication = firstKey(parameters, "authentication");
+  if (authentication !== null) {
+    config3.authentication = parseAuthenticationOptions(parameters, authentication);
+  }
+  if (!config3.server || config3.server.trim() === "") {
+    throw new Error("Server host is required in connection string");
+  }
+  return config3;
+}
+function parseAuthenticationOptions(parameters, authenticationValue) {
+  switch (authenticationValue) {
+    /**
+     * 'DefaultAzureCredential' is not listed in the JDBC driver spec
+     * https://learn.microsoft.com/en-us/sql/connect/jdbc/setting-the-connection-properties?view=sql-server-ver15#properties
+     * but is supported by tedious so included here
+     */
+    case "DefaultAzureCredential":
+    case "ActiveDirectoryIntegrated":
+    case "ActiveDirectoryInteractive":
+      return { type: "azure-active-directory-default", options: {} };
+    case "ActiveDirectoryPassword": {
+      const userName = firstKey(parameters, "userName");
+      const password = firstKey(parameters, "password");
+      const clientId = firstKey(parameters, "clientId");
+      const tenantId = firstKey(parameters, "tenantId");
+      if (!userName || !password || !clientId) {
+        throw new Error(`Invalid authentication, ActiveDirectoryPassword requires userName, password, clientId`);
       }
-      case "socketTimeout": {
-        const socketTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(socketTimeout)) {
-          throw new Error(`Invalid socket timeout: ${trimmedValue}`);
+      return {
+        type: "azure-active-directory-password",
+        options: {
+          userName,
+          password,
+          clientId,
+          tenantId: tenantId || ""
         }
-        config3.requestTimeout = socketTimeout;
-        break;
+      };
+    }
+    case "ActiveDirectoryManagedIdentity":
+    case "ActiveDirectoryMSI": {
+      const clientId = firstKey(parameters, "clientId");
+      const msiEndpoint = firstKey(parameters, "msiEndpoint");
+      const msiSecret = firstKey(parameters, "msiSecret");
+      if (!msiEndpoint || !msiSecret) {
+        throw new Error(`Invalid authentication, ActiveDirectoryManagedIdentity requires msiEndpoint, msiSecret`);
       }
-      case "poolTimeout": {
-        const poolTimeout = parseInt(trimmedValue, 10);
-        if (isNaN(poolTimeout)) {
-          throw new Error(`Invalid pool timeout: ${trimmedValue}`);
+      return {
+        type: "azure-active-directory-msi-app-service",
+        options: {
+          clientId: clientId || void 0,
+          // @ts-expect-error TODO: tedious typings don't define msiEndpoint and msiSecret -- needs to be fixed upstream
+          msiEndpoint,
+          msiSecret
         }
-        config3.pool = config3.pool || {};
-        config3.pool.acquireTimeoutMillis = poolTimeout * 1e3;
-        break;
+      };
+    }
+    case "ActiveDirectoryServicePrincipal": {
+      const clientId = firstKey(parameters, "userName");
+      const clientSecret = firstKey(parameters, "password");
+      const tenantId = firstKey(parameters, "tenantId");
+      if (clientId && clientSecret) {
+        return {
+          type: "azure-active-directory-service-principal-secret",
+          options: {
+            clientId,
+            clientSecret,
+            tenantId: tenantId || ""
+          }
+        };
+      } else {
+        throw new Error(
+          `Invalid authentication, ActiveDirectoryServicePrincipal requires userName (clientId), password (clientSecret)`
+        );
       }
-      case "applicationName":
-      case "application name":
-        config3.options = config3.options || {};
-        config3.options.appName = trimmedValue;
-        break;
-      case "isolationLevel":
-        config3.options = config3.options || {};
-        config3.options.isolationLevel = mapIsolationLevelFromString(trimmedValue);
-        break;
-      case "schema":
-        break;
-      default:
-        debug5(`Unknown connection string parameter: ${trimmedKey}`);
     }
   }
-  if (!config3.server || config3.server.trim() === "") {
-    throw new Error("Server host is required in connection string");
+  return void 0;
+}
+function firstKey(parameters, ...keys) {
+  for (const key of keys) {
+    if (key in parameters) {
+      return parameters[key];
+    }
   }
-  return config3;
+  return null;
 }
+var handledParameters = [
+  "application name",
+  "applicationName",
+  "connectTimeout",
+  "connectionLimit",
+  "connectionTimeout",
+  "database",
+  "encrypt",
+  "initial catalog",
+  "isolationLevel",
+  "loginTimeout",
+  "password",
+  "poolTimeout",
+  "pwd",
+  "socketTimeout",
+  "trustServerCertificate",
+  "uid",
+  "user",
+  "userid",
+  "username"
+];
 function mapColumnType2(col) {
   switch (col.type) {
     case import_mssql3.default.VarChar:
@@ -110504,13 +111157,13 @@ var PrismaPgAdapter = class extends PgQueryable {
     const tag2 = "[js::startTransaction]";
     debug6("%s options: %O", tag2, options);
     const conn = await this.client.connect().catch((error44) => this.onError(error44));
-    const onError2 = (err) => {
+    const onError = (err) => {
       debug6(`Error from pool connection: ${err.message} %O`, err);
       this.pgOptions?.onConnectionError?.(err);
     };
-    conn.on("error", onError2);
+    conn.on("error", onError);
     const cleanup = () => {
-      conn.removeListener("error", onError2);
+      conn.removeListener("error", onError);
     };
     try {
       const tx = new PgTransaction(conn, options, this.pgOptions, cleanup);
@@ -110601,24 +111254,65 @@ var PrismaPgAdapterFactory = class {
 
 // src/logic/adapter.ts
 function createAdapter(url2) {
-  if (url2.startsWith("postgres://") || url2.startsWith("postgresql://")) {
-    return new PrismaPgAdapterFactory({
-      connectionString: url2
-    });
-  } else if (url2.startsWith("mysql://") || url2.startsWith("mariadb://")) {
-    return new PrismaMariaDbAdapterFactory(url2);
-  } else if (url2.startsWith("sqlserver://")) {
-    return new PrismaMssqlAdapterFactory(url2);
-  } else {
-    let urlObj;
-    try {
-      urlObj = new URL(url2);
-    } catch {
-      throw new Error("Invalid database URL");
+  for (const factory of factories) {
+    if (factory.protocols.some((protocol) => url2.startsWith(`${protocol}://`))) {
+      return factory.create(url2);
     }
-    throw new Error(`Unsupported protocol in database URL: ${urlObj.protocol}`);
   }
+  let urlObj;
+  try {
+    urlObj = new URL(url2);
+  } catch {
+    throw new Error("Invalid database URL");
+  }
+  throw new Error(`Unsupported protocol in database URL: ${urlObj.protocol}`);
 }
+var factories = [
+  {
+    protocols: ["postgres", "postgresql"],
+    create(connectionString) {
+      const url2 = new URL(connectionString);
+      if (["sslcert", "sslkey", "sslrootcert"].some((param) => url2.searchParams.has(param))) {
+        throw new Error(
+          "Unsupported parameters in connection string: uploading and using custom TLS certificates is not currently supported"
+        );
+      }
+      let sslmode = url2.searchParams.get("sslmode");
+      if (sslmode === null && url2.searchParams.get("ssl") === "true") {
+        sslmode = "require";
+      }
+      const ssl = (() => {
+        switch (sslmode) {
+          case null:
+          case "disable":
+            return false;
+          case "prefer":
+          case "require":
+          case "no-verify":
+            return { rejectUnauthorized: false };
+          case "verify-ca":
+          case "verify-full":
+            return true;
+          default:
+            throw new Error(`Unsupported sslmode: ${sslmode}`);
+        }
+      })();
+      return new PrismaPgAdapterFactory({ connectionString, ssl });
+    }
+  },
+  {
+    protocols: ["mysql", "mariadb"],
+    create(url2) {
+      return new PrismaMariaDbAdapterFactory(url2);
+    }
+  },
+  {
+    protocols: ["sqlserver"],
+    create(url2) {
+      return new PrismaMssqlAdapterFactory(url2);
+    }
+  }
+];
 
 // src/logic/resource-limits.ts
 var ResourceLimitError = class extends Error {