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

package/dist/packem_shared/DiskStorageWithChecksum-B_XY8_cO.js

@@ -0,0 +1,240 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { truncate } from 'node:fs/promises';
+import { Transform, pipeline } from 'node:stream';
+import { p as partMatch, d as detectFileTypeFromStream, g as getFileStatus } from './part-match-BMNqHDYD.js';
+import { throwErrorCode, ERRORS } from './ERRORS-D0apMqnc.js';
+import { D as DiskStorage, e as ensureFile, S as StreamLength, s as streamChecksum } from './disk-storage-DeivH-J5.js';
+import { LRUCache } from 'lru-cache';
+import { createHash } from 'node:crypto';
+import { r as remove } from './local-meta-storage-BlOk6m7F.js';
+import { u as updateSize } from './update-size-CCGm6i1J.js';
+import { h as hasContent } from './has-content-CY66ehMK.js';
+
+class RangeChecksum extends Transform {
+  /**
+   * Creates a new RangeChecksum transform stream.
+   * @param hashes Range hasher instance managing multiple file hashes
+   * @param path File path identifier for this checksum operation
+   */
+  constructor(hashes, path) {
+    super();
+    this.path = path;
+    this.hashes = hashes;
+    this.hash = this.hashes.get(path) || createHash(this.hashes.algorithm);
+    this.hashCopy = this.hash.copy();
+  }
+  path;
+  hash;
+  hashCopy;
+  hashes;
+  /**
+   * Resets the hash state to its initial value.
+   * Useful for reusing the checksum calculator for multiple operations.
+   */
+  reset() {
+    this.hashes.set(this.path, this.hashCopy);
+  }
+  /**
+   * Returns the current hash digest in the specified encoding.
+   * @param encoding Output encoding format (default: 'hex')
+   * @returns Hash digest as a string
+   */
+  digest(encoding = "hex") {
+    return this.hash.copy().digest(encoding);
+  }
+  // eslint-disable-next-line no-underscore-dangle
+  _transform(chunk, _encoding, done) {
+    this.push(chunk);
+    this.hash.update(chunk);
+    done();
+  }
+  // eslint-disable-next-line class-methods-use-this,no-underscore-dangle
+  _flush(callback) {
+    callback();
+  }
+}
+
+class RangeHasher extends LRUCache {
+  /**
+   * Creates a new RangeHasher instance.
+   * @param algorithm Hash algorithm to use (default: 'sha1')
+   * @param options LRU cache configuration options
+   */
+  constructor(algorithm = "sha1", options) {
+    super({
+      ttl: 1e3,
+      ttlAutopurge: true,
+      ...options
+    });
+    this.algorithm = algorithm;
+  }
+  algorithm;
+  /**
+   * Returns the hex-encoded digest for a previously initialized path.
+   * @param path File path identifier
+   * @returns Hex-encoded hash digest, or empty string if not found
+   */
+  hex(path) {
+    return this.get(path)?.copy().digest("hex") || "";
+  }
+  /**
+   * Returns the base64-encoded digest for a previously initialized path.
+   * @param path File path identifier
+   * @returns Base64-encoded hash digest, or empty string if not found
+   */
+  base64(path) {
+    return this.get(path)?.copy().digest("base64") || "";
+  }
+  /**
+   * Initializes or continues a hasher for a file from the specified offset.
+   * Returns cached hash if available, otherwise calculates from filesystem.
+   * @param path File path to hash
+   * @param start Starting offset in bytes (default: 0)
+   * @returns Promise resolving to the hash instance
+   */
+  async init(path, start = 0) {
+    return this.get(path)?.copy() || this.updateFromFs(path, start);
+  }
+  /**
+   * Creates a transform stream that updates the rolling hash for a file path.
+   * Useful for incremental hashing during streaming operations.
+   * @param path File path identifier for hash tracking
+   * @returns RangeChecksum transform stream instance
+   */
+  digester(path) {
+    return new RangeChecksum(this, path);
+  }
+  async updateFromFs(path, start = 0, initial) {
+    const hash = await this.fromFs(path, start, initial);
+    this.set(path, hash);
+    return hash;
+  }
+  fromFs(path, start = 0, initial) {
+    return new Promise((resolve, reject) => {
+      const digester = this.digester(path);
+      if (initial !== void 0) {
+        digester.hash = initial;
+      }
+      createReadStream(path, { start }).on("error", reject).on("end", () => resolve(digester.hash)).pipe(digester).resume();
+    });
+  }
+}
+
+class DiskStorageWithChecksum extends DiskStorage {
+  hashes;
+  constructor(config) {
+    super(config);
+    this.hashes = new RangeHasher(config?.checksum === "sha1" ? "sha1" : "md5");
+  }
+  async delete({ id }) {
+    try {
+      const file = await this.getMeta(id);
+      const path = this.getFilePath(file.name);
+      this.hashes.delete(path);
+      await remove(path);
+      await this.deleteMeta(id);
+      const deletedFile = { ...file, status: "deleted" };
+      await this.onDelete(deletedFile);
+      return deletedFile;
+    } catch (error) {
+      this.logger?.error("[error]: Could not delete file: %O", error);
+      const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
+      await this.onError(httpError);
+    }
+    return { id };
+  }
+  async write(part) {
+    let file;
+    if ("contentType" in part && "metadata" in part && !("body" in part) && !("start" in part)) {
+      file = part;
+    } else {
+      file = await this.getMeta(part.id);
+      await this.checkIfExpired(file);
+    }
+    if (file.status === "completed") {
+      return file;
+    }
+    if (part.size !== void 0) {
+      updateSize(file, part.size);
+    }
+    if (!partMatch(part, file)) {
+      return throwErrorCode(ERRORS.FILE_CONFLICT);
+    }
+    const path = this.getFilePath(file.name);
+    try {
+      const startPosition = part.start || 0;
+      await ensureFile(path);
+      if (file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) {
+        file.bytesWritten = startPosition;
+      }
+      await this.hashes.init(path);
+      if (hasContent(part)) {
+        if (this.isUnsupportedChecksum(part.checksumAlgorithm)) {
+          return throwErrorCode(ERRORS.UNSUPPORTED_CHECKSUM_ALGORITHM);
+        }
+        const isFirstChunk = part.start === 0 || part.start === void 0;
+        if (isFirstChunk && (file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) && (!file.contentType || file.contentType === "application/octet-stream")) {
+          try {
+            const { fileType, stream: detectedStream } = await detectFileTypeFromStream(part.body);
+            if (fileType?.mime) {
+              file.contentType = fileType.mime;
+            }
+            part.body = detectedStream;
+          } catch {
+          }
+        }
+        const [bytesWritten, errorCode] = await this.lazyWrite({ ...part, ...file });
+        if (errorCode) {
+          await truncate(path, file.bytesWritten);
+          return throwErrorCode(errorCode);
+        }
+        if (typeof bytesWritten !== "number") {
+          await this.hashes.updateFromFs(path, file.bytesWritten);
+        }
+        file.bytesWritten = bytesWritten;
+      }
+      file.status = getFileStatus(file);
+      file.hash = {
+        algorithm: this.hashes.algorithm,
+        value: this.hashes.hex(path)
+      };
+      if (file.status === "completed") {
+        this.hashes.delete(path);
+      }
+      await this.saveMeta(file);
+      return file;
+    } catch (error) {
+      await this.hashes.updateFromFs(path, file.bytesWritten);
+      const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
+      await this.onError(httpError);
+      return throwErrorCode(ERRORS.FILE_ERROR, (typeof httpError.message === "string" ? httpError.message : String(error)) || String(error));
+    }
+  }
+  lazyWrite(part) {
+    return new Promise((resolve, reject) => {
+      const path = this.getFilePath(part.name);
+      const destination = createWriteStream(path, { flags: "r+", start: part.start });
+      const lengthChecker = new StreamLength(part.contentLength || Number(part.size) - part.start);
+      const checksumChecker = streamChecksum(part.checksum, part.checksumAlgorithm);
+      const digester = this.hashes.digester(path);
+      const keepPartial = !part.checksum;
+      const failWithCode = (code) => {
+        digester.reset();
+        destination.close();
+        resolve([Number.NaN, code]);
+      };
+      lengthChecker.on("error", () => failWithCode(ERRORS.FILE_CONFLICT));
+      checksumChecker.on("error", () => failWithCode(ERRORS.CHECKSUM_MISMATCH));
+      part.body.on("aborted", () => failWithCode(keepPartial ? void 0 : ERRORS.REQUEST_ABORTED));
+      pipeline(part.body, lengthChecker, checksumChecker, digester, destination, (error) => {
+        if (error) {
+          digester.reset();
+          return reject(error);
+        }
+        return resolve([part.start + destination.bytesWritten]);
+      });
+    });
+  }
+}
+
+export { DiskStorageWithChecksum as default };

package/dist/packem_shared/ERRORS-D0apMqnc.js

@@ -0,0 +1,97 @@
+var ERRORS = /* @__PURE__ */ ((ERRORS2) => {
+  ERRORS2["BAD_REQUEST"] = "BadRequest";
+  ERRORS2["CHECKSUM_MISMATCH"] = "ChecksumMismatch";
+  ERRORS2["FILE_CONFLICT"] = "FileConflict";
+  ERRORS2["FILE_ERROR"] = "FileError";
+  ERRORS2["FILE_LOCKED"] = "FileLocked";
+  ERRORS2["FILE_NOT_ALLOWED"] = "FileNotAllowed";
+  ERRORS2["FILE_NOT_FOUND"] = "FileNotFound";
+  ERRORS2["FORBIDDEN"] = "Forbidden";
+  ERRORS2["GONE"] = "Gone";
+  ERRORS2["INVALID_FILE_NAME"] = "InvalidFileName";
+  ERRORS2["INVALID_FILE_SIZE"] = "InvalidFileSize";
+  ERRORS2["INVALID_RANGE"] = "InvalidRange";
+  ERRORS2["INVALID_TYPE"] = "Invalidtype";
+  ERRORS2["METHOD_NOT_ALLOWED"] = "MethodNotAllowed";
+  ERRORS2["REQUEST_ABORTED"] = "RequestAborted";
+  ERRORS2["REQUEST_ENTITY_TOO_LARGE"] = "RequestEntityTooLarge";
+  ERRORS2["STORAGE_BUSY"] = "StorageBusy";
+  ERRORS2["STORAGE_ERROR"] = "StorageError";
+  ERRORS2["TOO_MANY_REQUESTS"] = "TooManyRequests";
+  ERRORS2["UNKNOWN_ERROR"] = "UnknownError";
+  ERRORS2["UNPROCESSABLE_ENTITY"] = "UnprocessableEntity";
+  ERRORS2["UNSUPPORTED_CHECKSUM_ALGORITHM"] = "UnsupportedChecksumAlgorithm";
+  ERRORS2["UNSUPPORTED_MEDIA_TYPE"] = "UnsupportedMediaType";
+  return ERRORS2;
+})(ERRORS || {});
+const ErrorMap = (() => {
+  const errors = {
+    BadRequest: [400, "Bad request"],
+    ChecksumMismatch: [460, "Checksum mismatch"],
+    FileConflict: [409, "File conflict"],
+    FileError: [500, "Something went wrong writing the file"],
+    FileLocked: [423, "File locked"],
+    FileNotAllowed: [403, "File not allowed"],
+    FileNotFound: [404, "Not found"],
+    Forbidden: [403, "Authenticated user is not allowed access"],
+    Gone: [410, "The file for this url no longer exists"],
+    InvalidFileName: [400, "Invalid file name or it cannot be retrieved"],
+    InvalidFileSize: [400, "File size cannot be retrieved"],
+    InvalidRange: [400, "Invalid or missing content-range header"],
+    Invalidtype: [400, 'Invalid or missing "content-type" header'],
+    MethodNotAllowed: [405, "Method not allowed"],
+    RequestAborted: [499, "Request aborted"],
+    RequestEntityTooLarge: [413, "Request entity too large"],
+    StorageBusy: [503, "Storage is busy"],
+    StorageError: [503, "Storage error"],
+    TooManyRequests: [429, "Too many requests"],
+    UnknownError: [500, "Something went wrong"],
+    UnprocessableEntity: [422, "Validation failed"],
+    UnsupportedChecksumAlgorithm: [400, "Unsupported checksum algorithm"],
+    UnsupportedMediaType: [415, "Unsupported media type"]
+  };
+  const errorMap = {};
+  Object.keys(errors).forEach((code) => {
+    const [statusCode, message] = errors[code];
+    errorMap[code] = { code, message, statusCode };
+  });
+  return errorMap;
+})();
+class UploadError extends Error {
+  name = "UploadError";
+  /** The standardized error code from the ERRORS enum */
+  UploadErrorCode = "UnknownError" /* UNKNOWN_ERROR */;
+  /** Optional additional error details */
+  detail;
+  /**
+   * Creates a new UploadError instance.
+   * @param code Standardized error code (defaults to UNKNOWN_ERROR)
+   * @param message Human-readable error message (defaults to the code)
+   * @param detail Optional additional error details
+   */
+  constructor(code = "UnknownError" /* UNKNOWN_ERROR */, message, detail) {
+    super(message || code);
+    this.name = "UploadError";
+    this.detail = detail;
+    if (Object.values(ERRORS).includes(code)) {
+      this.UploadErrorCode = code;
+    }
+  }
+}
+const isUploadError = (error) => !!error.UploadErrorCode;
+const throwErrorCode = (UploadErrorCode, detail) => {
+  const errorCode = UploadErrorCode;
+  let errorResponse;
+  if (errorCode && typeof errorCode === "string" && errorCode in ErrorMap) {
+    errorResponse = ErrorMap[errorCode];
+  }
+  const message = detail || (errorResponse?.body && typeof errorResponse.body === "object" && "message" in errorResponse.body ? errorResponse.body.message : void 0) || errorResponse?.message || "UnknownError" /* UNKNOWN_ERROR */;
+  const error = new UploadError(errorCode, message);
+  error.UploadErrorCode = errorCode;
+  if (typeof detail === "string") {
+    error.detail = detail;
+  }
+  throw error;
+};
+
+export { ERRORS, ErrorMap, UploadError, isUploadError, throwErrorCode };

package/dist/packem_shared/File-Bb3P23dr.js

@@ -0,0 +1,69 @@
+import fnv1a from '@sindresorhus/fnv1a';
+import { nanoid } from 'nanoid';
+
+const hash = (value) => fnv1a(value, { size: 64 }).toString(16);
+const extractMimeType = (meta) => {
+  if (typeof meta.mimeType === "string") {
+    return meta.mimeType;
+  }
+  if (typeof meta.type === "string") {
+    return meta.type;
+  }
+  if (typeof meta.filetype === "string") {
+    return meta.filetype;
+  }
+  return void 0;
+};
+const extractOriginalName = (meta) => {
+  if (typeof meta.name === "string") {
+    return meta.name;
+  }
+  if (typeof meta.title === "string") {
+    return meta.title;
+  }
+  if (typeof meta.originalName === "string") {
+    return meta.originalName;
+  }
+  if (typeof meta.filename === "string") {
+    return meta.filename;
+  }
+  return void 0;
+};
+const generateFileId = (file) => {
+  const { metadata, originalName, size } = file;
+  const mtime = String(metadata.lastModified ?? Date.now());
+  return [originalName, size, mtime].filter(Boolean).map(String).map((value) => hash(value)).join("-");
+};
+class File {
+  bytesWritten = Number.NaN;
+  contentType;
+  originalName;
+  id;
+  metadata;
+  name = "";
+  size;
+  status;
+  expiredAt;
+  createdAt;
+  modifiedAt;
+  hash;
+  content;
+  ETag;
+  constructor({ contentType, expiredAt, metadata = {}, originalName, size }) {
+    this.metadata = metadata;
+    this.originalName = originalName || extractOriginalName(metadata) || (this.id = nanoid());
+    this.contentType = contentType || extractMimeType(metadata) || "application/octet-stream";
+    this.expiredAt = expiredAt;
+    if (typeof size === "string" || typeof size === "number") {
+      this.size = Number(size);
+    } else if (typeof metadata.size === "string" || typeof metadata.size === "number") {
+      this.size = Number(metadata.size);
+    }
+    if (typeof this.size === "number" && this.size <= 0) {
+      this.size = void 0;
+    }
+    this.id ||= generateFileId(this);
+  }
+}
+
+export { File as default };

package/dist/packem_shared/GCSConfig-vPP22kN6.js

@@ -0,0 +1,11 @@
+const GCSConfig = {
+  authScopes: [
+    "https://www.googleapis.com/auth/iam",
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/devstorage.full_control"
+  ],
+  storageAPI: "https://storage.googleapis.com/storage/v1/b",
+  uploadAPI: "https://storage.googleapis.com/upload/storage/v1/b"
+};
+
+export { GCSConfig as default };

package/dist/packem_shared/GCSFile-BIEunhAN.js

@@ -0,0 +1,8 @@
+import File from './File-Bb3P23dr.js';
+
+class GCSFile extends File {
+  GCSUploadURI;
+  uri;
+}
+
+export { GCSFile as default };

package/dist/packem_shared/GCSMetaStorage-FypK8Tn1.js

@@ -0,0 +1,7 @@
+import 'node:crypto';
+import 'gaxios';
+import 'google-auth-library';
+export { G as default } from './gcs-meta-storage-B0Baj0Xr.js';
+import './MetaStorage-pECeFOad.js';
+import './Metadata-DRLXeJ0F.js';
+import './GCSConfig-vPP22kN6.js';