@joystick.js/node-canary 0.0.0-canary.46 → 0.0.0-canary.460

package/dist/app/middleware/render.js

@@ -1,213 +0,0 @@
-import fs from "fs";
-import dayjs from "dayjs";
-import crypto from "crypto";
-import ssr from "../../ssr/index.js";
-import { isObject } from "../../validation/lib/typeValidators";
-import settings from "../../settings";
-import generateErrorPage from "../../lib/generateErrorPage.js";
-import replaceFileProtocol from "../../lib/replaceFileProtocol.js";
-import replaceBackslashesWithForwardSlashes from "../../lib/replaceBackslashesWithForwardSlashes.js";
-import getBuildPath from "../../lib/getBuildPath.js";
-import escapeHTML from "../../lib/escapeHTML.js";
-import escapeKeyValuePair from "../../lib/escapeKeyValuePair.js";
-const generateHash = (input = "") => {
-  return crypto.createHash("sha256").update(input).digest("hex");
-};
-const getCacheDiff = async (diffFunction = null) => {
-  if (diffFunction) {
-    const diff = await diffFunction();
-    const diffHash = typeof diff === "string" ? generateHash(diff) : null;
-    return diffHash;
-  }
-  return null;
-};
-const writeCacheFileToDisk = ({
-  expiresAfterMinutes = "",
-  cachePath = "",
-  cacheFileName = "index",
-  currentDiff = null,
-  html = ""
-}) => {
-  const expiresAt = dayjs().add(expiresAfterMinutes, "minutes").unix();
-  fs.mkdir(`${cachePath}/_cache`, { recursive: true }, () => {
-    fs.writeFile(`${cachePath}/_cache/${cacheFileName}_${expiresAt}.html`, html, (error) => {
-      if (error) {
-        console.warn(error);
-      }
-    });
-    if (currentDiff) {
-      fs.writeFile(`${cachePath}/_cache/diff_${expiresAt}`, currentDiff, (error) => {
-        if (error) {
-          console.warn(error);
-        }
-      });
-    }
-  });
-};
-const getCachedHTML = ({ cachePath, cacheFileName, currentDiff }) => {
-  const files = fs.existsSync(`${cachePath}/_cache`) ? fs.readdirSync(`${cachePath}/_cache`) : [];
-  const cacheFile = files?.find((file) => file?.includes(cacheFileName));
-  const cacheFileExpiresAtUnix = cacheFile?.replace(`${cacheFileName}_`, "").replace(".html", "");
-  const existingDiff = fs.existsSync(`${cachePath}/_cache/diff_${cacheFileExpiresAtUnix}`) ? fs.readFileSync(`${cachePath}/_cache/diff_${cacheFileExpiresAtUnix}`, "utf-8") : null;
-  const cacheFileDiffHasChanged = existingDiff !== currentDiff;
-  const cacheFileExpiresAtHasPassed = dayjs().isAfter(dayjs.unix(parseInt(cacheFileExpiresAtUnix)));
-  const cacheFileHasExpired = cacheFileDiffHasChanged || cacheFileExpiresAtHasPassed;
-  if (cacheFileDiffHasChanged || cacheFileExpiresAtHasPassed) {
-    fs.unlink(`${cachePath}/_cache/${cacheFile}`, (error) => {
-      if (error)
-        return;
-    });
-    fs.unlink(`${cachePath}/_cache/diff_${cacheFileExpiresAtUnix}`, (error) => {
-      if (error)
-        return;
-    });
-  }
-  return cacheFile && !cacheFileHasExpired ? fs.readFileSync(`${cachePath}/_cache/${cacheFile}`, "utf-8") : null;
-};
-const getUrl = (request = {}) => {
-  const [path = null] = request.url?.split("?");
-  return {
-    params: escapeKeyValuePair(request.params),
-    query: escapeKeyValuePair(request.query),
-    route: escapeHTML(request.route.path),
-    path: escapeHTML(path)
-  };
-};
-const getFile = async (buildPath = "") => {
-  const file = await import(buildPath);
-  return file.default;
-};
-const getTranslationsFile = async (languageFilePath = "", paths = "") => {
-  const languageFile = await getFile(`${paths.build}/i18n/${languageFilePath}`);
-  const isValidLanguageFile = languageFile && isObject(languageFile);
-  if (isValidLanguageFile) {
-    const translationsForPage = languageFile[paths.page];
-    return translationsForPage ? translationsForPage : languageFile;
-  }
-  return {};
-};
-const getTranslations = async (paths = {}, languagePreferences = []) => {
-  const languageFiles = fs.readdirSync(`${paths.build}/i18n`);
-  let matchingFile = null;
-  for (let i = 0; i < languagePreferences.length; i += 1) {
-    const languageRegex = languagePreferences[i];
-    const match = languageFiles.find((languageFile) => !!languageFile.match(languageRegex));
-    if (match) {
-      matchingFile = match;
-      break;
-    }
-  }
-  const translationsFile = await getTranslationsFile(matchingFile, paths);
-  return translationsFile;
-};
-const getLanguagePreferenceRegexes = (userLanguage = "", browserLanguages = []) => {
-  let languagePreferences = [];
-  if (userLanguage) {
-    languagePreferences.push(userLanguage);
-  }
-  const filteredBrowserLanguages = browserLanguages?.filter((language) => {
-    return !language?.includes("*");
-  });
-  languagePreferences.push(...filteredBrowserLanguages);
-  languagePreferences.push(settings?.config?.i18n?.defaultLanguage);
-  return languagePreferences?.flatMap((language) => {
-    const variants = [language];
-    if (language?.length === 2) {
-      variants.push(`${language.substring(0, 2)}-`);
-    }
-    if (language?.length > 2) {
-      variants.push(`${language?.split("-")[0]}`);
-      variants.push(`${language?.split("-")[0]}-`);
-    }
-    return variants;
-  })?.map((languageString) => {
-    const lastCharacter = languageString[languageString.length - 1];
-    if (lastCharacter === "-") {
-      return new RegExp(`^${languageString}[A-Z]+.js`, "g");
-    }
-    return new RegExp(`^${languageString}.js`, "g");
-  });
-};
-const parseBrowserLanguages = (languages = "") => {
-  const rawLanguages = languages.split(",");
-  return rawLanguages?.map((rawLanguage) => rawLanguage.split(";")[0]);
-};
-var render_default = (req, res, next, appInstance = {}) => {
-  res.render = async function(path = "", options = {}) {
-    const urlFormattedForCache = req?.url?.split("/")?.filter((part) => !!part)?.join("_");
-    const buildPathForEnvironment = getBuildPath();
-    const buildPath = replaceFileProtocol(replaceBackslashesWithForwardSlashes(`${process.cwd().replace(buildPathForEnvironment, "")}/${buildPathForEnvironment}`));
-    const pagePath = `${buildPath}${path}`;
-    const layoutPath = options.layout ? `${buildPath}${options.layout}` : null;
-    const pagePathParts = `${buildPathForEnvironment}${path}`?.split("/")?.filter((part) => !!part);
-    const cachePath = pagePathParts?.slice(0, pagePathParts.length - 1)?.join("/");
-    let currentDiff;
-    if (!fs.existsSync(pagePath)) {
-      return res.status(404).send(generateErrorPage({
-        type: "pageNotFound",
-        path: `res.render('${path}')`,
-        frame: null,
-        stack: `A page component at the path ${path} could not be found.`
-      }));
-    }
-    if (layoutPath && !fs.existsSync(layoutPath)) {
-      return res.status(404).send(generateErrorPage({
-        type: "layoutNotFound",
-        path: `res.render('${path}', { layout: '${options.layout}' })`,
-        frame: null,
-        stack: `A layout component at the path ${options.layout} could not be found.`
-      }));
-    }
-    if (options?.cache?.expiresAfterMinutes) {
-      currentDiff = typeof options?.cache?.diff === "function" ? await getCacheDiff(options?.cache?.diff) : null;
-      const cachedHTML = await getCachedHTML({
-        cachePath,
-        cacheFileName: urlFormattedForCache?.trim() === "" ? "index" : urlFormattedForCache,
-        currentDiff
-      });
-      if (cachedHTML) {
-        return res.send(cachedHTML);
-      }
-    }
-    const pageFile = await getFile(pagePath);
-    const Page = pageFile;
-    const layoutFile = layoutPath ? await getFile(layoutPath) : null;
-    const Layout = layoutFile;
-    const browserLanguages = parseBrowserLanguages(req?.headers["accept-language"]);
-    const languagePreferenceRegexes = getLanguagePreferenceRegexes(req?.context?.user?.language, browserLanguages);
-    const translations = await getTranslations({ build: buildPath, page: path }, languagePreferenceRegexes);
-    const url = getUrl(req);
-    const props = { ...options?.props || {} };
-    if (layoutPath && fs.existsSync(layoutPath)) {
-      props.page = Page;
-    }
-    const html = await ssr({
-      componentFunction: Layout || Page,
-      req,
-      props,
-      url,
-      translations,
-      attributes: options?.attributes,
-      email: false,
-      baseHTMLPath: null,
-      layoutComponentPath: options?.layout,
-      pageComponentPath: path?.substring(0, 1) === "/" ? path?.replace("/", "") : path,
-      head: options?.head,
-      api: appInstance?.options?.api
-    });
-    if (options?.cache?.expiresAfterMinutes) {
-      writeCacheFileToDisk({
-        expiresAfterMinutes: parseInt(options?.cache?.expiresAfterMinutes),
-        cachePath,
-        cacheFileName: urlFormattedForCache?.trim() === "" ? "index" : urlFormattedForCache,
-        currentDiff,
-        html
-      });
-    }
-    return res.status(200).send(html);
-  };
-  next();
-};
-export {
-  render_default as default
-};

package/dist/app/middleware/requestMethods.js

@@ -1,19 +0,0 @@
-var requestMethods_default = (req, res, next) => {
-  const allowedMethods = [
-    "OPTIONS",
-    "HEAD",
-    "CONNECT",
-    "GET",
-    "POST",
-    "PUT",
-    "DELETE",
-    "PATCH"
-  ];
-  if (!allowedMethods.includes(req.method)) {
-    res.status(405).send(`${req.method} not allowed.`);
-  }
-  next();
-};
-export {
-  requestMethods_default as default
-};

package/dist/app/registerGetters.js

@@ -1,45 +0,0 @@
-import getAPIURLComponent from "./getAPIURLComponent";
-import getAPIContext from "./getAPIContext";
-import formatAPIError from "../lib/formatAPIError";
-import validate from "../validation/index.js";
-import getOutput from "./getOutput";
-import sanitizeAPIResponse from "./sanitizeAPIResponse";
-import { isObject } from "../validation/lib/typeValidators";
-import validateSession from "./validateSession.js";
-import runGetter from "./runGetter.js";
-var registerGetters_default = (express, getters = [], context = {}, APIOptions = {}, appInstance = {}) => {
-  const { app } = express;
-  if (app) {
-    for (const [getterName, getterOptions] of getters) {
-      app.get(`/api/_getters/${getAPIURLComponent(getterName)}`, ...Array.isArray(getterOptions?.middleware) ? getterOptions?.middleware : [], async (req, res) => {
-        const isValidSession = validateSession(req, res, appInstance?.sessions);
-        if (!isValidSession) {
-          return;
-        }
-        const getterContext = await getAPIContext({ req, res }, context);
-        const input = req?.query?.input ? JSON.parse(req?.query?.input) : null;
-        const output = req?.query?.output ? JSON.parse(req?.query?.output) : null;
-        runGetter({
-          getterName,
-          getterOptions,
-          input,
-          output,
-          APIOptions,
-          context: getterContext
-        }).then((response) => {
-          return res.status(200).send(JSON.stringify(response));
-        }).catch((error) => {
-          if (typeof error === "string") {
-            return res.status(500).send(error);
-          }
-          if (typeof error === "object" && !Array.isArray(error)) {
-            return res.status(error?.errors && error?.errors[0]?.status || 400).send(JSON.stringify(error));
-          }
-        });
-      });
-    }
-  }
-};
-export {
-  registerGetters_default as default
-};

package/dist/app/registerSetters.js

@@ -1,45 +0,0 @@
-import getAPIURLComponent from "./getAPIURLComponent.js";
-import getAPIContext from "./getAPIContext.js";
-import formatAPIError from "../lib/formatAPIError.js";
-import validate from "../validation/index.js";
-import getOutput from "./getOutput.js";
-import sanitizeAPIResponse from "./sanitizeAPIResponse.js";
-import { isObject } from "../validation/lib/typeValidators.js";
-import validateSession from "./validateSession.js";
-import runSetter from "./runSetter.js";
-var registerSetters_default = (express, setters = [], context = {}, APIOptions = {}, appInstance = {}) => {
-  const { app } = express;
-  if (app) {
-    for (const [setterName, setterOptions] of setters) {
-      app.post(`/api/_setters/${getAPIURLComponent(setterName)}`, ...Array.isArray(setterOptions?.middleware) ? setterOptions?.middleware : [], async (req, res) => {
-        const isValidSession = validateSession(req, res, appInstance?.sessions);
-        if (!isValidSession) {
-          return;
-        }
-        const setterContext = await getAPIContext({ req, res }, context);
-        const input = req?.body?.input || null;
-        const output = req?.body?.output || null;
-        runSetter({
-          setterName,
-          setterOptions,
-          input,
-          output,
-          APIOptions,
-          context: setterContext
-        }).then((response) => {
-          return res.status(200).send(JSON.stringify(response));
-        }).catch((error) => {
-          if (typeof error === "string") {
-            return res.status(500).send(error);
-          }
-          if (typeof error === "object" && !Array.isArray(error)) {
-            return res.status(error?.errors && error?.errors[0]?.status || 400).send(JSON.stringify(error));
-          }
-        });
-      });
-    }
-  }
-};
-export {
-  registerSetters_default as default
-};

package/dist/app/runGetter.js

@@ -1,103 +0,0 @@
-import validate from "../validation/index.js";
-import formatAPIError from "../lib/formatAPIError.js";
-import { isObject } from "../validation/lib/typeValidators.js";
-import getOutput from "./getOutput.js";
-import sanitizeAPIResponse from "./sanitizeAPIResponse.js";
-const handleRunGetter = async (getterOptions = {}, input = {}, output = {}, context = {}, APIOptions = {}) => {
-  try {
-    const shouldDisableSanitizationForGetter = getterOptions?.sanitize === false;
-    const shouldSanitizeOutput = (getterOptions?.sanitize || APIOptions?.sanitize) === true || isObject(APIOptions?.sanitize || getterOptions?.sanitize);
-    const data = await getterOptions?.get(input, context) || {};
-    const response = output ? getOutput(data, output) : data;
-    return !shouldDisableSanitizationForGetter && shouldSanitizeOutput ? sanitizeAPIResponse(response, getterOptions?.sanitize || APIOptions?.sanitize) : response;
-  } catch (exception) {
-    throw new Error(`[runGetter.handleRunGetter] ${exception.message}`);
-  }
-};
-const handleRunAuthorization = async (getterOptions = {}, input = {}, context = {}) => {
-  try {
-    const authorization = await getterOptions?.authorized(input, context);
-    if (typeof authorization === "boolean") {
-      return authorization;
-    }
-    if (typeof authorization === "object" && !Array.isArray(authorization) && typeof authorization?.authorized !== "undefined") {
-      return authorization?.authorized ? true : authorization?.message;
-    }
-  } catch (exception) {
-    throw new Error(`[runGetter.runAuthorization] ${exception.message}`);
-  }
-};
-const handleLogValidationErrors = (validationErrors = [], getterName = "") => {
-  try {
-    console.log(`Input validation for getter "${getterName}" failed with the following errors:
-`);
-    for (let i = 0; i < validationErrors?.length; i += 1) {
-      const validationError = validationErrors[i];
-      console.log(`${i + 1}. ${validationError}`);
-    }
-  } catch (exception) {
-    throw new Error(`[runGetter.handleLogValidationErrors] ${exception.message}`);
-  }
-};
-const handleRunValidation = async (input = {}, getterOptions = {}) => {
-  try {
-    let validationErrors = [];
-    if (Object.keys(getterOptions?.input || {})?.length > 0) {
-      validationErrors = await validate.inputWithSchema(input, getterOptions.input);
-    }
-    return validationErrors;
-  } catch (exception) {
-    throw new Error(`[runGetter.runValidation] ${exception.message}`);
-  }
-};
-const validateOptions = (options) => {
-  try {
-    if (!options)
-      throw new Error("options object is required.");
-    if (!options.getterName)
-      throw new Error("options.getterName is required.");
-    if (!options.getterOptions)
-      throw new Error("options.getterOptions is required.");
-  } catch (exception) {
-    throw new Error(`[runGetter.validateOptions] ${exception.message}`);
-  }
-};
-const runGetter = async (options, { resolve, reject }) => {
-  try {
-    validateOptions(options);
-    if (Object?.keys(options?.getterOptions?.input || {})?.length > 0) {
-      const validationErrors = await handleRunValidation(options?.input, options?.getterOptions);
-      if (validationErrors?.length > 0) {
-        handleLogValidationErrors(validationErrors, options?.getterName);
-        return reject({
-          errors: validationErrors.map((error) => {
-            return formatAPIError(new Error(error), "validation", 401);
-          })
-        });
-      }
-    }
-    if (typeof options?.getterOptions?.authorized === "function") {
-      const authorized = await handleRunAuthorization(options?.getterOptions, options?.input, options?.context);
-      if (!authorized || typeof authorized === "string") {
-        return reject({
-          errors: [
-            formatAPIError(new Error(typeof authorized === "string" ? authorized : `Not authorized to access ${options?.getterName}.`), "authorized", 403)
-          ]
-        });
-      }
-    }
-    if (typeof options?.getterOptions?.get === "function") {
-      const response = await handleRunGetter(options?.getterOptions, options?.input, options?.output, options?.context, options?.APIOptions);
-      return resolve(response);
-    }
-    resolve();
-  } catch (exception) {
-    reject(`[runGetter] ${exception.message}`);
-  }
-};
-var runGetter_default = (options) => new Promise((resolve, reject) => {
-  runGetter(options, { resolve, reject });
-});
-export {
-  runGetter_default as default
-};

package/dist/app/runSetter.js

@@ -1,103 +0,0 @@
-import validate from "../validation/index.js";
-import formatAPIError from "../lib/formatAPIError.js";
-import { isObject } from "../validation/lib/typeValidators.js";
-import getOutput from "./getOutput.js";
-import sanitizeAPIResponse from "./sanitizeAPIResponse.js";
-const handleRunSetter = async (setterOptions = {}, input = {}, output = {}, context = {}, APIOptions = {}) => {
-  try {
-    const shouldDisableSanitizationForSetter = setterOptions?.sanitize === false;
-    const shouldSanitizeOutput = (setterOptions?.sanitize || APIOptions?.sanitize) === true || isObject(APIOptions?.sanitize || setterOptions?.sanitize);
-    const data = await setterOptions?.set(input, context) || {};
-    const response = output ? getOutput(data, output) : data;
-    return !shouldDisableSanitizationForSetter && shouldSanitizeOutput ? sanitizeAPIResponse(response, setterOptions?.sanitize || APIOptions?.sanitize) : response;
-  } catch (exception) {
-    throw new Error(`[runSetter.handleRunSetter] ${exception.message}`);
-  }
-};
-const handleRunAuthorization = async (getterOptions = {}, input = {}, context = {}) => {
-  try {
-    const authorization = await getterOptions?.authorized(input, context);
-    if (typeof authorization === "boolean") {
-      return authorization;
-    }
-    if (typeof authorization === "object" && !Array.isArray(authorization) && typeof authorization?.authorized !== "undefined") {
-      return authorization?.authorized ? true : authorization?.message;
-    }
-  } catch (exception) {
-    throw new Error(`[runSetter.runAuthorization] ${exception.message}`);
-  }
-};
-const handleLogValidationErrors = (validationErrors = [], setterName = "") => {
-  try {
-    console.log(`Input validation for setter "${setterName}" failed with the following errors:
-`);
-    for (let i = 0; i < validationErrors?.length; i += 1) {
-      const validationError = validationErrors[i];
-      console.log(`${i + 1}. ${validationError}`);
-    }
-  } catch (exception) {
-    throw new Error(`[runSetter.handleLogValidationErrors] ${exception.message}`);
-  }
-};
-const handleRunValidation = async (input = {}, setterOptions = {}) => {
-  try {
-    let validationErrors = [];
-    if (Object.keys(setterOptions?.input || {})?.length > 0) {
-      validationErrors = await validate.inputWithSchema(input, setterOptions.input);
-    }
-    return validationErrors;
-  } catch (exception) {
-    throw new Error(`[runSetter.runValidation] ${exception.message}`);
-  }
-};
-const validateOptions = (options) => {
-  try {
-    if (!options)
-      throw new Error("options object is required.");
-    if (!options.setterName)
-      throw new Error("options.setterName is required.");
-    if (!options.setterOptions)
-      throw new Error("options.setterOptions is required.");
-  } catch (exception) {
-    throw new Error(`[runSetter.validateOptions] ${exception.message}`);
-  }
-};
-const runSetter = async (options, { resolve, reject }) => {
-  try {
-    validateOptions(options);
-    if (Object?.keys(options?.setterOptions?.input || {})?.length > 0) {
-      const validationErrors = await handleRunValidation(options?.input, options?.setterOptions);
-      if (validationErrors?.length > 0) {
-        handleLogValidationErrors(validationErrors, options?.setterName);
-        return reject({
-          errors: validationErrors.map((error) => {
-            return formatAPIError(new Error(error), `setters.${options?.setterName}.validation`, 401);
-          })
-        });
-      }
-    }
-    if (typeof options?.setterOptions?.authorized === "function") {
-      const authorized = await handleRunAuthorization(options?.setterOptions, options?.input, options?.context);
-      if (!authorized || typeof authorized === "string") {
-        return reject({
-          errors: [
-            formatAPIError(new Error(typeof authorized === "string" ? authorized : `Not authorized to access ${options?.setterName}.`), `setters.${options?.setterName}.authorized`, 403)
-          ]
-        });
-      }
-    }
-    if (typeof options?.setterOptions?.set === "function") {
-      const response = await handleRunSetter(options?.setterOptions, options?.input, options?.output, options?.context, options?.APIOptions);
-      return resolve(response);
-    }
-    resolve();
-  } catch (exception) {
-    reject(`[runSetter] ${exception.message}`);
-  }
-};
-var runSetter_default = (options) => new Promise((resolve, reject) => {
-  runSetter(options, { resolve, reject });
-});
-export {
-  runSetter_default as default
-};

package/dist/app/runUploader.js

@@ -1,143 +0,0 @@
-import fs from "fs";
-import AWS from "aws-sdk";
-import path from "path";
-import emitWebsocketEvent from "../websockets/emitWebsocketEvent";
-const uploadToS3 = (upload = {}, options = {}, onUploadProgress) => {
-  try {
-    return new Promise((resolve) => {
-      const temporaryFilePath = `.joystick/uploads/_tmp/${upload?.fileName}`;
-      if (!fs.existsSync(".joystick/uploads/_tmp")) {
-        fs.mkdirSync(".joystick/uploads/_tmp", { recursive: true });
-      }
-      const uploadParams = {
-        Bucket: upload?.s3?.bucket,
-        Key: upload?.fileName,
-        Body: upload?.content
-      };
-      if (upload?.fileName?.includes(".svg")) {
-        uploadParams.ContentType = "image/svg+xml";
-      }
-      if (upload?.s3?.acl) {
-        uploadParams.ACL = upload?.s3?.acl;
-      }
-      const s3 = new AWS.S3({
-        accessKeyId: upload?.s3?.accessKeyId,
-        secretAccessKey: upload?.s3?.secretAccessKey,
-        region: upload?.s3?.region
-      });
-      const s3Upload = s3.upload(uploadParams, {
-        partSize: 5 * 1024 * 1024,
-        queueSize: 3
-      });
-      let previous = 0;
-      s3Upload.on("httpUploadProgress", (s3UploadProgress) => {
-        onUploadProgress("s3", s3UploadProgress?.loaded - previous);
-        previous = s3UploadProgress?.loaded;
-      });
-      s3Upload.send((error, data) => {
-        if (error) {
-          console.warn(error);
-        }
-        fs.unlink(temporaryFilePath, () => {
-          const response = {
-            id: options?.req?.headers["x-joystick-upload-id"],
-            provider: "s3",
-            url: data?.Location,
-            size: upload?.fileSize,
-            fileName: upload?.fileName,
-            originalFileName: upload?.originalFileName,
-            mimeType: upload?.mimeType
-          };
-          if (error) {
-            response.error = error?.message || "There was an error uploading your file to Amazon S3. Check the server logs for more information.";
-          }
-          resolve(response);
-        });
-      });
-    });
-  } catch (exception) {
-    throw new Error(`[runUploader.uploadToS3] ${exception.message}`);
-  }
-};
-const uploadToLocal = (upload = {}, options = {}) => {
-  try {
-    return new Promise((resolve) => {
-      if (upload?.local?.path) {
-        if (!fs.existsSync(upload?.local?.path)) {
-          fs.mkdirSync(upload?.local?.path, { recursive: true });
-        }
-        const directoryPath = path.dirname(`${upload?.local?.path}/${upload?.fileName}`);
-        if (!fs.existsSync(directoryPath)) {
-          fs.mkdirSync(directoryPath, { recursive: true });
-        }
-        const filePath = `${upload?.local?.path}/${upload?.fileName}` || `./_uploads/${upload?.fileName}`;
-        fs.writeFile(filePath, upload?.content, () => {
-          resolve({
-            id: options?.req?.headers["x-joystick-upload-id"],
-            provider: "local",
-            url: filePath,
-            size: upload?.fileSize,
-            fileName: upload?.fileName,
-            originalFileName: upload?.originalFileName,
-            mimeType: upload?.mimeType
-          });
-        });
-      }
-    });
-  } catch (exception) {
-    throw new Error(`[runUploader.uploadToLocal] ${exception.message}`);
-  }
-};
-const handleUploads = async (options = {}) => {
-  try {
-    const uploads = [];
-    let alreadyUploaded = options?.alreadyUploaded;
-    const onUploadProgress = (provider = "", chunk = 0) => {
-      const progress = alreadyUploaded + chunk;
-      const percentage = Math.round(progress / options?.totalFileSizeAllProviders * 100);
-      emitWebsocketEvent(`uploaders_${options?.req?.headers["x-joystick-upload-id"]}`, "progress", { provider, progress: percentage });
-      alreadyUploaded += chunk;
-    };
-    for (let i = 0; i < options?.uploads?.length; i += 1) {
-      const upload = options?.uploads[i];
-      if (upload?.providers?.includes("local")) {
-        const result = await uploadToLocal(upload, { ...options });
-        uploads.push(result);
-      }
-      if (upload?.providers?.includes("s3")) {
-        const result = await uploadToS3(upload, { ...options }, onUploadProgress);
-        uploads.push(result);
-      }
-    }
-    return uploads;
-  } catch (exception) {
-    throw new Error(`[runUploader.handleUploads] ${exception.message}`);
-  }
-};
-const validateOptions = (options) => {
-  try {
-    if (!options)
-      throw new Error("options object is required.");
-    if (!options.uploads)
-      throw new Error("options.uploads is required.");
-    if (!options.req)
-      throw new Error("options.req is required.");
-  } catch (exception) {
-    throw new Error(`[runUploader.validateOptions] ${exception.message}`);
-  }
-};
-const runUploader = async (options, promise = {}) => {
-  try {
-    validateOptions(options);
-    const completedUploads = await handleUploads(options);
-    promise.resolve(completedUploads);
-  } catch (exception) {
-    promise.reject(exception.message);
-  }
-};
-var runUploader_default = (options) => new Promise((resolve, reject) => {
-  runUploader(options, { resolve, reject });
-});
-export {
-  runUploader_default as default
-};