@prisma/fetch-engine 6.16.2 → 6.17.0-dev.10

package/dist/chmodPlusX.js

@@ -18,8 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var chmodPlusX_exports = {};
 __export(chmodPlusX_exports, {
-  chmodPlusX: () => import_chunk_MX3HXAU2.chmodPlusX
+  chmodPlusX: () => import_chunk_7JLQJWOR.chmodPlusX
 });
 module.exports = __toCommonJS(chmodPlusX_exports);
-var import_chunk_MX3HXAU2 = require("./chunk-MX3HXAU2.js");
+var import_chunk_7JLQJWOR = require("./chunk-7JLQJWOR.js");
 var import_chunk_QGM4M3NI = require("./chunk-QGM4M3NI.js");

package/dist/{chunk-4GLRZ2GS.js → chunk-2DPMENYP.js}

@@ -26,33 +26,33 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_4GLRZ2GS_exports = {};
-__export(chunk_4GLRZ2GS_exports, {
+var chunk_2DPMENYP_exports = {};
+__export(chunk_2DPMENYP_exports, {
   cleanupCache: () => cleanupCache
 });
-module.exports = __toCommonJS(chunk_4GLRZ2GS_exports);
-var import_chunk_SVP4SRAT = require("./chunk-SVP4SRAT.js");
-var import_chunk_YJOPKU47 = require("./chunk-YJOPKU47.js");
+module.exports = __toCommonJS(chunk_2DPMENYP_exports);
+var import_chunk_FSAAZH62 = require("./chunk-FSAAZH62.js");
+var import_chunk_7KB2WQ67 = require("./chunk-7KB2WQ67.js");
 var import_chunk_QGM4M3NI = require("./chunk-QGM4M3NI.js");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
 var import_debug = __toESM(require("@prisma/debug"));
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_p_map = (0, import_chunk_QGM4M3NI.__toESM)((0, import_chunk_SVP4SRAT.require_p_map)());
+var import_p_map = (0, import_chunk_QGM4M3NI.__toESM)((0, import_chunk_FSAAZH62.require_p_map)());
 var debug = (0, import_debug.default)("cleanupCache");
 async function cleanupCache(n = 5) {
   try {
-    const rootCacheDir = await (0, import_chunk_YJOPKU47.getRootCacheDir)();
+    const rootCacheDir = await (0, import_chunk_7KB2WQ67.getRootCacheDir)();
     if (!rootCacheDir) {
       debug("no rootCacheDir found");
       return;
     }
     const channel = "master";
-    const cacheDir = import_path.default.join(rootCacheDir, channel);
-    const dirs = await import_fs.default.promises.readdir(cacheDir);
+    const cacheDir = import_node_path.default.join(rootCacheDir, channel);
+    const dirs = await import_node_fs.default.promises.readdir(cacheDir);
     const dirsWithMeta = await Promise.all(
       dirs.map(async (dirName) => {
-        const dir = import_path.default.join(cacheDir, dirName);
-        const statResult = await import_fs.default.promises.stat(dir);
+        const dir = import_node_path.default.join(cacheDir, dirName);
+        const statResult = await import_node_fs.default.promises.stat(dir);
         return {
           dir,
           created: statResult.birthtime
@@ -61,7 +61,7 @@ async function cleanupCache(n = 5) {
     );
     dirsWithMeta.sort((a, b) => a.created < b.created ? 1 : -1);
     const dirsToRemove = dirsWithMeta.slice(n);
-    await (0, import_p_map.default)(dirsToRemove, (dir) => (0, import_chunk_SVP4SRAT.rimraf)(dir.dir), { concurrency: 20 });
+    await (0, import_p_map.default)(dirsToRemove, (dir) => import_node_fs.default.promises.rm(dir.dir, { force: true, recursive: true }), { concurrency: 20 });
   } catch (e) {
   }
 }

package/dist/{chunk-MX3HXAU2.js → chunk-7JLQJWOR.js}

@@ -26,19 +26,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_MX3HXAU2_exports = {};
-__export(chunk_MX3HXAU2_exports, {
+var chunk_7JLQJWOR_exports = {};
+__export(chunk_7JLQJWOR_exports, {
   chmodPlusX: () => chmodPlusX
 });
-module.exports = __toCommonJS(chunk_MX3HXAU2_exports);
-var import_fs = __toESM(require("fs"));
+module.exports = __toCommonJS(chunk_7JLQJWOR_exports);
+var import_node_fs = __toESM(require("node:fs"));
 function chmodPlusX(file) {
   if (process.platform === "win32") return;
-  const s = import_fs.default.statSync(file);
+  const s = import_node_fs.default.statSync(file);
   const newMode = s.mode | 64 | 8 | 1;
   if (s.mode === newMode) {
     return;
   }
   const base8 = newMode.toString(8).slice(-3);
-  import_fs.default.chmodSync(file, base8);
+  import_node_fs.default.chmodSync(file, base8);
 }

package/dist/{chunk-YJOPKU47.js → chunk-7KB2WQ67.js}

@@ -26,31 +26,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_YJOPKU47_exports = {};
-__export(chunk_YJOPKU47_exports, {
+var chunk_7KB2WQ67_exports = {};
+__export(chunk_7KB2WQ67_exports, {
   getCacheDir: () => getCacheDir,
   getDownloadUrl: () => getDownloadUrl,
   getRootCacheDir: () => getRootCacheDir,
   overwriteFile: () => overwriteFile,
   require_lib: () => require_lib
 });
-module.exports = __toCommonJS(chunk_YJOPKU47_exports);
+module.exports = __toCommonJS(chunk_7KB2WQ67_exports);
 var import_chunk_QGM4M3NI = require("./chunk-QGM4M3NI.js");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
 var import_debug = __toESM(require("@prisma/debug"));
 var import_get_platform = require("@prisma/get-platform");
 var import_node_process = __toESM(require("node:process"));
-var import_node_path = __toESM(require("node:path"));
-var import_node_fs = __toESM(require("node:fs"));
 var import_node_path2 = __toESM(require("node:path"));
+var import_node_fs2 = __toESM(require("node:fs"));
 var import_node_path3 = __toESM(require("node:path"));
+var import_node_path4 = __toESM(require("node:path"));
 var import_node_url = require("node:url");
 var import_node_process2 = __toESM(require("node:process"));
-var import_node_path4 = __toESM(require("node:path"));
-var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path5 = __toESM(require("node:path"));
+var import_node_fs3 = __toESM(require("node:fs"));
 var import_node_url2 = require("node:url");
-var import_fs = __toESM(require("fs"));
-var import_os = __toESM(require("os"));
-var import_path = __toESM(require("path"));
 var require_common_path_prefix = (0, import_chunk_QGM4M3NI.__commonJS)({
   "../../node_modules/.pnpm/common-path-prefix@3.0.0/node_modules/common-path-prefix/index.js"(exports, module2) {
     "use strict";
@@ -2169,10 +2169,10 @@ function locatePathSync(paths, {
 } = {}) {
   checkType(type);
   cwd2 = toPath(cwd2);
-  const statFunction = allowSymlinks ? import_node_fs2.default.statSync : import_node_fs2.default.lstatSync;
+  const statFunction = allowSymlinks ? import_node_fs3.default.statSync : import_node_fs3.default.lstatSync;
   for (const path_ of paths) {
     try {
-      const stat = statFunction(import_node_path4.default.resolve(cwd2, path_), {
+      const stat = statFunction(import_node_path5.default.resolve(cwd2, path_), {
         throwIfNoEntry: false
       });
       if (!stat) {
@@ -2188,8 +2188,8 @@ function locatePathSync(paths, {
 var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath;
 var findUpStop = Symbol("findUpStop");
 function findUpMultipleSync(name, options = {}) {
-  let directory = import_node_path3.default.resolve(toPath2(options.cwd) || "");
-  const { root } = import_node_path3.default.parse(directory);
+  let directory = import_node_path4.default.resolve(toPath2(options.cwd) || "");
+  const { root } = import_node_path4.default.parse(directory);
   const stopAt = options.stopAt || root;
   const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
@@ -2210,12 +2210,12 @@ function findUpMultipleSync(name, options = {}) {
       break;
     }
     if (foundPath) {
-      matches.push(import_node_path3.default.resolve(directory, foundPath));
+      matches.push(import_node_path4.default.resolve(directory, foundPath));
     }
     if (directory === stopAt || matches.length >= limit) {
       break;
     }
-    directory = import_node_path3.default.dirname(directory);
+    directory = import_node_path4.default.dirname(directory);
   }
   return matches;
 }
@@ -2225,12 +2225,12 @@ function findUpSync(name, options = {}) {
 }
 function packageDirectorySync({ cwd: cwd2 } = {}) {
   const filePath = findUpSync("package.json", { cwd: cwd2 });
-  return filePath && import_node_path2.default.dirname(filePath);
+  return filePath && import_node_path3.default.dirname(filePath);
 }
 var { env, cwd } = import_node_process.default;
 var isWritable = (path6) => {
   try {
-    import_node_fs.default.accessSync(path6, import_node_fs.default.constants.W_OK);
+    import_node_fs2.default.accessSync(path6, import_node_fs2.default.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -2238,27 +2238,27 @@ var isWritable = (path6) => {
 };
 function useDirectory(directory, options) {
   if (options.create) {
-    import_node_fs.default.mkdirSync(directory, { recursive: true });
+    import_node_fs2.default.mkdirSync(directory, { recursive: true });
   }
   return directory;
 }
 function getNodeModuleDirectory(directory) {
-  const nodeModules = import_node_path.default.join(directory, "node_modules");
-  if (!isWritable(nodeModules) && (import_node_fs.default.existsSync(nodeModules) || !isWritable(import_node_path.default.join(directory)))) {
+  const nodeModules = import_node_path2.default.join(directory, "node_modules");
+  if (!isWritable(nodeModules) && (import_node_fs2.default.existsSync(nodeModules) || !isWritable(import_node_path2.default.join(directory)))) {
     return;
   }
   return nodeModules;
 }
 function findCacheDirectory(options = {}) {
   if (env.CACHE_DIR && !["true", "false", "1", "0"].includes(env.CACHE_DIR)) {
-    return useDirectory(import_node_path.default.join(env.CACHE_DIR, options.name), options);
+    return useDirectory(import_node_path2.default.join(env.CACHE_DIR, options.name), options);
   }
   let { cwd: directory = cwd(), files } = options;
   if (files) {
     if (!Array.isArray(files)) {
       throw new TypeError(`Expected \`files\` option to be an array, got \`${typeof files}\`.`);
     }
-    directory = (0, import_common_path_prefix.default)(files.map((file) => import_node_path.default.resolve(directory, file)));
+    directory = (0, import_common_path_prefix.default)(files.map((file) => import_node_path2.default.resolve(directory, file)));
   }
   directory = packageDirectorySync({ cwd: directory });
   if (!directory) {
@@ -2268,18 +2268,18 @@ function findCacheDirectory(options = {}) {
   if (!nodeModules) {
     return;
   }
-  return useDirectory(import_node_path.default.join(directory, "node_modules", ".cache", options.name), options);
+  return useDirectory(import_node_path2.default.join(directory, "node_modules", ".cache", options.name), options);
 }
 var import_fs_extra = (0, import_chunk_QGM4M3NI.__toESM)(require_lib());
 var debug = (0, import_debug.default)("prisma:fetch-engine:cache-dir");
 async function getRootCacheDir() {
-  if (import_os.default.platform() === "win32") {
+  if (import_node_os.default.platform() === "win32") {
     const cacheDir = findCacheDirectory({ name: "prisma", create: true });
     if (cacheDir) {
       return cacheDir;
     }
     if (process.env.APPDATA) {
-      return import_path.default.join(process.env.APPDATA, "Prisma");
+      return import_node_path.default.join(process.env.APPDATA, "Prisma");
     }
   }
   if (process.env.AWS_LAMBDA_FUNCTION_VERSION) {
@@ -2290,16 +2290,16 @@ async function getRootCacheDir() {
       return null;
     }
   }
-  return import_path.default.join(import_os.default.homedir(), ".cache/prisma");
+  return import_node_path.default.join(import_node_os.default.homedir(), ".cache/prisma");
 }
 async function getCacheDir(channel, version, binaryTarget) {
   const rootCacheDir = await getRootCacheDir();
   if (!rootCacheDir) {
     return null;
   }
-  const cacheDir = import_path.default.join(rootCacheDir, channel, version, binaryTarget);
+  const cacheDir = import_node_path.default.join(rootCacheDir, channel, version, binaryTarget);
   try {
-    if (!import_fs.default.existsSync(cacheDir)) {
+    if (!import_node_fs.default.existsSync(cacheDir)) {
       await (0, import_fs_extra.ensureDir)(cacheDir);
     }
   } catch (e) {
@@ -2328,18 +2328,18 @@ function getDownloadUrl({
   return `${baseUrl}/${channel}/${version}/${binaryTarget}/${binaryName}${finalExtension}`;
 }
 async function overwriteFile(sourcePath, targetPath) {
-  if (import_os.default.platform() === "darwin") {
+  if (import_node_os.default.platform() === "darwin") {
     await removeFileIfExists(targetPath);
-    await import_fs.default.promises.copyFile(sourcePath, targetPath);
+    await import_node_fs.default.promises.copyFile(sourcePath, targetPath);
   } else {
     const tempPath = `${targetPath}.tmp${process.pid}`;
-    await import_fs.default.promises.copyFile(sourcePath, tempPath);
-    await import_fs.default.promises.rename(tempPath, targetPath);
+    await import_node_fs.default.promises.copyFile(sourcePath, tempPath);
+    await import_node_fs.default.promises.rename(tempPath, targetPath);
   }
 }
 async function removeFileIfExists(filePath) {
   try {
-    await import_fs.default.promises.unlink(filePath);
+    await import_node_fs.default.promises.unlink(filePath);
   } catch (e) {
     if (e.code !== "ENOENT") {
       throw e;

package/dist/{chunk-CWGQAQ3T.js → chunk-FKGWOTGU.js}

@@ -26,16 +26,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_CWGQAQ3T_exports = {};
-__export(chunk_CWGQAQ3T_exports, {
+var chunk_FKGWOTGU_exports = {};
+__export(chunk_FKGWOTGU_exports, {
   getHash: () => getHash
 });
-module.exports = __toCommonJS(chunk_CWGQAQ3T_exports);
-var import_crypto = __toESM(require("crypto"));
-var import_fs = __toESM(require("fs"));
+module.exports = __toCommonJS(chunk_FKGWOTGU_exports);
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_node_fs = __toESM(require("node:fs"));
 function getHash(filePath) {
-  const hash = import_crypto.default.createHash("sha256");
-  const input = import_fs.default.createReadStream(filePath);
+  const hash = import_node_crypto.default.createHash("sha256");
+  const input = import_node_fs.default.createReadStream(filePath);
   return new Promise((resolve) => {
     input.on("readable", () => {
       const data = input.read();

package/dist/chunk-FSAAZH62.js

@@ -0,0 +1,190 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_FSAAZH62_exports = {};
+__export(chunk_FSAAZH62_exports, {
+  require_p_map: () => require_p_map
+});
+module.exports = __toCommonJS(chunk_FSAAZH62_exports);
+var import_chunk_QGM4M3NI = require("./chunk-QGM4M3NI.js");
+var require_indent_string = (0, import_chunk_QGM4M3NI.__commonJS)({
+  "../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = (string, count = 1, options) => {
+      options = {
+        indent: " ",
+        includeEmptyLines: false,
+        ...options
+      };
+      if (typeof string !== "string") {
+        throw new TypeError(
+          `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+        );
+      }
+      if (typeof count !== "number") {
+        throw new TypeError(
+          `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+        );
+      }
+      if (typeof options.indent !== "string") {
+        throw new TypeError(
+          `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
+        );
+      }
+      if (count === 0) {
+        return string;
+      }
+      const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+      return string.replace(regex, options.indent.repeat(count));
+    };
+  }
+});
+var require_clean_stack = (0, import_chunk_QGM4M3NI.__commonJS)({
+  "../../node_modules/.pnpm/clean-stack@2.2.0/node_modules/clean-stack/index.js"(exports, module2) {
+    "use strict";
+    var os = (0, import_chunk_QGM4M3NI.__require)("os");
+    var extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/;
+    var pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/;
+    var homeDir = typeof os.homedir === "undefined" ? "" : os.homedir();
+    module2.exports = (stack, options) => {
+      options = Object.assign({ pretty: false }, options);
+      return stack.replace(/\\/g, "/").split("\n").filter((line) => {
+        const pathMatches = line.match(extractPathRegex);
+        if (pathMatches === null || !pathMatches[1]) {
+          return true;
+        }
+        const match = pathMatches[1];
+        if (match.includes(".app/Contents/Resources/electron.asar") || match.includes(".app/Contents/Resources/default_app.asar")) {
+          return false;
+        }
+        return !pathRegex.test(match);
+      }).filter((line) => line.trim() !== "").map((line) => {
+        if (options.pretty) {
+          return line.replace(extractPathRegex, (m, p1) => m.replace(p1, p1.replace(homeDir, "~")));
+        }
+        return line;
+      }).join("\n");
+    };
+  }
+});
+var require_aggregate_error = (0, import_chunk_QGM4M3NI.__commonJS)({
+  "../../node_modules/.pnpm/aggregate-error@3.1.0/node_modules/aggregate-error/index.js"(exports, module2) {
+    "use strict";
+    var indentString = require_indent_string();
+    var cleanStack = require_clean_stack();
+    var cleanInternalStack = (stack) => stack.replace(/\s+at .*aggregate-error\/index.js:\d+:\d+\)?/g, "");
+    var AggregateError = class extends Error {
+      constructor(errors) {
+        if (!Array.isArray(errors)) {
+          throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
+        }
+        errors = [...errors].map((error) => {
+          if (error instanceof Error) {
+            return error;
+          }
+          if (error !== null && typeof error === "object") {
+            return Object.assign(new Error(error.message), error);
+          }
+          return new Error(error);
+        });
+        let message = errors.map((error) => {
+          return typeof error.stack === "string" ? cleanInternalStack(cleanStack(error.stack)) : String(error);
+        }).join("\n");
+        message = "\n" + indentString(message, 4);
+        super(message);
+        this.name = "AggregateError";
+        Object.defineProperty(this, "_errors", { value: errors });
+      }
+      *[Symbol.iterator]() {
+        for (const error of this._errors) {
+          yield error;
+        }
+      }
+    };
+    module2.exports = AggregateError;
+  }
+});
+var require_p_map = (0, import_chunk_QGM4M3NI.__commonJS)({
+  "../../node_modules/.pnpm/p-map@4.0.0/node_modules/p-map/index.js"(exports, module2) {
+    "use strict";
+    var AggregateError = require_aggregate_error();
+    module2.exports = async (iterable, mapper, {
+      concurrency = Infinity,
+      stopOnError = true
+    } = {}) => {
+      return new Promise((resolve, reject) => {
+        if (typeof mapper !== "function") {
+          throw new TypeError("Mapper function is required");
+        }
+        if (!((Number.isSafeInteger(concurrency) || concurrency === Infinity) && concurrency >= 1)) {
+          throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+        }
+        const result = [];
+        const errors = [];
+        const iterator = iterable[Symbol.iterator]();
+        let isRejected = false;
+        let isIterableDone = false;
+        let resolvingCount = 0;
+        let currentIndex = 0;
+        const next = () => {
+          if (isRejected) {
+            return;
+          }
+          const nextItem = iterator.next();
+          const index = currentIndex;
+          currentIndex++;
+          if (nextItem.done) {
+            isIterableDone = true;
+            if (resolvingCount === 0) {
+              if (!stopOnError && errors.length !== 0) {
+                reject(new AggregateError(errors));
+              } else {
+                resolve(result);
+              }
+            }
+            return;
+          }
+          resolvingCount++;
+          (async () => {
+            try {
+              const element = await nextItem.value;
+              result[index] = await mapper(element, index);
+              resolvingCount--;
+              next();
+            } catch (error) {
+              if (stopOnError) {
+                isRejected = true;
+                reject(error);
+              } else {
+                errors.push(error);
+                resolvingCount--;
+                next();
+              }
+            }
+          })();
+        };
+        for (let i = 0; i < concurrency; i++) {
+          next();
+          if (isIterableDone) {
+            break;
+          }
+        }
+      });
+    };
+  }
+});