@visulima/storage 1.0.0-alpha.9 → 1.0.1

package/dist/packem_shared/NetlifyBlobStorage-CLPtjHqd.js

@@ -1,376 +0,0 @@
-import { getStore } from '@netlify/blobs';
-import { g as getFileStatus, p as partMatch, a as detectFileTypeFromBuffer } from './part-match-BMNqHDYD.js';
-import { B as BaseStorage, t as toMilliseconds, u as updateMetadata } from './storage-C6NSXb8h.js';
-import { createRetryWrapper } from './isRetryableError-Dycp7127.js';
-import { L as LocalMetaStorage } from './local-meta-storage-By-3SNBI.js';
-import NetlifyBlobFile from './NetlifyBlobFile-CXzyjqrD.js';
-import { u as updateSize } from './update-size-CCGm6i1J.js';
-import { h as hasContent } from './has-content-CY66ehMK.js';
-
-class NetlifyBlobStorage extends BaseStorage {
-  static name = "netlify-blob";
-  checksumTypes = ["md5"];
-  meta;
-  storeName;
-  siteID;
-  token;
-  store;
-  retry;
-  constructor(config) {
-    super(config);
-    this.storeName = config.storeName || "default";
-    this.siteID = config.siteID || process.env.NETLIFY_SITE_ID;
-    this.token = config.token || process.env.NETLIFY_TOKEN;
-    this.store = getStore({
-      name: this.storeName,
-      ...this.siteID && { siteID: this.siteID },
-      ...this.token && { token: this.token }
-    });
-    const retryConfig = {
-      backoffMultiplier: 2,
-      initialDelay: 1e3,
-      maxDelay: 3e4,
-      maxRetries: 3,
-      retryableStatusCodes: [408, 429, 500, 502, 503, 504],
-      shouldRetry: (error) => {
-        if (error instanceof Error) {
-          const errorWithCode = error;
-          const errorCode = errorWithCode.code;
-          if (errorCode === "ECONNRESET" || errorCode === "ETIMEDOUT" || errorCode === "ENOTFOUND" || errorCode === "ECONNREFUSED") {
-            return true;
-          }
-        }
-        const errorWithStatus = error;
-        return Boolean(errorWithStatus.status && [408, 429, 500, 502, 503, 504].includes(errorWithStatus.status));
-      },
-      ...config.retryConfig
-    };
-    this.retry = createRetryWrapper(retryConfig);
-    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 NetlifyBlobFile(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 {
-            }
-          }
-          await this.retry(
-            () => this.store.set(file.name, buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), {
-              metadata: {
-                contentType: file.contentType,
-                ...file.metadata
-              }
-            })
-          );
-          file.pathname = file.name;
-          file.url = this.getBlobUrl(file.name);
-          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.pathname) {
-        throw new Error(`File ${id} does not have a valid pathname`);
-      }
-      file.status = "deleted";
-      try {
-        await this.retry(() => this.store.delete(file.pathname));
-      } catch (error) {
-        this.logger?.error("Failed to delete blob from Netlify 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 Netlify 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.pathname || file.pathname.length <= 0) {
-          return false;
-        }
-        const blob = await this.retry(() => this.store.get(file.pathname, { type: "blob" }));
-        return blob !== null && blob !== void 0;
-      } catch {
-        return false;
-      }
-    });
-  }
-  async get({ id }) {
-    return this.instrumentOperation("get", async () => {
-      const file = await this.checkIfExpired(await this.getMeta(id));
-      if (!file.pathname || file.pathname.length <= 0) {
-        throw new Error("File pathname not found");
-      }
-      const blob = await this.retry(() => this.store.get(file.pathname, { type: "blob" }));
-      if (!blob) {
-        throw new Error("File not found in Netlify Blob");
-      }
-      let arrayBuffer;
-      if (typeof blob === "string") {
-        arrayBuffer = Buffer.from(blob, "utf8").buffer;
-      } else if (blob && typeof blob === "object" && "arrayBuffer" in blob && typeof blob.arrayBuffer === "function") {
-        arrayBuffer = await this.retry(() => blob.arrayBuffer());
-      } else {
-        throw new Error("Invalid blob type returned from Netlify Blob");
-      }
-      const content = Buffer.from(arrayBuffer);
-      let blobMetadata = null;
-      try {
-        const metadata = await this.store.getMetadata?.(file.pathname);
-        blobMetadata = metadata ?? null;
-      } catch {
-      }
-      return {
-        content,
-        contentType: blobMetadata?.contentType || file.contentType,
-        ETag: file.ETag,
-        expiredAt: file.expiredAt,
-        id,
-        metadata: {
-          ...file.metadata,
-          ...blobMetadata?.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.pathname) {
-        throw new Error("Source file pathname not found");
-      }
-      const sourceBlob = await this.retry(() => this.store.get(sourceFile.pathname, { type: "blob" }));
-      if (!sourceBlob) {
-        throw new Error("Source file not found in Netlify Blob");
-      }
-      let sourceMetadata = null;
-      try {
-        const storeWithMetadata = this.store;
-        if (storeWithMetadata.getMetadata && sourceFile.pathname) {
-          sourceMetadata = await storeWithMetadata.getMetadata(sourceFile.pathname);
-        }
-      } catch {
-      }
-      let arrayBuffer;
-      if (typeof sourceBlob === "string") {
-        arrayBuffer = Buffer.from(sourceBlob, "utf8").buffer;
-      } else if (sourceBlob && typeof sourceBlob === "object" && "arrayBuffer" in sourceBlob) {
-        const blobWithArrayBuffer = sourceBlob;
-        arrayBuffer = await this.retry(() => blobWithArrayBuffer.arrayBuffer());
-      } else {
-        throw new Error("Invalid blob type returned from Netlify Blob");
-      }
-      const buffer = Buffer.from(arrayBuffer);
-      await this.retry(
-        () => this.store.set(destination, buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), {
-          metadata: sourceMetadata || {
-            contentType: sourceFile.contentType,
-            ...sourceFile.metadata
-          }
-        })
-      );
-      const copiedFile = {
-        ...sourceFile,
-        id: destination,
-        name: destination,
-        pathname: destination,
-        url: this.getBlobUrl(destination)
-      };
-      await this.saveMeta(copiedFile);
-      return copiedFile;
-    });
-  }
-  /**
-   * 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;
-    });
-  }
-  /**
-   * Updates file metadata with user-provided key-value pairs.
-   * Updates the metadata file (overwrites it) but does not update Netlify Blob metadata
-   * since the Netlify Blob API doesn't support metadata updates.
-   * @param query File query containing the file ID to update.
-   * @param query.id File ID to update.
-   * @param metadata Partial file object containing fields to update.
-   * @returns Promise resolving to the updated file object.
-   * @throws {UploadError} If the file cannot be found (ERRORS.FILE_NOT_FOUND).
-   * @remarks
-   * Supports TTL (time-to-live) option: if metadata contains a 'ttl' field,
-   * it will be converted to an 'expiredAt' timestamp.
-   * TTL can be a number (milliseconds) or string (e.g., "1h", "30m", "7d").
-   */
-  async update({ id }, metadata) {
-    return this.instrumentOperation("update", async () => {
-      const file = await this.getMeta(id);
-      const processedMetadata = { ...metadata };
-      if ("ttl" in processedMetadata && processedMetadata.ttl !== void 0) {
-        const ttlValue = processedMetadata.ttl;
-        const ttlMs = typeof ttlValue === "string" ? toMilliseconds(ttlValue) : ttlValue;
-        if (ttlMs !== void 0) {
-          processedMetadata.expiredAt = Date.now() + ttlMs;
-        }
-        delete processedMetadata.ttl;
-      }
-      updateMetadata(file, processedMetadata);
-      await this.saveMeta(file);
-      const updatedFile = { ...file, status: "updated" };
-      await this.onUpdate(updatedFile);
-      return updatedFile;
-    });
-  }
-  async list(limit = 1e3) {
-    return this.instrumentOperation(
-      "list",
-      async () => {
-        const listResult = await this.retry(() => this.store.list());
-        const files = [];
-        for await (const blob of listResult.blobs) {
-          let metadata = null;
-          try {
-            const fetchedMetadata = await this.store.getMetadata?.(blob.key);
-            metadata = fetchedMetadata ?? null;
-          } catch {
-          }
-          const file = new NetlifyBlobFile({
-            contentType: metadata?.contentType || "application/octet-stream",
-            metadata: metadata?.metadata || {},
-            originalName: blob.key
-          });
-          const blobWithDates = blob;
-          file.createdAt = blobWithDates.createdAt?.toISOString();
-          file.id = blob.key;
-          file.modifiedAt = blobWithDates.updatedAt?.toISOString();
-          file.name = blob.key;
-          file.pathname = blob.key;
-          file.size = blobWithDates.size;
-          file.url = this.getBlobUrl(blob.key);
-          files.push(file);
-          if (files.length >= limit) {
-            break;
-          }
-        }
-        return files;
-      },
-      { limit }
-    );
-  }
-  internalOnComplete = (file) => this.deleteMeta(file.id);
-  /**
-   * Generate a URL for a blob in Netlify Blob store
-   * Note: Netlify Blob doesn't provide direct public URLs like Vercel Blob
-   * In production, you would typically serve these through Netlify Functions or Edge Functions
-   */
-  getBlobUrl(pathname) {
-    return `/api/blobs/${this.storeName}/${pathname}`;
-  }
-}
-
-export { NetlifyBlobStorage as default };

package/dist/packem_shared/NoOpMetrics-DhAk5rXc.js

@@ -1,10 +0,0 @@
-class NoOpMetrics {
-  increment(_name, _value, _attributes) {
-  }
-  timing(_name, _duration, _attributes) {
-  }
-  gauge(_name, _value, _attributes) {
-  }
-}
-
-export { NoOpMetrics as default };

package/dist/packem_shared/OpenTelemetryMetrics-BnxhqIaH.js

@@ -1,67 +0,0 @@
-import { metrics } from '@opentelemetry/api';
-
-class OpenTelemetryMetrics {
-  meter;
-  counters = /* @__PURE__ */ new Map();
-  histograms = /* @__PURE__ */ new Map();
-  gauges = /* @__PURE__ */ new Map();
-  /**
-   * Creates a new OpenTelemetryMetrics instance.
-   * @param meter OpenTelemetry Meter instance. If not provided, uses the default meter.
-   * @throws {Error} If \@opentelemetry/api is not installed
-   */
-  constructor(meter) {
-    this.meter = meter || metrics.getMeter("@visulima/storage", "1.0.0");
-  }
-  /**
-   * Increment a counter metric.
-   */
-  increment(name, value = 1, attributes) {
-    if (!this.counters.has(name)) {
-      const options = {
-        description: `Counter for ${name}`
-      };
-      this.counters.set(name, this.meter.createCounter(name, options));
-    }
-    const counter = this.counters.get(name);
-    if (!counter) {
-      throw new Error(`Counter ${name} was not created`);
-    }
-    counter.add(value, attributes);
-  }
-  /**
-   * Record a duration/timing metric in milliseconds.
-   */
-  timing(name, duration, attributes) {
-    if (!this.histograms.has(name)) {
-      const options = {
-        description: `Duration histogram for ${name}`,
-        unit: "ms"
-      };
-      this.histograms.set(name, this.meter.createHistogram(name, options));
-    }
-    const histogram = this.histograms.get(name);
-    if (!histogram) {
-      throw new Error(`Histogram ${name} was not created`);
-    }
-    histogram.record(duration, attributes);
-  }
-  /**
-   * Set a gauge metric value.
-   */
-  gauge(name, value, attributes) {
-    if (!this.gauges.has(name)) {
-      const options = {
-        description: `Gauge for ${name}`
-      };
-      this.gauges.set(name, this.meter.createUpDownCounter(name, options));
-    }
-    const gauge = this.gauges.get(name);
-    if (!gauge) {
-      throw new Error(`Gauge ${name} was not created`);
-    }
-    gauge.add(value, attributes);
-  }
-}
-
-export { OpenTelemetryMetrics as default };

package/dist/packem_shared/Rest-DcxBMBjU.js

@@ -1,228 +0,0 @@
-import { c as createHttpError } from './headers-YLRp1dLo.js';
-import { hasBody } from 'type-is';
-import { a as getHeader, b as getRequestStream, g as getIdFromRequest, r as readBody } from './base-handler-core-BoAqTyz7.js';
-import { B as BaseHandlerNode } from './base-handler-node-DGzcHHAy.js';
-import { R as RestBase, v as validateRequestBody, a as validateContentLength, e as extractFileInit, p as parseContentDisposition, b as parseChunkHeaders } from './rest-base-D9URIFkc.js';
-
-class Rest extends BaseHandlerNode {
-  /**
-   * Limiting enabled http method handler
-   */
-  static methods = ["delete", "download", "get", "head", "options", "patch", "post", "put"];
-  restBase;
-  constructor(options) {
-    super(options);
-    const restInstance = this;
-    this.restBase = new class extends RestBase {
-      // eslint-disable-next-line class-methods-use-this
-      get storage() {
-        return restInstance.storage;
-      }
-      // eslint-disable-next-line class-methods-use-this
-      buildFileUrl(requestUrl, file) {
-        return restInstance.buildFileUrlForRest(requestUrl, file);
-      }
-    }();
-  }
-  /**
-   * Compose and register HTTP method handlers.
-   */
-  compose() {
-    this.registeredHandlers.set("POST", this.post.bind(this));
-    this.registeredHandlers.set("PUT", this.put.bind(this));
-    this.registeredHandlers.set("PATCH", this.patch.bind(this));
-    this.registeredHandlers.set("DELETE", this.delete.bind(this));
-    this.registeredHandlers.set("HEAD", this.head.bind(this));
-    this.registeredHandlers.set("GET", this.get.bind(this));
-    this.registeredHandlers.set("OPTIONS", this.options.bind(this));
-    this.logger?.debug("Registered handler: %s", [...this.registeredHandlers.keys()].join(", "));
-  }
-  /**
-   * Build file URL from request 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
-   */
-  buildFileUrlForRest(requestUrl, file) {
-    return this.buildFileUrl({ url: requestUrl }, file);
-  }
-  /**
-   * Creates a new file via POST request with raw binary data.
-   * Supports both full file uploads and chunked upload initialization.
-   * @param request Node.js IncomingMessage with file data.
-   * @returns Promise resolving to ResponseFile with upload result.
-   */
-  async post(request) {
-    const isChunkedUpload = getHeader(request, "x-chunked-upload", true) === "true";
-    validateRequestBody(request, true);
-    const contentLength = validateContentLength(request, true, this.storage.maxUploadSize);
-    const contentType = getHeader(request, "content-type") || "application/octet-stream";
-    const config = extractFileInit(request, contentLength, contentType);
-    const requestUrl = request.originalUrl || request.url;
-    const bodyStream = getRequestStream(request);
-    return this.restBase.handlePost(config, isChunkedUpload, requestUrl, bodyStream, contentLength);
-  }
-  /**
-   * Create or update a file via PUT request.
-   * Requires file ID in the URL path.
-   * @param request Node.js IncomingMessage with file ID and data
-   * @returns Promise resolving to ResponseFile with upload result
-   */
-  async put(request) {
-    let id;
-    try {
-      id = getIdFromRequest(request);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      throw error;
-    }
-    if (!hasBody(request)) {
-      throw createHttpError(400, "Request body is required");
-    }
-    const contentLength = Number.parseInt(getHeader(request, "content-length") || "0", 10);
-    if (contentLength === 0) {
-      throw createHttpError(400, "Content-Length is required and must be greater than 0");
-    }
-    if (contentLength > this.storage.maxUploadSize) {
-      throw createHttpError(413, `File size exceeds maximum allowed size of ${this.storage.maxUploadSize} bytes`);
-    }
-    const contentType = getHeader(request, "content-type") || "application/octet-stream";
-    const metadataHeader = getHeader(request, "x-file-metadata", true);
-    let metadata;
-    if (metadataHeader) {
-      try {
-        metadata = JSON.parse(metadataHeader);
-      } catch {
-      }
-    }
-    const originalName = parseContentDisposition(request);
-    const config = {
-      contentType,
-      metadata: metadata || {},
-      originalName,
-      size: contentLength
-    };
-    const requestUrl = request.originalUrl || request.url;
-    const bodyStream = getRequestStream(request);
-    return this.restBase.handlePut(id, config, requestUrl, bodyStream, contentLength, metadata);
-  }
-  /**
-   * Delete an uploaded file or multiple files.
-   * Supports single file (ID in URL) or batch delete (via ?ids=id1,id2 or JSON body).
-   * @param request Node.js IncomingMessage with file ID(s)
-   * @returns Promise resolving to ResponseFile (single) or ResponseList (batch) with deletion result
-   */
-  async delete(request) {
-    const url = new URL(request.url || "", "http://localhost");
-    const idsParameter = url.searchParams.get("ids");
-    if (idsParameter) {
-      const ids = idsParameter.split(",").map((id) => id.trim()).filter(Boolean);
-      if (ids.length === 0) {
-        throw createHttpError(400, "No file IDs provided");
-      }
-      return this.restBase.deleteBatch(ids);
-    }
-    const contentType = getHeader(request, "content-type") || "";
-    if (contentType.includes("application/json")) {
-      try {
-        const body = await readBody(request, "utf8", 1024 * 1024);
-        const parsed = JSON.parse(body);
-        if (Array.isArray(parsed)) {
-          if (parsed.length === 0) {
-            throw createHttpError(400, "No file IDs provided");
-          }
-          return this.restBase.deleteBatch(parsed);
-        }
-        if (typeof parsed === "object" && parsed !== null && "ids" in parsed && Array.isArray(parsed.ids)) {
-          const idsArray = parsed.ids;
-          if (idsArray.length === 0) {
-            throw createHttpError(400, "No file IDs provided");
-          }
-          return this.restBase.deleteBatch(idsArray);
-        }
-      } catch (error) {
-        if (error.statusCode === 400) {
-          throw error;
-        }
-      }
-    }
-    try {
-      const id = getIdFromRequest(request);
-      return this.restBase.deleteSingle(id);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      if (error.code === "ENOENT" || error.UploadErrorCode === "FILE_NOT_FOUND") {
-        throw createHttpError(404, "File not found");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Uploads a chunk via PATCH request for chunked uploads.
-   * Headers required: X-Chunk-Offset (byte offset), Content-Length (chunk size).
-   * Optional: X-Chunk-Checksum (SHA256 checksum for validation).
-   * @param request Node.js IncomingMessage with chunk data.
-   * @returns Promise resolving to ResponseFile with upload progress.
-   */
-  async patch(request) {
-    let id;
-    try {
-      id = getIdFromRequest(request);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      throw error;
-    }
-    if (!hasBody(request)) {
-      throw createHttpError(400, "Request body is required");
-    }
-    const contentLength = Number.parseInt(getHeader(request, "content-length") || "0", 10);
-    if (contentLength === 0) {
-      throw createHttpError(400, "Content-Length is required and must be greater than 0");
-    }
-    const { chunkOffset } = parseChunkHeaders(request);
-    if (chunkOffset === void 0) {
-      throw createHttpError(400, "X-Chunk-Offset header is required");
-    }
-    const chunkChecksum = getHeader(request, "x-chunk-checksum", true);
-    const requestUrl = request.originalUrl || request.url;
-    const bodyStream = getRequestStream(request);
-    return this.restBase.handlePatch(id, chunkOffset, contentLength, chunkChecksum, requestUrl, bodyStream);
-  }
-  /**
-   * Get file metadata via HEAD request.
-   * For chunked uploads, also returns upload progress information.
-   * @param request Node.js IncomingMessage with file ID
-   * @returns Promise resolving to ResponseFile with metadata headers
-   */
-  async head(request) {
-    try {
-      const id = getIdFromRequest(request);
-      return this.restBase.handleHead(id);
-    } catch (error) {
-      this.checkForUndefinedIdOrPath(error);
-      if (error.UploadErrorCode === "FILE_NOT_FOUND" || error.code === "ENOENT") {
-        throw createHttpError(404, "File not found");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Handle OPTIONS requests with REST API capabilities.
-   * @returns Promise resolving to ResponseFile with CORS headers
-   */
-  async options() {
-    return this.restBase.handleOptions(Rest.methods, this.storage.maxUploadSize);
-  }
-  /**
-   * Retrieves a file or list of files based on the request path.
-   * Delegates to BaseHandlerNode.get() method.
-   * @param request Node.js IncomingMessage with optional originalUrl.
-   * @param response Node.js ServerResponse.
-   * @returns Promise resolving to a single file, paginated list, or array of files.
-   */
-  async get(request, response) {
-    return super.get(request, response);
-  }
-}
-
-export { Rest as default };