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

package/dist/packem_shared/multipart-base-B3i67SSX.js

@@ -0,0 +1,102 @@
+import { c as createHttpError } from './headers-DoS5nwM-.js';
+
+class MultipartBase {
+  /**
+   * Handle multipart POST (upload file).
+   * @param filePart File part from multipart parser
+   * @param filePart.bytes File bytes data
+   * @param filePart.filename Original filename
+   * @param filePart.mediaType Content type
+   * @param filePart.size File size in bytes
+   * @param metadataParts All parts from multipart parser (for extracting metadata)
+   * @param requestUrl Request URL for Location header
+   * @returns Promise resolving to ResponseFile with upload result
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async handlePost(filePart, metadataParts, requestUrl) {
+    const config = {
+      contentType: filePart.mediaType || "application/octet-stream",
+      metadata: {},
+      originalName: filePart.filename,
+      size: filePart.size
+    };
+    for (const part of metadataParts) {
+      if (!part.isFile && part.name) {
+        let data = {};
+        if (part.name === "metadata" && part.text) {
+          try {
+            data = JSON.parse(part.text);
+          } catch {
+          }
+        } else if (part.name) {
+          data = { [part.name]: part.text };
+        }
+        Object.assign(config.metadata, data);
+      }
+    }
+    const file = await this.storage.create(config);
+    const stream = this.createStreamFromBytes(filePart.bytes);
+    await this.storage.write({
+      body: stream,
+      contentLength: filePart.size,
+      id: file.id,
+      start: 0
+    });
+    const completedFile = await this.storage.write({
+      body: this.createEmptyStream(),
+      contentLength: 0,
+      id: file.id,
+      start: filePart.size
+    });
+    let finalFile = completedFile;
+    if (Object.keys(config.metadata).length > 0) {
+      const mergedMetadata = {
+        ...completedFile.metadata,
+        ...config.metadata
+      };
+      const updatedFile = await this.storage.update({ id: completedFile.id }, { metadata: mergedMetadata });
+      finalFile = { ...updatedFile, status: completedFile.status };
+    }
+    const locationUrl = this.buildFileUrl(requestUrl, finalFile);
+    return {
+      ...finalFile,
+      headers: {
+        Location: locationUrl,
+        ...finalFile.expiredAt === void 0 ? {} : { "X-Upload-Expires": finalFile.expiredAt.toString() },
+        ...finalFile.ETag === void 0 ? {} : { ETag: finalFile.ETag }
+      },
+      statusCode: 200
+    };
+  }
+  /**
+   * Handle DELETE (delete file).
+   * @param id File ID from URL
+   * @returns Promise resolving to ResponseFile with deletion result
+   */
+  async handleDelete(id) {
+    const file = await this.storage.delete({ id });
+    if (file.status === void 0) {
+      throw createHttpError(404, "File not found");
+    }
+    return { ...file, headers: {}, statusCode: 204 };
+  }
+  /**
+   * Storage instance for file operations.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  get storage() {
+    throw new Error("storage must be implemented");
+  }
+  /**
+   * Build file URL from request URL and file data.
+   * @param _requestUrl Request URL string
+   * @param _file File object containing ID and content type
+   * @returns Constructed file URL with extension based on content type
+   */
+  // eslint-disable-next-line class-methods-use-this
+  buildFileUrl(_requestUrl, _file) {
+    throw new Error("buildFileUrl must be implemented");
+  }
+}
+
+export { MultipartBase as M };

package/dist/packem_shared/part-match-BMNqHDYD.js

@@ -0,0 +1,96 @@
+import { PassThrough, Transform } from 'node:stream';
+import { fileTypeFromBuffer } from 'file-type';
+
+const detectFileTypeFromBuffer = async (buffer) => {
+  try {
+    return await fileTypeFromBuffer(buffer);
+  } catch {
+    return void 0;
+  }
+};
+const detectFileTypeFromStream = async (stream, options) => {
+  const sampleSize = 4100;
+  let fileType;
+  const chunks = [];
+  let totalLength = 0;
+  let detectionStarted = false;
+  let detectionPromise;
+  const outputStream = new PassThrough({ highWaterMark: 0 });
+  const peekStream = new Transform({
+    objectMode: false,
+    transform(chunk, _encoding, callback) {
+      if (!detectionStarted) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+        if (totalLength >= sampleSize || totalLength > 0) {
+          detectionStarted = true;
+          const buffer = Buffer.concat(chunks);
+          detectionPromise = fileTypeFromBuffer(buffer).then((detected) => {
+            fileType = detected;
+            return detected;
+          }).catch(() => void 0);
+        }
+      }
+      callback(void 0, chunk);
+    }
+  });
+  stream.pipe(peekStream).pipe(outputStream);
+  stream.on("error", (error) => {
+    peekStream.destroy(error);
+    outputStream.destroy(error);
+  });
+  peekStream.on("error", (error) => {
+    if (!outputStream.destroyed) {
+      outputStream.destroy(error);
+    }
+  });
+  await Promise.race([
+    new Promise((resolve) => {
+      if (detectionStarted) {
+        resolve();
+        return;
+      }
+      const timeout = setTimeout(() => resolve(), 10);
+      peekStream.once("data", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      peekStream.once("end", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    }),
+    new Promise((resolve) => {
+      setTimeout(() => resolve(), 10);
+    })
+  ]);
+  if (detectionPromise) {
+    await Promise.race([
+      detectionPromise.then(() => void 0),
+      new Promise((resolve) => {
+        setTimeout(() => resolve(), 150);
+      })
+    ]).catch(() => {
+    });
+  }
+  return { fileType, stream: outputStream };
+};
+
+const getFileStatus = (file) => {
+  if (file.bytesWritten === file.size) {
+    return "completed";
+  }
+  return file.createdAt ? "part" : "created";
+};
+
+const partMatch = (part, file) => {
+  if (part.size !== void 0 && file.size !== void 0 && part.size > 0 && file.size > 0 && part.size > file.size) {
+    return false;
+  }
+  if (file.size === void 0) {
+    return true;
+  }
+  return (part.start || 0) + (part.contentLength || 0) <= file.size;
+};
+
+export { detectFileTypeFromBuffer as a, detectFileTypeFromStream as d, getFileStatus as g, partMatch as p };

package/dist/packem_shared/path-CR6YkPXX-7R1-9CMk.js

@@ -0,0 +1,161 @@
+const DRIVE_LETTER_START_RE = /^[A-Z]:\//i;
+const normalizeWindowsPath = (input = "") => {
+  if (!input) {
+    return input;
+  }
+  return input.replaceAll("\\", "/").replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+};
+const UNC_REGEX = /^[/\\]{2}/;
+const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+const DRIVE_LETTER_RE = /^[A-Z]:$/i;
+const cwd = () => {
+  if (typeof process.cwd === "function") {
+    return process.cwd().replaceAll("\\", "/");
+  }
+  return "/";
+};
+const normalizeString = (path2, allowAboveRoot) => {
+  let result = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char;
+  for (let index = 0; index <= path2.length; ++index) {
+    if (index < path2.length) {
+      char = path2[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (result.length < 2 || lastSegmentLength !== 2 || !result.endsWith(".") || result.at(-2) !== ".") {
+          if (result.length > 2) {
+            const lastSlashIndex = result.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              result = "";
+              lastSegmentLength = 0;
+            } else {
+              result = result.slice(0, lastSlashIndex);
+              lastSegmentLength = result.length - 1 - result.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (result.length > 0) {
+            result = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          result += result.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (result.length > 0) {
+          result += `/${path2.slice(lastSlash + 1, index)}`;
+        } else {
+          result = path2.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return result;
+};
+const isAbsolute = (path2) => IS_ABSOLUTE_RE.test(path2);
+const normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = UNC_REGEX.exec(path2);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2.at(-1) === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (DRIVE_LETTER_RE.test(path2)) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+const join = (...segments) => {
+  let path2 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path2.length > 0) {
+      const pathTrailing = path2[path2.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path2 += seg.slice(1);
+      } else {
+        path2 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path2 += seg;
+    }
+  }
+  return normalize(path2);
+};
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path2 = index >= 0 ? arguments_[index] : cwd();
+    if (!path2 || path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+const dirname = (path2) => {
+  const segments = normalizeWindowsPath(path2).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(path2) ? "/" : ".");
+};
+const basename = (path2, extension) => {
+  const lastSegment = normalizeWindowsPath(path2).split("/").pop();
+  if (extension && lastSegment.endsWith(extension)) {
+    return lastSegment.slice(0, -extension.length);
+  }
+  return lastSegment;
+};
+
+export { normalizeWindowsPath as a, basename as b, dirname as d, isAbsolute as i, join as j, normalize as n, resolve as r };

package/dist/packem_shared/response-builder-BtnRiBUI.js

@@ -0,0 +1,45 @@
+import 'mime';
+
+const buildResponseFile = (file, headers = {}, statusCode = 200) => ({
+  ...file,
+  headers,
+  statusCode
+});
+const buildFileHeaders = (file, locationUrl, additionalHeaders = {}) => {
+  return {
+    Location: locationUrl,
+    ...file.expiredAt === void 0 ? {} : { "X-Upload-Expires": file.expiredAt.toString() },
+    ...file.ETag === void 0 ? {} : { ETag: file.ETag },
+    ...additionalHeaders
+  };
+};
+const buildChunkedUploadHeaders = (file, isComplete) => {
+  const metadata = file.metadata || {};
+  const headers = {
+    "x-chunked-upload": "true",
+    "x-upload-complete": isComplete ? "true" : "false",
+    "x-upload-offset": String(file.bytesWritten || 0)
+  };
+  if (Array.isArray(metadata._chunks) && metadata._chunks.length > 0) {
+    headers["x-received-chunks"] = JSON.stringify(metadata._chunks);
+  }
+  return headers;
+};
+const buildFileMetadataHeaders = (file) => {
+  return {
+    "Content-Length": String(file.size || 0),
+    "Content-Type": file.contentType,
+    ...file.expiredAt === void 0 ? {} : { "X-Upload-Expires": file.expiredAt.toString() },
+    ...file.modifiedAt === void 0 ? {} : { "Last-Modified": file.modifiedAt.toString() },
+    ...file.ETag === void 0 ? {} : { ETag: file.ETag }
+  };
+};
+const convertHeadersToString = (headers) => {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    result[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return result;
+};
+
+export { buildFileHeaders as a, buildResponseFile as b, buildChunkedUploadHeaders as c, buildFileMetadataHeaders as d, convertHeadersToString as e };