@visulima/storage 1.0.0-alpha.9 → 1.0.1

package/dist/packem_shared/base-handler-core-BoAqTyz7.js

@@ -1,303 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { format } from 'node:url';
-import mime from 'mime';
-import { ErrorMap } from './ERRORS-D0apMqnc.js';
-import { H as HeaderUtilities } from './headers-YLRp1dLo.js';
-import { Readable } from 'node:stream';
-import 'type-is';
-
-const getLastOne = (value) => value.at(-1);
-
-const extractForwarded = (request) => {
-  let proto = "";
-  let host = "";
-  const header = getHeader(request, "forwarded");
-  if (header) {
-    const kvPairs = header.split(";");
-    kvPairs.forEach((kv) => {
-      const [token, value] = kv.split("=");
-      if (token === "proto") {
-        proto = value;
-      }
-      if (token === "host") {
-        host = value;
-      }
-    });
-  }
-  return { host, proto };
-};
-const readBody = (request, encoding = "utf8", limit) => new Promise((resolve, reject) => {
-  let body = "";
-  request.setEncoding(encoding);
-  request.on("data", (chunk) => {
-    if (body.length + chunk.length > limit) {
-      return reject(new Error("Request body length limit exceeded"));
-    }
-    body += chunk;
-  });
-  request.once("end", () => resolve(body));
-});
-const getHeader = (request, name, all = false) => {
-  const raw = request.headers?.[name.toLowerCase()];
-  if (!raw || raw.length === 0) {
-    return "";
-  }
-  if (all) {
-    return raw.toString().trim();
-  }
-  const array = Array.isArray(raw) ? raw : raw.split(",");
-  return getLastOne(array).trim();
-};
-const appendHeader = (response, name, value) => {
-  const s = [response.getHeader(name), value].flat().filter(Boolean).toString();
-  response.setHeader(name, s);
-};
-const setHeaders = (response, headers = {}) => {
-  const keys = Object.keys(headers);
-  if (keys.length > 0) {
-    appendHeader(response, "Access-Control-Expose-Headers", keys);
-  }
-  keys.forEach((key) => {
-    if (["link", "location"].includes(key.toLowerCase())) {
-      response.setHeader(key, encodeURI(headers[key].toString()));
-    } else {
-      response.setHeader(key, headers[key]);
-    }
-  });
-};
-const extractHost = (request) => getHeader(request, "host") || getHeader(request, "x-forwarded-host");
-const extractProto = (request) => getHeader(request, "x-forwarded-proto").toLowerCase();
-const getBaseUrl = (request) => {
-  let { host, proto } = extractForwarded(request);
-  host ||= extractHost(request);
-  proto ||= extractProto(request);
-  if (!host) {
-    return "";
-  }
-  return proto ? `${proto}://${host}` : `//${host}`;
-};
-const getRealPath = (request) => {
-  let realPath = (request.originalUrl || request.url || "").split("?")[0];
-  if (!realPath) {
-    throw new TypeError("Invalid request URL");
-  }
-  if (!realPath.startsWith("/")) {
-    realPath = `/${realPath}`;
-  }
-  if (realPath.startsWith("http")) {
-    const url = new URL(realPath);
-    realPath = url.pathname;
-  }
-  return realPath;
-};
-const uuidRegex = /(?:[\dA-Z]+-){2}[\dA-Z]+/i;
-const getIdFromRequest = (request) => {
-  const realPath = getRealPath(request);
-  const segments = realPath.split("/").filter(Boolean);
-  if (segments.length === 0) {
-    throw new Error("Invalid request URL");
-  }
-  for (let index = segments.length - 1; index >= 0; index -= 1) {
-    const segment = segments[index];
-    if (!segment) {
-      continue;
-    }
-    const cleanSegment = segment.replace(/\.[^/.]+$/, "");
-    const commonPathNames2 = ["files", "metadata", "upload", "download", "http-rest", "http-rest-chunked"];
-    if (commonPathNames2.includes(cleanSegment.toLowerCase())) {
-      continue;
-    }
-    if (uuidRegex.test(cleanSegment)) {
-      return cleanSegment;
-    }
-  }
-  const lastSegment = segments[segments.length - 1];
-  if (!lastSegment) {
-    throw new Error("Invalid request URL");
-  }
-  const cleanLastSegment = lastSegment.replace(/\.[^/.]+$/, "");
-  const commonPathNames = ["files", "metadata", "upload", "download", "http-rest", "http-rest-chunked"];
-  if (commonPathNames.includes(cleanLastSegment.toLowerCase())) {
-    throw new Error("Invalid request URL");
-  }
-  if (cleanLastSegment.length < 8) {
-    throw new Error("Invalid request URL");
-  }
-  if (segments.length > 1) {
-    return cleanLastSegment;
-  }
-  throw new Error("Invalid request URL");
-};
-const getRequestStream = (request) => {
-  if ("body" in request && request.body && typeof request.body.getReader === "function") {
-    return Readable.fromWeb(request.body);
-  }
-  if ("body" in request && request.body && request.body instanceof Uint8Array) {
-    return Readable.from(Buffer.from(request.body));
-  }
-  if (request instanceof Readable) {
-    return request;
-  }
-  return Readable.from(new Uint8Array(0));
-};
-
-const pick = (object, whitelist) => {
-  const result = {};
-  whitelist.forEach((key) => {
-    result[key] = object[key];
-  });
-  return result;
-};
-
-class BaseHandlerCore extends EventEmitter {
-  /**
-   * Response body type for the handler.
-   */
-  responseType = "json";
-  /**
-   * Storage instance for file operations.
-   */
-  storage;
-  /**
-   * Optional media transformer for image/video processing.
-   */
-  mediaTransformer;
-  /**
-   * Whether to disable termination for finished uploads.
-   */
-  disableTerminationForFinishedUploads;
-  /**
-   * Logger instance for debugging and error reporting.
-   */
-  logger;
-  /**
-   * Gets the logger instance.
-   * @returns Logger instance or undefined.
-   */
-  get loggerInstance() {
-    return this.logger;
-  }
-  /**
-   * Internal error responses configuration.
-   */
-  internalErrorResponses = {};
-  /**
-   * Gets the error responses configuration.
-   * @returns Error responses configuration.
-   */
-  get errorResponses() {
-    return this.internalErrorResponses;
-  }
-  constructor({ disableTerminationForFinishedUploads, mediaTransformer, storage }) {
-    super();
-    this.storage = storage;
-    this.mediaTransformer = mediaTransformer;
-    this.disableTerminationForFinishedUploads = disableTerminationForFinishedUploads;
-    this.logger = this.storage?.logger;
-    this.assembleErrors();
-  }
-  /**
-   * Sets custom error responses.
-   * @param value Partial error responses to override defaults.
-   */
-  set errorResponses(value) {
-    this.assembleErrors(value);
-  }
-  /**
-   * Assemble error responses by merging defaults with custom overrides.
-   * @param customErrors Custom error responses to override defaults
-   */
-  assembleErrors = (customErrors = {}) => {
-    this.internalErrorResponses = {
-      ...ErrorMap,
-      ...this.internalErrorResponses,
-      ...this.storage.errorResponses,
-      ...customErrors
-    };
-  };
-  /**
-   * Parses HTTP Range header and returns start/end byte positions for partial content requests.
-   * @param rangeHeader HTTP Range header value (e.g., "bytes=0-1023").
-   * @param fileSize Total size of the file in bytes.
-   * @returns Object with start and end positions, or undefined if range is invalid.
-   */
-  // eslint-disable-next-line class-methods-use-this
-  parseRangeHeader(rangeHeader, fileSize) {
-    if (!rangeHeader || !rangeHeader.startsWith("bytes=")) {
-      return void 0;
-    }
-    const ranges = rangeHeader.slice(6).split(",");
-    if (ranges.length !== 1) {
-      return void 0;
-    }
-    const range = ranges[0]?.trim();
-    if (!range) {
-      return void 0;
-    }
-    const parts = range.split("-");
-    if (parts.length !== 2) {
-      return void 0;
-    }
-    const [startString, endString] = parts;
-    let start;
-    let end;
-    if (startString && endString) {
-      start = Number.parseInt(startString, 10);
-      end = Number.parseInt(endString, 10);
-    } else if (startString && !endString) {
-      start = Number.parseInt(startString, 10);
-      end = fileSize - 1;
-    } else if (!startString && endString) {
-      const suffixLength = Number.parseInt(endString, 10);
-      start = Math.max(0, fileSize - suffixLength);
-      end = fileSize - 1;
-    } else {
-      return void 0;
-    }
-    if (Number.isNaN(start) || Number.isNaN(end) || start >= fileSize || end >= fileSize || start > end) {
-      return void 0;
-    }
-    return { end, start };
-  }
-  /**
-   * Build file URL from request and file data.
-   * Platform-agnostic version that accepts URL string.
-   * @param requestUrl Request URL string
-   * @param file File object containing ID and content type
-   * @returns Constructed file URL with extension based on content type
-   */
-  buildFileUrlFromString(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 });
-    const baseUrl = this.storage.config.useRelativeLocation ? "" : getBaseUrl({ });
-    return `${baseUrl}${relative}.${mime.getExtension(file.contentType)}`;
-  }
-  /**
-   * Negotiates content type based on Accept header and supported formats.
-   * Platform-agnostic version that accepts header string.
-   * @param acceptHeader Accept header value
-   * @param supportedTypes Array of supported MIME types to match against
-   * @returns Best matching content type or undefined if no match found
-   */
-  // eslint-disable-next-line class-methods-use-this
-  negotiateContentTypeFromHeader(acceptHeader, supportedTypes) {
-    if (!acceptHeader) {
-      return void 0;
-    }
-    return HeaderUtilities.getPreferredMediaType(acceptHeader, supportedTypes);
-  }
-  /**
-   * Check for undefined ID or path errors and throw appropriate HTTP errors.
-   * @param error The error 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 error;
-    }
-  }
-}
-
-export { BaseHandlerCore as B, getHeader as a, getRequestStream as b, getBaseUrl as c, getRealPath as d, getIdFromRequest as g, pick as p, readBody as r, setHeaders as s, uuidRegex as u };

package/dist/packem_shared/base-handler-fetch-D4u2xits.js

@@ -1,291 +0,0 @@
-import { H as HeaderUtilities, h as httpErrorsExports } from './headers-YLRp1dLo.js';
-import { ERRORS, isUploadError } from './ERRORS-D0apMqnc.js';
-import { B as BaseHandlerCore, p as pick } from './base-handler-core-BoAqTyz7.js';
-import { i as isValidationError } from './validator-BeX_lJet.js';
-import { waitForStorage } from './waitForStorage-Cscw85sx.js';
-
-class BaseHandlerFetch 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 Web API Fetch requests (for Hono, Cloudflare Workers, etc.).
-   * @param request Web API Request object.
-   * @returns Promise resolving to Web API Response.
-   */
-  async fetch(request) {
-    this.logger?.debug("[fetch request]: %s %s", request.method, request.url);
-    const handler = this.registeredHandlers.get(request.method || "GET");
-    if (!handler) {
-      return this.createErrorResponse({ UploadErrorCode: ERRORS.METHOD_NOT_ALLOWED });
-    }
-    try {
-      await waitForStorage(this.storage);
-    } catch {
-      return this.createErrorResponse({ UploadErrorCode: ERRORS.STORAGE_ERROR });
-    }
-    try {
-      const file = await handler.call(this, request);
-      return this.handleFetchResponse(request, file);
-    } catch (error) {
-      const errorObject = error instanceof Error ? error : new Error(String(error));
-      const uError = pick(errorObject, ["name", ...Object.getOwnPropertyNames(errorObject)]);
-      const errorEvent = {
-        ...uError,
-        request: {
-          headers: Object.fromEntries(request.headers.entries()),
-          method: request.method,
-          url: request.url
-        }
-      };
-      if (this.listenerCount("error") > 0) {
-        this.emit("error", errorEvent);
-      }
-      this.logger?.error("[fetch error]: %O", errorEvent);
-      return this.createErrorResponse(errorObject);
-    }
-  }
-  /**
-   * Handle the response from handlers for fetch requests and convert to Web API Response.
-   * @param request Web API Request object
-   * @param file Response file or list from handler
-   * @returns Promise resolving to Web API Response object
-   */
-  async handleFetchResponse(request, file) {
-    if (request.method === "HEAD" || request.method === "OPTIONS") {
-      const { headers: headers2, statusCode: statusCode2 } = file;
-      return new Response(void 0, {
-        headers: this.convertHeaders({
-          ...headers2,
-          "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"
-        }),
-        status: statusCode2
-      });
-    }
-    if (request.method === "GET") {
-      const { headers: headers2, statusCode: statusCode2 } = file;
-      let body = "";
-      if (file.content !== void 0) {
-        body = new Uint8Array(file.content);
-      } else if (typeof file === "object" && "data" in file) {
-        body = JSON.stringify(file.data);
-      }
-      return new Response(body, {
-        headers: this.convertHeaders({
-          ...headers2,
-          "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"
-        }),
-        status: statusCode2
-      });
-    }
-    const { headers, statusCode, ...basicFile } = file;
-    if (basicFile.status !== void 0 && this.listenerCount(basicFile.status) > 0) {
-      this.emit(basicFile.status, {
-        ...basicFile,
-        request: {
-          headers: Object.fromEntries(request.headers.entries()),
-          method: request.method,
-          url: request.url
-        }
-      });
-    }
-    if (basicFile.status === "completed") {
-      const responseFile = file;
-      if (responseFile.headers === void 0) {
-        responseFile.headers = {};
-      }
-      if (responseFile.statusCode === void 0) {
-        responseFile.statusCode = 200;
-      }
-      try {
-        await this.storage.onComplete(basicFile, responseFile);
-      } catch (error) {
-        this.logger?.error("[onComplete error]: %O", error);
-        throw error;
-      }
-      const { headers: responseFileHeaders2, statusCode: responseFileStatusCode, ...fileData } = responseFile;
-      const { content, stream, ...cleanFileData } = fileData;
-      return this.createResponse({
-        body: cleanFileData,
-        headers: responseFileHeaders2 || headers,
-        statusCode: responseFileStatusCode || statusCode || 200
-      });
-    }
-    const allHeaders = {
-      ...headers,
-      ...file.headers
-    };
-    const convertedHeaders = this.convertHeaders({
-      ...allHeaders,
-      "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",
-      ...basicFile.hash === void 0 ? {} : { [`X-Range-${basicFile.hash?.algorithm.toUpperCase()}`]: basicFile.hash?.value }
-    });
-    const responseFileHeaders = file.headers || {};
-    if (responseFileHeaders.Location && !convertedHeaders.location && !convertedHeaders.Location) {
-      convertedHeaders.location = String(responseFileHeaders.Location);
-    } else if (responseFileHeaders.location && !convertedHeaders.location && !convertedHeaders.Location) {
-      convertedHeaders.location = String(responseFileHeaders.location);
-    } else if (headers.Location && !convertedHeaders.location && !convertedHeaders.Location) {
-      convertedHeaders.location = String(headers.Location);
-    } else if (headers.location && !convertedHeaders.location && !convertedHeaders.Location) {
-      convertedHeaders.location = String(headers.location);
-    }
-    let responseBody;
-    if (statusCode >= 200 && statusCode < 300) {
-      responseBody = Object.keys(basicFile).length > 0 ? { ...basicFile } : {};
-      if ("content" in responseBody) {
-        delete responseBody.content;
-      }
-      if ("stream" in responseBody) {
-        delete responseBody.stream;
-      }
-      if (Object.keys(responseBody).length === 0) {
-        responseBody = {};
-      }
-    }
-    return this.createResponse({
-      body: responseBody,
-      headers: convertedHeaders,
-      statusCode: statusCode || 200
-    });
-  }
-  /**
-   * Convert headers to Web API Headers format by flattening arrays and converting to strings.
-   * @param headers Headers object with potentially array values
-   * @returns Headers object with all values as strings
-   */
-  // eslint-disable-next-line class-methods-use-this
-  convertHeaders(headers) {
-    const result = {};
-    for (const [key, value] of Object.entries(headers)) {
-      result[key] = Array.isArray(value) ? value.join(", ") : String(value);
-    }
-    return result;
-  }
-  /**
-   * Create Web API Response from UploadResponse object.
-   * @param uploadResponse Upload response containing body, headers, and status code
-   * @returns Web API Response object
-   */
-  createResponse(uploadResponse) {
-    const { body, headers = {}, statusCode } = uploadResponse;
-    let responseBody;
-    if (statusCode === 204) {
-      responseBody = null;
-    } else if (typeof body === "string") {
-      responseBody = body;
-    } else if (body instanceof Buffer) {
-      responseBody = new Uint8Array(body);
-    } else if (body && typeof body === "object") {
-      responseBody = JSON.stringify(body);
-      if (!headers["Content-Type"]) {
-        headers["Content-Type"] = HeaderUtilities.createContentType({
-          charset: "utf8",
-          mediaType: "application/json"
-        });
-      }
-    } else if (body === void 0 && statusCode !== void 0 && statusCode >= 200 && statusCode < 300) {
-      responseBody = "{}";
-      if (!headers["Content-Type"]) {
-        headers["Content-Type"] = HeaderUtilities.createContentType({
-          charset: "utf8",
-          mediaType: "application/json"
-        });
-      }
-    }
-    return new Response(responseBody, {
-      headers: this.convertHeaders(headers),
-      status: statusCode
-    });
-  }
-  /**
-   * Create error Response from Error object with appropriate status code and message.
-   * @param error Error object to convert to HTTP error response
-   * @returns Web API Response object with error details
-   */
-  async createErrorResponse(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
-      };
-    }
-    return this.createResponse(errorResponse);
-  }
-  /**
-   * Build file URL from request and file data.
-   * @param request Web API Request object
-   * @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.url, file);
-  }
-  /**
-   * Negotiates content type based on Accept header and supported formats.
-   * @param request Web API 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.get("accept") || void 0, supportedTypes);
-  }
-}
-
-export { BaseHandlerFetch as B };