@visulima/storage 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/packem_shared/local-meta-storage-By-3SNBI.js

@@ -0,0 +1,649 @@
+import { utimes } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { throwErrorCode, ERRORS } from './ERRORS-D0apMqnc.js';
+import MetaStorage from './MetaStorage-pECeFOad.js';
+import { stringifyMetadata, parseMetadata } from './Metadata-DRLXeJ0F.js';
+import { a as normalizeWindowsPath, d as dirname, n as normalize, j as join } from './path-CR6YkPXX-7R1-9CMk.js';
+import { createRequire } from 'node:module';
+
+const F_OK = 0;
+const R_OK = 4;
+
+const assertValidFileOrDirectoryPath = (fileOrDirectoryPath) => {
+  if (!fileOrDirectoryPath || !(fileOrDirectoryPath instanceof URL) && typeof fileOrDirectoryPath !== "string") {
+    throw new TypeError("Path must be a non-empty string or URL.");
+  }
+};
+
+const getFileInfoType = (fileInfo) => {
+  if (fileInfo.isFile()) {
+    return "file";
+  }
+  if (fileInfo.isDirectory()) {
+    return "dir";
+  }
+  if (fileInfo.isSymbolicLink()) {
+    return "symlink";
+  }
+  return void 0;
+};
+
+const __cjs_require$5 = createRequire(import.meta.url);
+const __cjs_getProcess$5 = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+const __cjs_getBuiltinModule$5 = (module) => {
+  if (typeof __cjs_getProcess$5 !== "undefined" && __cjs_getProcess$5.versions && __cjs_getProcess$5.versions.node) {
+    const [major, minor] = __cjs_getProcess$5.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess$5.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require$5(module);
+};
+const {
+  lstat,
+  mkdir: mkdir$1
+} = __cjs_getBuiltinModule$5("node:fs/promises");
+const ensureDir = async (directory) => {
+  assertValidFileOrDirectoryPath(directory);
+  try {
+    const fileInfo = await lstat(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+    }
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  try {
+    await mkdir$1(directory, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const fileInfo = await lstat(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+    }
+  }
+};
+
+const __cjs_require$4 = createRequire(import.meta.url);
+const __cjs_getProcess$4 = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+const __cjs_getBuiltinModule$4 = (module) => {
+  if (typeof __cjs_getProcess$4 !== "undefined" && __cjs_getProcess$4.versions && __cjs_getProcess$4.versions.node) {
+    const [major, minor] = __cjs_getProcess$4.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess$4.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require$4(module);
+};
+const {
+  fileURLToPath
+} = __cjs_getBuiltinModule$4("node:url");
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var binaryExtensions$1;
+var hasRequiredBinaryExtensions;
+function requireBinaryExtensions() {
+  if (hasRequiredBinaryExtensions) return binaryExtensions$1;
+  hasRequiredBinaryExtensions = 1;
+  binaryExtensions$1 = [
+    "3dm",
+    "3ds",
+    "3g2",
+    "3gp",
+    "7z",
+    "a",
+    "aac",
+    "adp",
+    "afdesign",
+    "afphoto",
+    "afpub",
+    "ai",
+    "aif",
+    "aiff",
+    "alz",
+    "ape",
+    "apk",
+    "appimage",
+    "ar",
+    "arj",
+    "asf",
+    "au",
+    "avi",
+    "bak",
+    "baml",
+    "bh",
+    "bin",
+    "bk",
+    "bmp",
+    "btif",
+    "bz2",
+    "bzip2",
+    "cab",
+    "caf",
+    "cgm",
+    "class",
+    "cmx",
+    "cpio",
+    "cr2",
+    "cr3",
+    "cur",
+    "dat",
+    "dcm",
+    "deb",
+    "dex",
+    "djvu",
+    "dll",
+    "dmg",
+    "dng",
+    "doc",
+    "docm",
+    "docx",
+    "dot",
+    "dotm",
+    "dra",
+    "DS_Store",
+    "dsk",
+    "dts",
+    "dtshd",
+    "dvb",
+    "dwg",
+    "dxf",
+    "ecelp4800",
+    "ecelp7470",
+    "ecelp9600",
+    "egg",
+    "eol",
+    "eot",
+    "epub",
+    "exe",
+    "f4v",
+    "fbs",
+    "fh",
+    "fla",
+    "flac",
+    "flatpak",
+    "fli",
+    "flv",
+    "fpx",
+    "fst",
+    "fvt",
+    "g3",
+    "gh",
+    "gif",
+    "graffle",
+    "gz",
+    "gzip",
+    "h261",
+    "h263",
+    "h264",
+    "icns",
+    "ico",
+    "ief",
+    "img",
+    "ipa",
+    "iso",
+    "jar",
+    "jpeg",
+    "jpg",
+    "jpgv",
+    "jpm",
+    "jxr",
+    "key",
+    "ktx",
+    "lha",
+    "lib",
+    "lvp",
+    "lz",
+    "lzh",
+    "lzma",
+    "lzo",
+    "m3u",
+    "m4a",
+    "m4v",
+    "mar",
+    "mdi",
+    "mht",
+    "mid",
+    "midi",
+    "mj2",
+    "mka",
+    "mkv",
+    "mmr",
+    "mng",
+    "mobi",
+    "mov",
+    "movie",
+    "mp3",
+    "mp4",
+    "mp4a",
+    "mpeg",
+    "mpg",
+    "mpga",
+    "mxu",
+    "nef",
+    "npx",
+    "numbers",
+    "nupkg",
+    "o",
+    "odp",
+    "ods",
+    "odt",
+    "oga",
+    "ogg",
+    "ogv",
+    "otf",
+    "ott",
+    "pages",
+    "pbm",
+    "pcx",
+    "pdb",
+    "pdf",
+    "pea",
+    "pgm",
+    "pic",
+    "png",
+    "pnm",
+    "pot",
+    "potm",
+    "potx",
+    "ppa",
+    "ppam",
+    "ppm",
+    "pps",
+    "ppsm",
+    "ppsx",
+    "ppt",
+    "pptm",
+    "pptx",
+    "psd",
+    "pya",
+    "pyc",
+    "pyo",
+    "pyv",
+    "qt",
+    "rar",
+    "ras",
+    "raw",
+    "resources",
+    "rgb",
+    "rip",
+    "rlc",
+    "rmf",
+    "rmvb",
+    "rpm",
+    "rtf",
+    "rz",
+    "s3m",
+    "s7z",
+    "scpt",
+    "sgi",
+    "shar",
+    "snap",
+    "sil",
+    "sketch",
+    "slk",
+    "smv",
+    "snk",
+    "so",
+    "stl",
+    "suo",
+    "sub",
+    "swf",
+    "tar",
+    "tbz",
+    "tbz2",
+    "tga",
+    "tgz",
+    "thmx",
+    "tif",
+    "tiff",
+    "tlz",
+    "ttc",
+    "ttf",
+    "txz",
+    "udf",
+    "uvh",
+    "uvi",
+    "uvm",
+    "uvp",
+    "uvs",
+    "uvu",
+    "viv",
+    "vob",
+    "war",
+    "wav",
+    "wax",
+    "wbmp",
+    "wdp",
+    "weba",
+    "webm",
+    "webp",
+    "whl",
+    "wim",
+    "wm",
+    "wma",
+    "wmv",
+    "wmx",
+    "woff",
+    "woff2",
+    "wrm",
+    "wvx",
+    "xbm",
+    "xif",
+    "xla",
+    "xlam",
+    "xls",
+    "xlsb",
+    "xlsm",
+    "xlsx",
+    "xlt",
+    "xltm",
+    "xltx",
+    "xm",
+    "xmind",
+    "xpi",
+    "xpm",
+    "xwd",
+    "xz",
+    "z",
+    "zip",
+    "zipx"
+  ];
+  return binaryExtensions$1;
+}
+var binaryExtensionsExports = /* @__PURE__ */ requireBinaryExtensions();
+const binaryExtensions = /* @__PURE__ */ getDefaultExportFromCjs(binaryExtensionsExports);
+new Set(binaryExtensions);
+const toPath = (urlOrPath) => normalizeWindowsPath(urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath);
+
+const __cjs_require$3 = createRequire(import.meta.url);
+const __cjs_getProcess$3 = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+const __cjs_getBuiltinModule$3 = (module) => {
+  if (typeof __cjs_getProcess$3 !== "undefined" && __cjs_getProcess$3.versions && __cjs_getProcess$3.versions.node) {
+    const [major, minor] = __cjs_getProcess$3.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess$3.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require$3(module);
+};
+const {
+  access
+} = __cjs_getBuiltinModule$3("node:fs/promises");
+async function isAccessible(path, mode = F_OK) {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  try {
+    await access(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+class PermissionError extends Error {
+  /**
+   * Creates a new instance.
+   * @param message
+   */
+  constructor(message) {
+    super(`EPERM: Operation not permitted, ${message}`);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  get code() {
+    return "EPERM";
+  }
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/explicit-module-boundary-types
+  set code(_name) {
+    throw new Error("Cannot overwrite code EPERM");
+  }
+  // eslint-disable-next-line class-methods-use-this
+  get name() {
+    return "PermissionError";
+  }
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/explicit-module-boundary-types
+  set name(_name) {
+    throw new Error("Cannot overwrite name of PermissionError");
+  }
+}
+
+const __cjs_require$2 = createRequire(import.meta.url);
+const __cjs_getProcess$2 = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+const __cjs_getBuiltinModule$2 = (module) => {
+  if (typeof __cjs_getProcess$2 !== "undefined" && __cjs_getProcess$2.versions && __cjs_getProcess$2.versions.node) {
+    const [major, minor] = __cjs_getProcess$2.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess$2.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require$2(module);
+};
+const {
+  readFile: readFile$1
+} = __cjs_getBuiltinModule$2("node:fs/promises");
+const {
+  unzip,
+  brotliDecompress
+} = __cjs_getBuiltinModule$2("node:zlib");
+const decompressionMethods = {
+  brotli: brotliDecompress,
+  gzip: unzip,
+  none: (buffer, callback) => {
+    callback(null, buffer);
+  }
+};
+const readFile = async (path, options) => {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  if (!await isAccessible(path)) {
+    throw new PermissionError(`unable to read the non-accessible file: ${path}`);
+  }
+  if (!await isAccessible(path, R_OK)) {
+    throw new Error(`Unable to read the non-readable file: ${path}`);
+  }
+  const { buffer, compression, encoding, flag } = options ?? {};
+  return await readFile$1(path, flag ? { encoding, flag } : { encoding }).then(
+    async (content) => await new Promise((resolve, reject) => {
+      decompressionMethods[compression ?? "none"](content, (error, result) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(buffer ? result : result.toString());
+        }
+      });
+    })
+  ).catch((error) => {
+    throw error;
+  });
+};
+
+const __cjs_require$1 = createRequire(import.meta.url);
+const __cjs_getProcess$1 = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+const __cjs_getBuiltinModule$1 = (module) => {
+  if (typeof __cjs_getProcess$1 !== "undefined" && __cjs_getProcess$1.versions && __cjs_getProcess$1.versions.node) {
+    const [major, minor] = __cjs_getProcess$1.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess$1.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require$1(module);
+};
+const {
+  unlink: unlink$1,
+  rm
+} = __cjs_getBuiltinModule$1("node:fs/promises");
+const remove = async (path, options = {}) => {
+  assertValidFileOrDirectoryPath(path);
+  try {
+    await unlink$1(path);
+  } catch {
+  }
+  try {
+    await rm(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+  } catch {
+  }
+};
+
+const assertValidFileContents = (contents) => {
+  if (typeof contents !== "string" && !(contents instanceof ArrayBuffer) && !ArrayBuffer.isView(contents)) {
+    throw new TypeError("File contents must be a string, ArrayBuffer, or ArrayBuffer view.");
+  }
+};
+
+const encoder = new TextEncoder();
+const toUint8Array = (contents) => {
+  if (contents instanceof Uint8Array) {
+    return contents;
+  }
+  if (typeof contents === "string") {
+    return encoder.encode(contents);
+  }
+  if (contents instanceof ArrayBuffer) {
+    return new Uint8Array(contents);
+  }
+  if (ArrayBuffer.isView(contents)) {
+    const bytes = contents.buffer.slice(contents.byteOffset, contents.byteOffset + contents.byteLength);
+    return new Uint8Array(bytes);
+  }
+  throw new TypeError("Invalid contents type. Expected string or ArrayBuffer.");
+};
+
+const __cjs_require = createRequire(import.meta.url);
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+const __cjs_getBuiltinModule = (module) => {
+  if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+    const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require(module);
+};
+const {
+  mkdir,
+  writeFile: writeFile$1,
+  stat,
+  rename,
+  chown,
+  chmod,
+  unlink
+} = __cjs_getBuiltinModule("node:fs/promises");
+const writeFile = async (path, content, options) => {
+  options = {
+    encoding: "utf8",
+    flag: "w",
+    overwrite: true,
+    recursive: true,
+    ...options
+  };
+  assertValidFileOrDirectoryPath(path);
+  assertValidFileContents(content);
+  path = toPath(path);
+  const temporaryPath = `${path}.tmp`;
+  try {
+    const pathExists = await isAccessible(path, F_OK);
+    if (!pathExists && options.recursive) {
+      const directory = dirname(path);
+      if (!await isAccessible(directory, F_OK)) {
+        await mkdir(directory, { recursive: true });
+      }
+    }
+    let stat$1;
+    await writeFile$1(temporaryPath, toUint8Array(content), { encoding: options.encoding, flag: options.flag });
+    if (pathExists && !options.overwrite) {
+      stat$1 = await stat(path);
+      if (options.chown === void 0) {
+        options.chown = { gid: stat$1.gid, uid: stat$1.uid };
+      }
+      await rename(path, `${path}.bak`);
+    }
+    if (options.chown) {
+      try {
+        await chown(temporaryPath, options.chown.uid, options.chown.gid);
+      } catch {
+      }
+    }
+    await chmod(temporaryPath, stat$1 && !options.mode ? stat$1.mode : options.mode ?? 438);
+    await rename(temporaryPath, path);
+  } catch (error) {
+    throw new Error(`Failed to write file at: ${path} - ${error.message}`, { cause: error });
+  } finally {
+    if (await isAccessible(temporaryPath)) {
+      await unlink(`${path}.tmp`);
+    }
+  }
+};
+
+class LocalMetaStorage extends MetaStorage {
+  directory;
+  constructor(config) {
+    super(config);
+    this.directory = normalize(config?.directory || join(tmpdir(), "Upload_meta"));
+    this.accessCheck().catch((error) => {
+      this.logger?.error("Metadata storage access check failed: %O", error);
+    });
+  }
+  /**
+   * Returns metafile path.
+   * @param id upload id
+   */
+  getMetaPath = (id) => normalize(`${this.directory}/${this.prefix}${id}${this.suffix}`);
+  /**
+   * Returns upload id from metafile path.
+   * @internal
+   */
+  getIdFromPath = (metaFilePath) => metaFilePath.slice(`${this.directory}/${this.prefix}`.length, -this.suffix.length);
+  async save(id, file) {
+    await this.accessCheck();
+    const transformedMetadata = { ...file };
+    if (transformedMetadata.metadata) {
+      transformedMetadata.metadata = stringifyMetadata(file.metadata);
+    }
+    await writeFile(this.getMetaPath(id), JSON.stringify(transformedMetadata), {
+      recursive: true
+    });
+    return file;
+  }
+  async touch(id, file) {
+    const time = /* @__PURE__ */ new Date();
+    await utimes(this.getMetaPath(id), time, time);
+    return file;
+  }
+  async get(id) {
+    try {
+      const json = await readFile(this.getMetaPath(id));
+      if (json === void 0) {
+        throw throwErrorCode(ERRORS.FILE_NOT_FOUND);
+      }
+      const file = JSON.parse(json);
+      if (file.metadata && typeof file.metadata === "string") {
+        file.metadata = parseMetadata(file.metadata);
+      }
+      return file;
+    } catch (error) {
+      const errorWithCode = error;
+      const isSyntaxError = error instanceof SyntaxError;
+      if (errorWithCode.code === "ENOENT" || isSyntaxError) {
+        throw throwErrorCode(ERRORS.FILE_NOT_FOUND);
+      }
+      if (error instanceof Error && "UploadErrorCode" in error) {
+        throw error;
+      }
+      throw error;
+    }
+  }
+  async delete(id) {
+    await remove(this.getMetaPath(id));
+  }
+  async accessCheck() {
+    await ensureDir(this.directory);
+  }
+}
+
+export { LocalMetaStorage as L, assertValidFileOrDirectoryPath as a, readFile as b, ensureDir as e, getFileInfoType as g, isAccessible as i, remove as r, toPath as t };

package/dist/packem_shared/minio-C2YBZQOw.js

@@ -0,0 +1,22 @@
+const minio = (parameters) => {
+  const { accessKeyId, endpoint, region, secretAccessKey } = parameters ?? {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID || process.env.MINIO_ACCESS_KEY_ID || process.env.MINIO_ACCESS_KEY,
+    endpoint: process.env.AWS_ENDPOINT || process.env.MINIO_ENDPOINT,
+    region: process.env.AWS_REGION || process.env.MINIO_REGION,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || process.env.MINIO_SECRET_ACCESS_KEY || process.env.MINIO_SECRET_KEY
+  };
+  if (!region || !accessKeyId || !secretAccessKey || !endpoint) {
+    throw new Error("Missing required parameters for Minio client.");
+  }
+  return {
+    credentials: {
+      accessKeyId,
+      secretAccessKey
+    },
+    endpoint,
+    forcePathStyle: true,
+    region
+  };
+};
+
+export { minio as default };