@visulima/storage 1.0.0-alpha.9 → 1.0.1

package/dist/packem_shared/Tus-DaN0FmOy.js

@@ -1,195 +0,0 @@
-import { format } from 'node:url';
-import { c as createHttpError } from './headers-YLRp1dLo.js';
-import { a as getHeader, b as getRequestStream, g as getIdFromRequest, c as getBaseUrl } from './base-handler-core-BoAqTyz7.js';
-import { B as BaseHandlerNode } from './base-handler-node-DGzcHHAy.js';
-import { TusBase } from './TUS_RESUMABLE-Dtfsffnj.js';
-export { TUS_RESUMABLE, TUS_VERSION } from './TUS_RESUMABLE-Dtfsffnj.js';
-
-class Tus extends BaseHandlerNode {
-  /**
-   * Limiting enabled http method handler
-   */
-  static methods = ["delete", "download", "get", "head", "options", "patch", "post"];
-  disableTerminationForFinishedUploads = false;
-  tusBase;
-  constructor(options) {
-    super(options);
-    this.disableTerminationForFinishedUploads = options.disableTerminationForFinishedUploads ?? false;
-    const tusInstance = this;
-    this.tusBase = new class extends TusBase {
-      // eslint-disable-next-line class-methods-use-this
-      get storage() {
-        return tusInstance.storage;
-      }
-      // eslint-disable-next-line class-methods-use-this
-      get disableTerminationForFinishedUploads() {
-        return tusInstance.disableTerminationForFinishedUploads;
-      }
-      // eslint-disable-next-line class-methods-use-this
-      buildFileUrl(requestUrl, file) {
-        return tusInstance.buildFileUrlForTus(requestUrl, file);
-      }
-    }();
-  }
-  /**
-   * Handle OPTIONS requests with TUS protocol capabilities.
-   * @returns Promise resolving to ResponseFile with TUS headers
-   */
-  async options() {
-    return this.tusBase.handleOptions(Tus.methods);
-  }
-  /**
-   * Creates a new TUS upload and optionally starts uploading data.
-   * @param request Node.js IncomingMessage with TUS headers.
-   * @returns Promise resolving to ResponseFile with upload location and offset.
-   */
-  async post(request) {
-    this.tusBase.validateTusResumableHeader(getHeader(request, "tus-resumable"));
-    const uploadLength = request.headers["upload-length"];
-    const uploadDeferLength = request.headers["upload-defer-length"];
-    const uploadConcat = request.headers["upload-concat"];
-    const metadataHeader = getHeader(request, "upload-metadata", true);
-    const contentType = getHeader(request, "content-type") || "";
-    const contentLength = Number.parseInt(getHeader(request, "content-length") || "0", 10);
-    const requestUrl = request.originalUrl || request.url;
-    const bodyStream = getRequestStream(request);
-    return this.tusBase.handlePost(uploadLength, uploadDeferLength, uploadConcat, metadataHeader, requestUrl, bodyStream, contentLength, contentType);
-  }
-  /**
-   * Write a chunk of data to an existing TUS upload.
-   * @param request Node.js IncomingMessage with chunk data and TUS headers
-   * @returns Promise resolving to ResponseFile with updated offset
-   */
-  async patch(request) {
-    this.tusBase.validateTusResumableHeader(getHeader(request, "tus-resumable"));
-    try {
-      const id = getIdFromRequest(request);
-      if (request.headers["upload-offset"] === void 0) {
-        throw createHttpError(412, "Missing Upload-Offset header");
-      }
-      if (request.headers["content-type"] === void 0) {
-        throw createHttpError(412, "Content-Type header required");
-      }
-      if (request.headers["content-type"] !== "application/offset+octet-stream") {
-        throw createHttpError(415, "Unsupported Media Type");
-      }
-      const uploadOffset = Number.parseInt(getHeader(request, "upload-offset"), 10);
-      const uploadLength = request.headers["upload-length"];
-      const metadataHeader = getHeader(request, "upload-metadata", true);
-      const contentLength = Number(getHeader(request, "content-length"));
-      const checksumHeader = getHeader(request, "upload-checksum");
-      const { checksum, checksumAlgorithm } = this.tusBase.extractChecksum(checksumHeader);
-      const requestUrl = request.originalUrl || request.url;
-      const bodyStream = getRequestStream(request);
-      return this.tusBase.handlePatch(id, uploadOffset, uploadLength, metadataHeader, checksum, checksumAlgorithm, requestUrl, bodyStream, contentLength);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      const errorWithCode = error;
-      if (errorWithCode.UploadErrorCode === "GONE" || errorWithCode.UploadErrorCode === "FILE_NOT_FOUND") {
-        throw createHttpError(410, "Upload expired");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Get current upload offset and metadata for TUS resumable uploads.
-   * @param request Node.js IncomingMessage with upload ID
-   * @returns Promise resolving to ResponseFile with upload-offset and metadata headers
-   */
-  async head(request) {
-    this.tusBase.validateTusResumableHeader(getHeader(request, "tus-resumable"));
-    try {
-      const id = getIdFromRequest(request);
-      return this.tusBase.handleHead(id);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      const errorWithCode = error;
-      if (errorWithCode.UploadErrorCode === "GONE" || errorWithCode.UploadErrorCode === "FILE_NOT_FOUND") {
-        throw createHttpError(410, "Upload expired");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Get TUS upload metadata and current status.
-   * @param request Node.js IncomingMessage with upload ID
-   * @returns Promise resolving to ResponseFile with file metadata as JSON
-   */
-  async get(request) {
-    this.tusBase.validateTusResumableHeader(getHeader(request, "tus-resumable"));
-    try {
-      const id = getIdFromRequest(request);
-      return this.tusBase.handleGet(id);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      const errorWithCode = error;
-      if (errorWithCode.UploadErrorCode === "GONE") {
-        throw createHttpError(410, "Upload expired");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Delete a TUS upload and its associated data.
-   * @param request Node.js IncomingMessage with upload ID
-   * @returns Promise resolving to ResponseFile with deletion confirmation
-   */
-  async delete(request) {
-    this.tusBase.validateTusResumableHeader(getHeader(request, "tus-resumable"));
-    try {
-      const id = getIdFromRequest(request);
-      return this.tusBase.handleDelete(id);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      const errorWithCode = error;
-      if (errorWithCode.code === "ENOENT") {
-        throw createHttpError(404, "File not found");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Send TUS protocol response with required headers.
-   * @param response Node.js ServerResponse to send response to
-   * @param uploadResponse Response data with body, headers, and status code
-   */
-  send(response, { body = "", headers = {}, statusCode = 200 }) {
-    const uploadResponse = {
-      body,
-      headers: {
-        ...headers,
-        "Access-Control-Expose-Headers": "location,upload-expires,upload-offset,upload-length,upload-metadata,upload-defer-length,tus-resumable,tus-extension,tus-max-size,tus-version,tus-checksum-algorithm,cache-control",
-        "Tus-Resumable": "1.0.0"
-      },
-      statusCode: statusCode || 200
-    };
-    super.send(response, uploadResponse);
-  }
-  /**
-   * Compose and register HTTP method handlers.
-   */
-  compose() {
-    this.registeredHandlers.set("POST", this.post.bind(this));
-    this.registeredHandlers.set("PATCH", this.patch.bind(this));
-    this.registeredHandlers.set("HEAD", this.head.bind(this));
-    this.registeredHandlers.set("GET", this.get.bind(this));
-    this.registeredHandlers.set("DELETE", this.delete.bind(this));
-    this.registeredHandlers.set("OPTIONS", this.options.bind(this));
-    this.logger?.debug("Registered handler: %s", [...this.registeredHandlers.keys()].join(", "));
-  }
-  /**
-   * Build file URL for TUS uploads (without file extension).
-   * @param requestUrl Request URL string
-   * @param file File object containing ID
-   * @returns Constructed file URL for TUS protocol
-   */
-  buildFileUrlForTus(requestUrl, file) {
-    const url = new URL(requestUrl, "http://localhost");
-    const { pathname } = url;
-    const query = Object.fromEntries(url.searchParams.entries());
-    const relative = format({ pathname: `${pathname}/${file.id}`, query });
-    return `${this.storage.config.useRelativeLocation ? relative : getBaseUrl({ }) + relative}`;
-  }
-}
-
-export { Tus };

package/dist/packem_shared/ValidationError-BfF1aE4h.js

@@ -1,26 +0,0 @@
-class ValidationError extends Error {
-  code;
-  details;
-  /**
-   * Creates a new ValidationError instance with detailed error information.
-   * @param message Human-readable error message describing the validation failure
-   * @param code Machine-readable error code for programmatic error handling
-   * @param mediaType The media type where validation failed ('image', 'video', or 'audio')
-   * @param invalidParameters Array of parameter names that were invalid
-   * @param validParameters Array of valid parameter names or values
-   * @param suggestions Optional array of suggested corrections or valid values
-   */
-  constructor(message, code, mediaType, invalidParameters, validParameters, suggestions) {
-    super(message);
-    this.name = "ValidationError";
-    this.code = code;
-    this.details = {
-      invalidParams: invalidParameters,
-      mediaType,
-      suggestions,
-      validParams: validParameters
-    };
-  }
-}
-
-export { ValidationError as default };

package/dist/packem_shared/VercelBlobFile-BCg4aTEq.js

@@ -1,18 +0,0 @@
-import File from './File-Bb3P23dr.js';
-
-class VercelBlobFile extends File {
-  /**
-   * The blob's public URL
-   */
-  url;
-  /**
-   * The blob's download URL (may be different from url for private blobs)
-   */
-  downloadUrl;
-  /**
-   * The blob's pathname within the store
-   */
-  pathname;
-}
-
-export { VercelBlobFile as default };

package/dist/packem_shared/VercelBlobMetaStorage-Bd9F-VFm.js

@@ -1,9 +0,0 @@
-import { L as LocalMetaStorage } from './local-meta-storage-By-3SNBI.js';
-
-class VercelBlobMetaStorage extends LocalMetaStorage {
-  constructor(config) {
-    super(config);
-  }
-}
-
-export { VercelBlobMetaStorage as default };

package/dist/packem_shared/VercelBlobStorage-DD9LMOS6.js

@@ -1,261 +0,0 @@
-import { put, del, copy, list } from '@vercel/blob';
-import { g as getFileStatus, p as partMatch, a as detectFileTypeFromBuffer } from './part-match-BMNqHDYD.js';
-import { B as BaseStorage, t as toMilliseconds } from './storage-C6NSXb8h.js';
-import { L as LocalMetaStorage } from './local-meta-storage-By-3SNBI.js';
-import VercelBlobFile from './VercelBlobFile-BCg4aTEq.js';
-import { u as updateSize } from './update-size-CCGm6i1J.js';
-import { h as hasContent } from './has-content-CY66ehMK.js';
-
-class VercelBlobStorage extends BaseStorage {
-  static name = "vercel-blob";
-  checksumTypes = ["md5"];
-  meta;
-  token;
-  multipart;
-  constructor(config) {
-    super(config);
-    this.token = config.token || process.env.BLOB_READ_WRITE_TOKEN || process.env.VERCEL_BLOB_TOKEN || "";
-    if (!this.token) {
-      throw new Error("Vercel Blob token is required. Set BLOB_READ_WRITE_TOKEN or VERCEL_BLOB_TOKEN environment variable, or provide token in config.");
-    }
-    this.multipart = config.multipart ?? false;
-    const { metaStorage, metaStorageConfig } = config;
-    this.meta = metaStorage || new LocalMetaStorage(metaStorageConfig);
-    this.isReady = true;
-  }
-  async create(config) {
-    return this.instrumentOperation("create", async () => {
-      const processedConfig = { ...config };
-      if (config.ttl) {
-        const ttlMs = typeof config.ttl === "string" ? toMilliseconds(config.ttl) : config.ttl;
-        processedConfig.expiredAt = ttlMs === void 0 ? void 0 : Date.now() + ttlMs;
-      }
-      const file = new VercelBlobFile(processedConfig);
-      file.name = this.namingFunction(file);
-      await this.validate(file);
-      try {
-        const existing = await this.getMeta(file.id);
-        if (existing.bytesWritten >= 0) {
-          return existing;
-        }
-      } catch {
-      }
-      file.bytesWritten = 0;
-      file.status = getFileStatus(file);
-      await this.saveMeta(file);
-      await this.onCreate(file);
-      return file;
-    });
-  }
-  async write(part) {
-    return this.instrumentOperation("write", async () => {
-      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)) {
-        throw new Error("File part does not match");
-      }
-      await this.lock(part.id);
-      try {
-        if (hasContent(part)) {
-          if (this.isUnsupportedChecksum(part.checksumAlgorithm)) {
-            throw new Error("Unsupported checksum algorithm");
-          }
-          const chunks = [];
-          const stream = part.body;
-          for await (const chunk of stream) {
-            chunks.push(Buffer.from(chunk));
-          }
-          const buffer = Buffer.concat(chunks);
-          if ((file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) && (!file.contentType || file.contentType === "application/octet-stream")) {
-            try {
-              const fileType = await detectFileTypeFromBuffer(buffer);
-              if (fileType?.mime) {
-                file.contentType = fileType.mime;
-              }
-            } catch {
-            }
-          }
-          const blob = new Blob([buffer], { type: file.contentType });
-          const result = await put(file.name, blob, {
-            access: "public",
-            multipart: this.shouldUseMultipart(file)
-          });
-          file.url = result.url;
-          file.pathname = result.pathname;
-          file.downloadUrl = result.downloadUrl;
-          file.bytesWritten = buffer.length;
-        }
-        file.status = getFileStatus(file);
-        if (file.status === "completed") {
-          await this.internalOnComplete(file);
-        }
-        await this.saveMeta(file);
-        return file;
-      } finally {
-        await this.unlock(part.id);
-      }
-    });
-  }
-  /**
-   * Deletes an upload and its metadata.
-   * @param query File query containing the file ID to delete.
-   * @param query.id File ID to delete.
-   * @returns Promise resolving to the deleted file object with status: "deleted".
-   * @throws {UploadError} If the file metadata cannot be found.
-   */
-  async delete({ id }) {
-    return this.instrumentOperation("delete", async () => {
-      const file = await this.getMeta(id);
-      if (!file.url) {
-        throw new Error(`File ${id} does not have a valid URL`);
-      }
-      file.status = "deleted";
-      try {
-        await del(file.url, { token: this.token });
-      } catch (error) {
-        this.logger?.error("Failed to delete blob from Vercel Blob:", error);
-        const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
-        await this.onError(httpError);
-      }
-      await this.deleteMeta(file.id);
-      const deletedFile = { ...file };
-      await this.onDelete(deletedFile);
-      return deletedFile;
-    });
-  }
-  /**
-   * Checks if a file exists by verifying both metadata and the actual Vercel Blob.
-   * Returns true only if both the metadata and the blob exist.
-   * @param query File query containing the file ID to check.
-   * @returns Promise resolving to true if both metadata and blob exist, false otherwise.
-   */
-  async exists({ id }) {
-    return this.instrumentOperation("exists", async () => {
-      try {
-        const file = await this.getMeta(id);
-        if (!file.url || file.url.length === 0) {
-          return false;
-        }
-        const response = await fetch(file.url, { method: "HEAD" });
-        return response.ok;
-      } catch {
-        return false;
-      }
-    });
-  }
-  async get({ id }) {
-    return this.instrumentOperation("get", async () => {
-      const file = await this.checkIfExpired(await this.getMeta(id));
-      if (!file.url || file.url.length === 0) {
-        throw new Error("File URL not found");
-      }
-      const response = await fetch(file.url);
-      const content = Buffer.from(await response.arrayBuffer());
-      return {
-        content,
-        contentType: file.contentType,
-        ETag: file.ETag,
-        expiredAt: file.expiredAt,
-        id,
-        metadata: file.metadata,
-        modifiedAt: file.modifiedAt,
-        name: file.name,
-        originalName: file.originalName,
-        size: file.size || content.length
-      };
-    });
-  }
-  /**
-   * Copies an upload file to a new location.
-   * @param name Source file name/ID.
-   * @param destination Destination file name/ID.
-   * @returns Promise resolving to the copied file object.
-   * @throws {UploadError} If the source file cannot be found.
-   */
-  async copy(name, destination) {
-    return this.instrumentOperation("copy", async () => {
-      const sourceFile = await this.getMeta(name);
-      if (!sourceFile.url) {
-        throw new Error("Source file URL not found");
-      }
-      const result = await copy(sourceFile.url, destination, {
-        access: "public"
-      });
-      return {
-        ...sourceFile,
-        id: destination,
-        name: destination,
-        pathname: result.pathname,
-        url: result.url
-      };
-    });
-  }
-  /**
-   * Moves an upload file to a new location.
-   * @param name Source file name/ID.
-   * @param destination Destination file name/ID.
-   * @returns Promise resolving to the moved file object.
-   * @throws {UploadError} If the source file cannot be found.
-   */
-  async move(name, destination) {
-    return this.instrumentOperation("move", async () => {
-      const copiedFile = await this.copy(name, destination);
-      await this.delete({ id: name });
-      return copiedFile;
-    });
-  }
-  async list(limit = 1e3) {
-    return this.instrumentOperation(
-      "list",
-      async () => {
-        const result = await list({ limit });
-        return result.blobs.map((blob) => {
-          const file = new VercelBlobFile({
-            contentType: "application/octet-stream",
-            // Default content type
-            metadata: {},
-            originalName: blob.pathname
-          });
-          file.createdAt = blob.uploadedAt?.toISOString();
-          file.id = blob.pathname;
-          file.modifiedAt = blob.uploadedAt?.toISOString();
-          file.name = blob.pathname;
-          file.pathname = blob.pathname;
-          file.size = blob.size;
-          file.url = blob.url;
-          file.downloadUrl = blob.downloadUrl;
-          return file;
-        });
-      },
-      { limit }
-    );
-  }
-  internalOnComplete = (file) => this.deleteMeta(file.id);
-  /**
-   * Determines if multipart upload should be used for the given file.
-   * @param file File object to check.
-   * @returns True if multipart upload should be used, false otherwise.
-   */
-  shouldUseMultipart(file) {
-    if (typeof this.multipart === "boolean") {
-      return this.multipart;
-    }
-    if (typeof this.multipart === "number" && file.size !== void 0) {
-      return file.size >= this.multipart;
-    }
-    return false;
-  }
-}
-
-export { VercelBlobStorage as default };

package/dist/packem_shared/_commonjsHelpers-BqLXS_qQ.js

@@ -1,5 +0,0 @@
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-
-export { getDefaultExportFromCjs as g };