@visulima/storage 1.0.0-alpha.18 → 1.0.0-alpha.19

package/dist/packem_shared/base-handler-node-BiO2DF87.js

@@ -1,731 +0,0 @@
-import { paginate } from '@visulima/pagination';
-import { H as HeaderUtilities, h as httpErrorsExports, c as createHttpError } from './headers-YLRp1dLo.js';
-import mime from 'mime';
-import { ERRORS, isUploadError } from './ERRORS-D0apMqnc.js';
-import { match } from 'path-to-regexp';
-import { p as pick, B as BaseHandlerCore, s as setHeaders, d as getRealPath, u as uuidRegex } from './base-handler-core-lVB-D59L.js';
-import { i as isValidationError } from './validator-DuO17wFF.js';
-import { waitForStorage } from './waitForStorage-Cscw85sx.js';
-import { PassThrough } from 'node:stream';
-import { e as convertHeadersToString } from './response-builder-BtnRiBUI.js';
-
-const internalMatcher = match(["/:uuid", "/*path/:uuid.:ext/:metadata", "/*path/:uuid/:metadata", "/*path/:uuid.:ext", "/*path/:uuid"], {
-  decode: decodeURIComponent
-});
-const filePathUrlMatcher = (path) => {
-  const result = internalMatcher(path);
-  if (!result) {
-    return void 0;
-  }
-  const { params } = result;
-  if (!params.uuid) {
-    return void 0;
-  }
-  const orderedParams = {
-    uuid: params.uuid
-  };
-  if (params.metadata !== void 0) {
-    orderedParams.metadata = params.metadata;
-  }
-  if (params.path !== void 0) {
-    orderedParams.path = params.path;
-  }
-  if (params.ext !== void 0) {
-    orderedParams.ext = params.ext;
-  }
-  return {
-    params: orderedParams,
-    path: result.path
-  };
-};
-
-const createRangeLimitedStream = (sourceStream, start, end) => {
-  let bytesRead = 0;
-  let bytesSent = 0;
-  const contentLength = end - start + 1;
-  return new PassThrough({
-    // Use appropriate high water mark for better backpressure handling
-    highWaterMark: Math.min(64 * 1024, contentLength),
-    // 64KB or content length, whichever is smaller
-    transform(chunk, _, callback) {
-      const chunkSize = chunk.length;
-      const currentPos = bytesRead;
-      const endPos = currentPos + chunkSize - 1;
-      bytesRead += chunkSize;
-      if (endPos < start) {
-        callback();
-        return;
-      }
-      if (currentPos > end) {
-        this.end();
-        callback();
-        return;
-      }
-      const chunkStart = Math.max(0, start - currentPos);
-      const chunkEnd = Math.min(chunkSize, end - currentPos + 1);
-      if (chunkStart < chunkEnd) {
-        const dataToSend = chunk.subarray(chunkStart, chunkEnd);
-        bytesSent += dataToSend.length;
-        const canContinue = this.push(dataToSend);
-        if (!canContinue) {
-          sourceStream.pause();
-        }
-      }
-      if (bytesSent >= contentLength) {
-        this.end();
-        sourceStream.destroy();
-      }
-      callback();
-    }
-  });
-};
-const pipeWithBackpressure = (source, destination, sendError) => {
-  let isDestroyed = false;
-  const cleanup = () => {
-    if (isDestroyed) {
-      return;
-    }
-    isDestroyed = true;
-    source.destroy();
-  };
-  destination.on("drain", () => {
-    source.resume();
-  });
-  destination.on("close", cleanup);
-  destination.on("finish", cleanup);
-  destination.on("error", cleanup);
-  source.on("end", () => {
-    destination.end();
-  });
-  source.on("error", async (error) => {
-    if (!isDestroyed) {
-      await sendError(destination, error);
-      cleanup();
-    }
-  });
-  source.on("data", (chunk) => {
-    const canContinue = destination.write(chunk);
-    if (!canContinue) {
-      source.pause();
-    }
-  });
-  if (typeof destination.listeners === "function" && destination.listeners("close")?.length === 0) {
-    destination.on("close", cleanup);
-  }
-};
-
-const handleHeadOptionsRequest = (file, send, response) => {
-  const { headers, statusCode } = file;
-  send(response, { headers, statusCode });
-};
-const handleGetRequest = (file, request, response, next, send, sendStream, parseRangeHeader) => {
-  request.body = file?.data === void 0 ? file : file.data;
-  const { headers, statusCode } = file;
-  const streamingFile = file;
-  if (streamingFile.stream) {
-    if (typeof next === "function") {
-      next();
-    } else {
-      const range = parseRangeHeader(request.headers.range, streamingFile.size || 0);
-      sendStream(response, streamingFile.stream, {
-        headers,
-        range: range || void 0,
-        size: streamingFile.size,
-        statusCode
-      });
-    }
-  } else {
-    let body = "";
-    if (file.content !== void 0) {
-      body = file.content;
-    } else if (typeof file === "object" && "data" in file) {
-      body = file.data;
-    }
-    if (typeof next === "function") {
-      next();
-    } else {
-      send(response, { body, headers, statusCode });
-    }
-  }
-};
-const handleCompletedUpload = async (file, request, response, next, storage, logger, finish) => {
-  const { headers: fileHeaders, statusCode, ...basicFile } = file;
-  if (typeof next === "function") {
-    request._body = true;
-    request.body = basicFile;
-    next();
-  } else {
-    const responseFile = file;
-    const originalHeaders = responseFile.headers ? { ...responseFile.headers } : {};
-    if (responseFile.headers === void 0) {
-      responseFile.headers = {};
-    }
-    if (responseFile.statusCode === void 0) {
-      responseFile.statusCode = 200;
-    }
-    try {
-      const result = storage.onComplete(basicFile, responseFile, request);
-      if (result instanceof Promise) {
-        await result;
-      }
-    } catch (error) {
-      if (logger?.error) {
-        logger.error("[onComplete error]: %O", error);
-      }
-      throw error;
-    }
-    if (Object.keys(responseFile.headers || {}).length === 0 && Object.keys(originalHeaders).length > 0) {
-      responseFile.headers = originalHeaders;
-    } else if (responseFile.headers && Object.keys(originalHeaders).length > 0) {
-      responseFile.headers = {
-        ...originalHeaders,
-        ...responseFile.headers
-      };
-    }
-    finish(request, response, responseFile);
-  }
-};
-const handlePartialUpload = (file, request, response, send) => {
-  const { headers: fileHeaders, statusCode, ...basicFile } = file;
-  const headers = fileHeaders || {};
-  const isChunkedUploadInit = headers["X-Chunked-Upload"] === "true" || headers["x-chunked-upload"] === "true";
-  let body;
-  const responseHeaders = {
-    ...convertHeadersToString(headers),
-    ...fileHeaders ? convertHeadersToString(fileHeaders) : {},
-    ...basicFile.hash === void 0 ? {} : { [`X-Range-${basicFile.hash?.algorithm.toUpperCase()}`]: String(basicFile.hash?.value) }
-  };
-  if (isChunkedUploadInit) {
-    body = JSON.stringify(basicFile);
-    if (!responseHeaders["Content-Type"] && !responseHeaders["content-type"]) {
-      responseHeaders["Content-Type"] = "application/json; charset=utf-8";
-    }
-  }
-  if (request.method === "HEAD") {
-    body = "";
-  }
-  send(response, {
-    body,
-    headers: responseHeaders,
-    statusCode: statusCode || 200
-  });
-};
-const handleUploadError = async (error, request, emit, listenerCount, logger, sendError, response) => {
-  const errorObject = error instanceof Error ? error : new Error(String(error));
-  const uError = pick(errorObject, ["name", ...Object.getOwnPropertyNames(errorObject)]);
-  const errorEvent = { ...uError, request: pick(request, ["headers", "method", "url"]) };
-  if (listenerCount("error") > 0) {
-    emit("error", errorEvent);
-  }
-  if (logger?.error) {
-    logger.error("[error]: %O", errorEvent);
-  }
-  await sendError(response, errorObject);
-};
-
-const CONTENT_TYPE = "Content-Type";
-class BaseHandlerNode extends BaseHandlerCore {
-  /**
-   * Limiting enabled HTTP method handler.
-   */
-  static methods = ["delete", "get", "head", "options", "patch", "post", "put"];
-  /**
-   * Map of registered HTTP method handlers.
-   */
-  registeredHandlers = /* @__PURE__ */ new Map();
-  constructor(options) {
-    super(options);
-    this.compose();
-  }
-  /**
-   * Gets the registered handlers map.
-   * @returns Map of registered handlers.
-   */
-  get handlers() {
-    return this.registeredHandlers;
-  }
-  /**
-   * Handles HTTP request (alias for upload method).
-   * @param request Node.js IncomingMessage.
-   * @param response Node.js ServerResponse.
-   */
-  handle = async (request, response) => this.upload(request, response);
-  /**
-   * Main upload handler that processes HTTP requests and routes them to appropriate method handlers.
-   * @param request Node.js IncomingMessage.
-   * @param response Node.js ServerResponse.
-   * @param next Optional Express-style next function for middleware compatibility.
-   * @throws {UploadError} When storage is not ready or method is not allowed.
-   */
-  upload = async (request, response, next) => {
-    request.on("error", (error) => this.logger?.error("[request error]: %O", error));
-    this.logger?.debug("[request]: %s %s", request.method, request.url);
-    const handler = this.registeredHandlers.get(request.method);
-    if (!handler) {
-      await this.sendError(response, { UploadErrorCode: ERRORS.METHOD_NOT_ALLOWED });
-      return;
-    }
-    try {
-      await waitForStorage(this.storage);
-    } catch {
-      await this.sendError(response, { UploadErrorCode: ERRORS.STORAGE_ERROR });
-      return;
-    }
-    try {
-      const file = await handler.call(this, request, response);
-      if (["HEAD", "OPTIONS"].includes(request.method)) {
-        handleHeadOptionsRequest(file, this.send.bind(this), response);
-      } else if (request.method === "GET") {
-        const fileResponse = file;
-        if (fileResponse) {
-          handleGetRequest(
-            fileResponse,
-            request,
-            response,
-            next,
-            this.send.bind(this),
-            this.sendStream.bind(this),
-            this.parseRangeHeader.bind(this)
-          );
-        }
-      } else {
-        const { headers: fileHeaders, statusCode, ...basicFile } = file;
-        this.logger?.debug("[%s]: %s: %d/%d", basicFile.status, basicFile.name, basicFile.bytesWritten, basicFile.size);
-        if (basicFile.status !== void 0 && this.listenerCount(basicFile.status) > 0) {
-          this.emit(basicFile.status, {
-            ...basicFile,
-            request: pick(request, ["headers", "method", "url"])
-          });
-        }
-        if (basicFile.status === "completed") {
-          await handleCompletedUpload(
-            file,
-            request,
-            response,
-            next,
-            this.storage,
-            this.logger,
-            (_request, resp, uploadResp) => {
-              this.finish(_request, resp, uploadResp);
-            }
-          );
-        } else {
-          handlePartialUpload(file, request, response, (resp, data) => {
-            this.send(resp, {
-              body: data.body,
-              headers: data.headers,
-              statusCode: data.statusCode
-            });
-          });
-        }
-      }
-    } catch (error) {
-      await handleUploadError(error, request, this.emit.bind(this), this.listenerCount.bind(this), this.logger, this.sendError.bind(this), response);
-    }
-  };
-  /**
-   * Sends an HTTP response with the provided body, headers, and status code.
-   * @param response Node.js ServerResponse to send data to.
-   * @param body Response body, headers, and status code.
-   */
-  // eslint-disable-next-line class-methods-use-this
-  send(response, { body = "", headers = {}, statusCode = 200 }) {
-    let data;
-    const finalHeaders = { ...headers };
-    if (typeof body === "string") {
-      data = body;
-      if (finalHeaders[CONTENT_TYPE] === void 0) {
-        finalHeaders[CONTENT_TYPE] = HeaderUtilities.createContentType({ mediaType: "text/plain" });
-      } else {
-        const contentTypeValue = Array.isArray(finalHeaders[CONTENT_TYPE]) ? finalHeaders[CONTENT_TYPE].join(", ") : String(finalHeaders[CONTENT_TYPE]);
-        finalHeaders[CONTENT_TYPE] = HeaderUtilities.ensureCharset(contentTypeValue);
-      }
-      if (finalHeaders["Content-Length"] === void 0) {
-        finalHeaders["Content-Length"] = Buffer.byteLength(body);
-      }
-    } else if (body instanceof Buffer) {
-      data = body;
-    } else {
-      data = JSON.stringify(body);
-      if (!finalHeaders[CONTENT_TYPE]) {
-        finalHeaders[CONTENT_TYPE] = HeaderUtilities.createContentType({
-          charset: "utf8",
-          mediaType: "application/json"
-        });
-      }
-    }
-    setHeaders(response, finalHeaders);
-    response.statusCode = statusCode;
-    response.end(data);
-  }
-  /**
-   * Sends an error response to the client with appropriate status code and message.
-   * @param response Node.js ServerResponse to send error to.
-   * @param error Error object to convert to HTTP error response.
-   */
-  async sendError(response, error) {
-    let httpError;
-    if (isUploadError(error)) {
-      httpError = this.internalErrorResponses[error.UploadErrorCode];
-    } else if (!isValidationError(error) && !httpErrorsExports.isHttpError(error)) {
-      httpError = this.storage.normalizeError(error);
-    } else {
-      httpError = {
-        ...error,
-        code: error.code || error.name,
-        headers: error.headers || {},
-        message: error.message,
-        name: error.name,
-        statusCode: error.statusCode || 500
-      };
-    }
-    await this.storage.onError(httpError);
-    let errorResponse;
-    if (httpError.body) {
-      if (typeof httpError.body === "object" && httpError.body !== null) {
-        errorResponse = { body: httpError.body, headers: httpError.headers, statusCode: httpError.statusCode };
-      } else {
-        errorResponse = {
-          body: {
-            error: {
-              code: httpError.code || httpError.name || "Error",
-              message: httpError.body || httpError.message || "Unknown error",
-              name: httpError.name || "Error"
-            }
-          },
-          headers: httpError.headers,
-          statusCode: httpError.statusCode || 500
-        };
-      }
-    } else {
-      errorResponse = {
-        body: {
-          error: {
-            code: httpError.code || httpError.name || "Error",
-            message: httpError.message || "Unknown error",
-            name: httpError.name || "Error"
-          }
-        },
-        headers: httpError.headers,
-        statusCode: httpError.statusCode || 500
-      };
-    }
-    this.send(response, errorResponse);
-  }
-  /**
-   * Sends streaming response to client with proper backpressure handling and range request support.
-   * @param response Node.js ServerResponse to stream data to.
-   * @param stream Readable stream containing the file data.
-   * @param options Streaming options including headers, range, size, and status code.
-   */
-  sendStream(response, stream, {
-    headers = {},
-    range,
-    size,
-    statusCode = 200
-  }) {
-    setHeaders(response, headers);
-    response.statusCode = statusCode;
-    let finalStream = stream;
-    if (range && size) {
-      response.statusCode = 206;
-      response.setHeader("Content-Range", `bytes ${range.start}-${range.end}/${size}`);
-      response.setHeader("Content-Length", range.end - range.start + 1);
-      response.setHeader("Accept-Ranges", "bytes");
-      finalStream = createRangeLimitedStream(stream, range.start, range.end);
-    } else {
-      if (size) {
-        response.setHeader("Content-Length", size);
-      }
-      response.setHeader("Accept-Ranges", "bytes");
-    }
-    pipeWithBackpressure(finalStream, response, (resp, error) => this.sendError(resp, error));
-  }
-  /**
-   * Finish upload by sending final response to client with completed file data.
-   * @param _request HTTP request (unused parameter)
-   * @param response HTTP response object to send final response to
-   * @param uploadResponse Final upload response data containing body, headers, and status code
-   */
-  finish(_request, response, uploadResponse) {
-    const isResponseFile = "id" in uploadResponse && "headers" in uploadResponse && !("body" in uploadResponse);
-    let body;
-    let headers;
-    let statusCode;
-    if (isResponseFile) {
-      const responseFile = uploadResponse;
-      const fileHeaders = responseFile.headers || {};
-      const fileStatusCode = responseFile.statusCode || 200;
-      const { headers: _, statusCode: __, ...fileData } = responseFile;
-      body = fileData;
-      headers = { ...fileHeaders };
-      statusCode = fileStatusCode;
-    } else {
-      const uploadResp = uploadResponse;
-      body = uploadResp.body;
-      headers = uploadResp.headers || {};
-      statusCode = uploadResp.statusCode || 200;
-    }
-    if (body && typeof body === "object" && body.content !== void 0) {
-      const { content, contentType } = body;
-      body = content;
-      headers = {
-        ...headers,
-        "Content-Type": contentType
-      };
-    }
-    this.send(response, {
-      body: body || uploadResponse,
-      headers,
-      statusCode
-    });
-  }
-  /**
-   * Build file URL from request and file data.
-   * @param request HTTP request with optional originalUrl property
-   * @param file File object containing ID and content type
-   * @returns Constructed file URL with extension based on content type
-   */
-  buildFileUrl(request, file) {
-    return this.buildFileUrlFromString(request.originalUrl || request.url, file);
-  }
-  /**
-   * Negotiates content type based on Accept header and supported formats.
-   * @param request HTTP request object containing Accept header.
-   * @param supportedTypes Array of supported MIME types to match against.
-   * @returns Best matching content type or undefined if no match found.
-   */
-  negotiateContentType(request, supportedTypes) {
-    return super.negotiateContentTypeFromHeader(request.headers.accept, supportedTypes);
-  }
-  /**
-   * Default OPTIONS handler.
-   * @param _request HTTP request (unused)
-   * @param _response HTTP response (unused)
-   * @returns Promise resolving to ResponseFile with CORS headers
-   */
-  async options(_request, _response) {
-    const child = this.constructor;
-    return {
-      headers: {
-        "Access-Control-Allow-Methods": (child.methods || BaseHandlerNode.methods).map((method) => method.toUpperCase()).join(", ")
-      },
-      statusCode: 204
-    };
-  }
-  /**
-   * Retrieves a file or list of files based on the request path.
-   * @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.
-   * @throws {UploadError} When file is not found or storage error occurs.
-   */
-  // eslint-disable-next-line sonarjs/cognitive-complexity
-  async get(request, _response) {
-    const pathMatch = filePathUrlMatcher(getRealPath(request));
-    if (pathMatch?.params.uuid) {
-      const { ext, metadata, uuid: rawUuid } = pathMatch.params;
-      const uuid = ext ? rawUuid.replace(new RegExp(String.raw`\.${ext}$`), "") : rawUuid;
-      if (metadata === "metadata" && getRealPath(request).endsWith("/metadata")) {
-        try {
-          const file = await this.storage.getMeta(uuid);
-          return {
-            ...file,
-            content: JSON.stringify(file),
-            headers: {
-              "Content-Type": HeaderUtilities.createContentType({
-                charset: "utf8",
-                mediaType: "application/json"
-              }),
-              ...file.expiredAt === void 0 ? {} : { "X-Upload-Expires": file.expiredAt.toString() },
-              ...file.modifiedAt === void 0 ? {} : { "Last-Modified": file.modifiedAt.toString() }
-            },
-            statusCode: 200
-          };
-        } catch (error) {
-          const errorWithCode = error;
-          if (errorWithCode.UploadErrorCode === ERRORS.FILE_NOT_FOUND || errorWithCode.UploadErrorCode === ERRORS.GONE) {
-            throw createHttpError(404, "File metadata not found");
-          }
-          throw error;
-        }
-      }
-      if (!uuidRegex.test(uuid)) {
-        return this.list(request, _response);
-      }
-      try {
-        const url = new URL(request.url || "", "http://localhost");
-        const queryParameters = Object.fromEntries(url.searchParams.entries());
-        const hasTransformationParameters = Object.keys(queryParameters).length > 0 && this.mediaTransformer;
-        if (hasTransformationParameters && this.mediaTransformer) {
-          try {
-            const transformedResult = await this.mediaTransformer.handle(uuid, queryParameters);
-            return {
-              content: transformedResult.buffer,
-              headers: {
-                "Content-Length": String(transformedResult.size),
-                "Content-Type": `${transformedResult.mediaType}/${transformedResult.format}`,
-                "X-Media-Type": transformedResult.mediaType,
-                "X-Original-Format": transformedResult.originalFile?.contentType?.split("/")[1] || "",
-                "X-Transformed-Format": transformedResult.format,
-                ...transformedResult.originalFile?.expiredAt === void 0 ? {} : { "X-Upload-Expires": transformedResult.originalFile.expiredAt.toString() },
-                ...transformedResult.originalFile?.modifiedAt === void 0 ? {} : { "Last-Modified": transformedResult.originalFile.modifiedAt.toString() },
-                ...transformedResult.originalFile?.ETag === void 0 ? {} : { ETag: transformedResult.originalFile.ETag }
-              },
-              statusCode: 200
-            };
-          } catch (transformError) {
-            if (transformError.name === "ValidationError") {
-              throw createHttpError(400, transformError.message);
-            }
-            this.logger?.warn(`Media transformation failed: ${transformError.message}`);
-          }
-        }
-        const fileMeta = await this.storage.getMeta(uuid);
-        const useStreaming = request.headers.range || fileMeta.size && fileMeta.size > 1024 * 1024;
-        if (useStreaming && this.storage.getStream) {
-          try {
-            const streamResult = await this.storage.getStream({ id: uuid });
-            let contentType2 = streamResult.headers?.["Content-Type"] || fileMeta.contentType;
-            if (contentType2.includes("image") && typeof ext === "string") {
-              contentType2 = mime.getType(ext) || contentType2;
-            }
-            return {
-              headers: {
-                ...streamResult.headers,
-                "Accept-Ranges": "bytes",
-                // Indicate we support range requests
-                "Content-Type": contentType2
-              },
-              size: streamResult.size,
-              statusCode: 200,
-              stream: streamResult.stream,
-              ...fileMeta,
-              contentType: contentType2
-            };
-          } catch (streamError) {
-            this.logger?.warn(`Streaming failed, falling back to buffer: ${streamError}`);
-          }
-        }
-        const file = await this.storage.get({ id: uuid });
-        let { contentType } = file;
-        if (contentType.includes("image") && typeof ext === "string") {
-          contentType = mime.getType(ext) || contentType;
-        }
-        const { ETag, expiredAt, modifiedAt, size } = file;
-        return {
-          headers: {
-            "Accept-Ranges": "bytes",
-            // Indicate we support range requests
-            "Content-Length": String(size),
-            "Content-Type": contentType,
-            ...expiredAt === void 0 ? {} : { "X-Upload-Expires": expiredAt.toString() },
-            ...modifiedAt === void 0 ? {} : { "Last-Modified": modifiedAt.toString() },
-            ...ETag === void 0 ? {} : { ETag }
-          },
-          statusCode: 200,
-          ...file,
-          contentType
-        };
-      } catch (error) {
-        const errorWithCode = error;
-        if (errorWithCode.UploadErrorCode === ERRORS.FILE_NOT_FOUND || errorWithCode.UploadErrorCode === ERRORS.GONE) {
-          throw createHttpError(404, "File not found");
-        }
-        throw error;
-      }
-    }
-    return this.list(request, _response);
-  }
-  /**
-   * Returns a list of uploaded files with optional pagination support.
-   * @param request Node.js IncomingMessage containing query parameters for pagination.
-   * @param _response Node.js ServerResponse (unused).
-   * @returns Promise resolving to a paginated or complete list of uploaded files.
-   */
-  async list(request, _response) {
-    const url = new URL(request.url || "", "http://localhost");
-    const limit = url.searchParams.get("limit");
-    const page = url.searchParams.get("page");
-    const list = await this.storage.list(Number(limit || 1e3));
-    if (list.length === 0) {
-      return {
-        data: [],
-        headers: {},
-        statusCode: 200
-      };
-    }
-    if (page !== void 0 && limit !== void 0) {
-      return {
-        data: paginate(Number(page), Number(limit), list.length, list),
-        headers: {},
-        statusCode: 200
-      };
-    }
-    return {
-      data: list,
-      headers: {},
-      statusCode: 200
-    };
-  }
-  /**
-   * Streams download of a file with resumable support using HTTP range requests.
-   * @param request Node.js IncomingMessage with optional originalUrl and range header.
-   * @param response Node.js ServerResponse to stream the file to.
-   * @throws {HttpError} When file is not found or streaming is not supported.
-   */
-  async download(request, response) {
-    const pathMatch = filePathUrlMatcher(getRealPath(request));
-    if (!pathMatch?.params.uuid || !uuidRegex.test(pathMatch.params.uuid)) {
-      throw createHttpError(404, "File not found");
-    }
-    const { ext, uuid } = pathMatch.params;
-    try {
-      const fileMeta = await this.storage.getMeta(uuid);
-      if (!this.storage.getStream) {
-        await this.sendError(response, createHttpError(501, "Streaming download not supported"));
-        return;
-      }
-      const streamResult = await this.storage.getStream({ id: uuid });
-      let contentType = streamResult.headers?.["Content-Type"] || fileMeta.contentType;
-      if (contentType.includes("image") && typeof ext === "string") {
-        contentType = mime.getType(ext) || contentType;
-      }
-      const range = this.parseRangeHeader(request.headers.range, streamResult.size || 0);
-      const headers = {
-        ...streamResult.headers,
-        "Accept-Ranges": "bytes",
-        "Content-Disposition": HeaderUtilities.createContentDisposition({
-          filename: fileMeta.originalName || uuid,
-          type: "attachment"
-        }),
-        "Content-Type": contentType
-      };
-      this.sendStream(response, streamResult.stream, {
-        headers,
-        range: range || void 0,
-        size: streamResult.size,
-        statusCode: range ? 206 : 200
-      });
-    } catch (error) {
-      const errorWithCode = error;
-      if (errorWithCode.UploadErrorCode === ERRORS.FILE_NOT_FOUND || errorWithCode.UploadErrorCode === ERRORS.GONE) {
-        await this.sendError(response, createHttpError(404, "File not found"));
-        return;
-      }
-      await this.sendError(response, error);
-    }
-  }
-  /**
-   * Check if error is related to undefined ID or path and throw appropriate HTTP error.
-   * @param error Error object to check
-   */
-  // eslint-disable-next-line class-methods-use-this
-  checkForUndefinedIdOrPath(error) {
-    if (error instanceof Error && ["Id is undefined", "Invalid request URL", "Path is undefined"].includes(error.message)) {
-      throw createHttpError(404, "File not found");
-    }
-  }
-}
-
-export { BaseHandlerNode as B };