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

package/dist/packem_shared/TUS_RESUMABLE-Dtfsffnj.js

@@ -1,434 +0,0 @@
-import { c as createHttpError, H as HeaderUtilities } from './headers-YLRp1dLo.js';
-import { Metadata } from './Metadata-DRLXeJ0F.js';
-
-const TUS_RESUMABLE_VERSION = "1.0.0";
-const TUS_VERSION_VERSION = "1.0.0";
-const parseMetadata = (encoded = "") => {
-  const kvPairs = encoded.split(",").map((kv) => kv.split(" "));
-  const metadata = Object.create(Metadata.prototype);
-  Object.values(kvPairs).forEach(([key, value]) => {
-    if (key) {
-      metadata[key] = value ? Buffer.from(value, "base64").toString() : "";
-    }
-  });
-  return metadata;
-};
-const serializeMetadata = (object) => {
-  if (!object || Object.keys(object).length === 0) {
-    return "";
-  }
-  return Object.entries(object).map(([key, value]) => {
-    if (value === void 0) {
-      return key;
-    }
-    return `${key} ${Buffer.from(String(value)).toString("base64")}`;
-  }).toString();
-};
-class TusBase {
-  /**
-   * Storage instance for file operations.
-   */
-  // eslint-disable-next-line class-methods-use-this
-  get storage() {
-    throw new Error("storage must be implemented");
-  }
-  /**
-   * Build file URL from request URL and file data.
-   * @param _requestUrl Request URL string
-   * @param _file File object containing ID
-   * @returns Constructed file URL for TUS protocol
-   */
-  // eslint-disable-next-line class-methods-use-this
-  buildFileUrl(_requestUrl, _file) {
-    throw new Error("buildFileUrl must be implemented");
-  }
-  /**
-   * Handle OPTIONS request with TUS protocol capabilities.
-   * @param methods Array of supported HTTP methods
-   * @returns ResponseFile with TUS headers
-   */
-  handleOptions(methods) {
-    const headers = {
-      "Access-Control-Allow-Headers": "Authorization, Content-Type, Location, Tus-Extension, Tus-Max-Size, Tus-Resumable, Tus-Version, Upload-Concat, Upload-Defer-Length, Upload-Length, Upload-Metadata, Upload-Offset, X-HTTP-Method-Override, X-Requested-With",
-      "Access-Control-Allow-Methods": methods.map((method) => method.toUpperCase()).join(", "),
-      "Access-Control-Max-Age": 86400,
-      "Tus-Checksum-Algorithm": this.storage.checksumTypes.join(","),
-      "Tus-Extension": this.storage.tusExtension.toString(),
-      "Tus-Max-Size": this.storage.maxUploadSize,
-      "Tus-Version": TUS_VERSION_VERSION
-    };
-    return { headers, statusCode: 204 };
-  }
-  /**
-   * Handle TUS POST (create upload).
-   * @param uploadLength Upload length header value
-   * @param uploadDeferLength Upload defer length header value
-   * @param uploadConcat Upload concat header value
-   * @param metadataHeader Upload metadata header value
-   * @param requestUrl Request URL for Location header
-   * @param bodyStream Request body stream (for creation-with-upload)
-   * @param contentLength Content length (for creation-with-upload)
-   * @param contentType Content type (for creation-with-upload)
-   * @returns Promise resolving to ResponseFile with upload result
-   */
-  async handlePost(uploadLength, uploadDeferLength, uploadConcat, metadataHeader, requestUrl, bodyStream, contentLength, contentType) {
-    if (uploadDeferLength !== void 0) {
-      if (!this.storage.tusExtension.includes("creation-defer-length")) {
-        throw createHttpError(501, "creation-defer-length extension is not (yet) supported.");
-      }
-      if (uploadLength === void 0) {
-        const metadata2 = metadataHeader ? parseMetadata(metadataHeader) : {};
-        const config2 = { metadata: metadata2 };
-        let file2 = await this.storage.create(config2);
-        if (contentType === "application/offset+octet-stream" && contentLength > 0) {
-          file2 = await this.storage.write({
-            ...file2,
-            body: bodyStream,
-            contentLength,
-            start: 0
-          });
-        }
-        let headers2 = {};
-        if (this.storage.tusExtension.includes("expiration") && typeof file2.expiredAt === "number" && file2.size === void 0) {
-          headers2 = { "Upload-Expires": new Date(file2.expiredAt).toUTCString() };
-        }
-        const locationUrl2 = this.buildFileUrl(requestUrl, file2);
-        headers2 = { ...headers2, ...this.buildHeaders(file2, { Location: locationUrl2 }) };
-        if (!headers2.Location) {
-          headers2.Location = locationUrl2;
-        }
-        if (file2.bytesWritten > 0) {
-          headers2["Upload-Offset"] = file2.bytesWritten.toString();
-        }
-        headers2["Upload-Defer-Length"] = "1";
-        const statusCode2 = file2.bytesWritten > 0 ? 200 : 201;
-        return { ...file2, headers: headers2, statusCode: statusCode2 };
-      }
-    }
-    if (uploadConcat) {
-      if (!this.storage.tusExtension.includes("concatenation")) {
-        throw createHttpError(501, "Concatenation extension is not (yet) supported. Disable parallel upload in the tus client.");
-      }
-      const parsedMetadata = metadataHeader ? parseMetadata(metadataHeader) : {};
-      if (uploadConcat === "partial") {
-        const config2 = {
-          metadata: { ...parsedMetadata, uploadConcat: "partial" },
-          size: uploadLength
-        };
-        let file2 = await this.storage.create(config2);
-        if (contentType === "application/offset+octet-stream" && contentLength > 0) {
-          file2 = await this.storage.write({
-            ...file2,
-            body: bodyStream,
-            contentLength,
-            start: 0
-          });
-        }
-        let headers2 = {};
-        if (this.storage.tusExtension.includes("expiration") && typeof file2.expiredAt === "number" && file2.bytesWritten !== (file2.size ?? 0)) {
-          headers2 = { "Upload-Expires": new Date(file2.expiredAt).toUTCString() };
-        }
-        const locationUrl2 = this.buildFileUrl(requestUrl, file2);
-        headers2 = { ...headers2, ...this.buildHeaders(file2, { Location: locationUrl2 }) };
-        if (!headers2.Location) {
-          headers2.Location = locationUrl2;
-        }
-        if (file2.bytesWritten > 0) {
-          headers2["Upload-Offset"] = file2.bytesWritten.toString();
-        }
-        headers2["Upload-Concat"] = "partial";
-        const statusCode2 = file2.bytesWritten > 0 ? 200 : 201;
-        return { ...file2, headers: headers2, statusCode: statusCode2 };
-      }
-      if (uploadConcat.startsWith("final;")) {
-        const partialIds = uploadConcat.slice(6).trim().split(/\s+/).filter(Boolean);
-        if (partialIds.length === 0) {
-          throw createHttpError(400, "Upload-Concat final must include at least one partial upload ID");
-        }
-        let totalSize = 0;
-        const partialFiles = [];
-        for (const partialId of partialIds) {
-          try {
-            const partialFile = await this.storage.getMeta(partialId);
-            await this.storage.checkIfExpired(partialFile);
-            if (partialFile.metadata?.uploadConcat !== "partial") {
-              throw createHttpError(400, `Upload ${partialId} is not a partial upload`);
-            }
-            if (partialFile.status !== "completed" || partialFile.size === void 0) {
-              throw createHttpError(409, `Partial upload ${partialId} is not completed`);
-            }
-            partialFiles.push(partialFile);
-            totalSize += partialFile.size;
-          } catch (error) {
-            const errorWithCode = error;
-            if (errorWithCode.statusCode === 404 || errorWithCode.statusCode === 410) {
-              throw createHttpError(409, `Partial upload ${partialId} not found or expired`);
-            }
-            throw error;
-          }
-        }
-        const config2 = {
-          metadata: {
-            ...parsedMetadata,
-            partialIds,
-            uploadConcat: `final;${partialIds.join(" ")}`
-          },
-          size: totalSize
-        };
-        const file2 = await this.storage.create(config2);
-        await this.concatenateFiles(file2, partialFiles);
-        const locationUrl2 = this.buildFileUrl(requestUrl, file2);
-        const headers2 = {
-          ...this.buildHeaders(file2, { Location: locationUrl2 }),
-          "Upload-Concat": uploadConcat
-        };
-        return { ...file2, headers: headers2, statusCode: 201 };
-      }
-      throw createHttpError(400, "Invalid Upload-Concat header format");
-    }
-    if (uploadLength === void 0 && uploadDeferLength === void 0) {
-      throw createHttpError(400, "Either upload-length or upload-defer-length must be specified.");
-    }
-    if (uploadLength !== void 0 && Number.isNaN(Number(uploadLength))) {
-      throw createHttpError(400, "Invalid upload-length");
-    }
-    const metadata = metadataHeader ? parseMetadata(metadataHeader) : {};
-    const config = { metadata, size: uploadLength };
-    let file = await this.storage.create(config);
-    if (contentType === "application/offset+octet-stream" && contentLength > 0) {
-      file = await this.storage.write({
-        ...file,
-        body: bodyStream,
-        contentLength,
-        start: 0
-      });
-    }
-    let headers = {};
-    if (this.storage.tusExtension.includes("expiration") && typeof file.expiredAt === "number" && file.bytesWritten !== Number.parseInt(uploadLength, 10)) {
-      headers = { "Upload-Expires": new Date(file.expiredAt).toUTCString() };
-    }
-    const locationUrl = this.buildFileUrl(requestUrl, file);
-    headers = { ...headers, ...this.buildHeaders(file, { Location: locationUrl }) };
-    if (!headers.Location) {
-      headers.Location = locationUrl;
-    }
-    if (file.bytesWritten > 0) {
-      headers["Upload-Offset"] = file.bytesWritten.toString();
-    }
-    const statusCode = file.bytesWritten > 0 ? 200 : 201;
-    return { ...file, headers, statusCode };
-  }
-  /**
-   * Handle TUS PATCH (write chunk).
-   * @param id File ID from URL
-   * @param uploadOffset Upload offset header value
-   * @param uploadLength Optional upload length header value (for defer-length)
-   * @param metadataHeader Optional upload metadata header value
-   * @param checksum Optional checksum
-   * @param checksumAlgorithm Optional checksum algorithm
-   * @param requestUrl Request URL for Location header
-   * @param bodyStream Request body stream
-   * @param contentLength Content length
-   * @returns Promise resolving to ResponseFile with upload progress
-   */
-  async handlePatch(id, uploadOffset, uploadLength, metadataHeader, checksum, checksumAlgorithm, _requestUrl, bodyStream, contentLength) {
-    const metadata = metadataHeader ? parseMetadata(metadataHeader) : void 0;
-    if (metadata) {
-      try {
-        await this.storage.update({ id }, { id, metadata });
-      } catch (error) {
-        const errorWithCode = error;
-        if (errorWithCode.UploadErrorCode === "FILE_NOT_FOUND") {
-          throw createHttpError(410, "Upload expired");
-        }
-        throw error;
-      }
-    }
-    let currentFile;
-    try {
-      currentFile = await this.storage.getMeta(id);
-      await this.storage.checkIfExpired(currentFile);
-    } catch (error) {
-      const errorWithCode = error;
-      if (errorWithCode.UploadErrorCode === "GONE" || errorWithCode.UploadErrorCode === "FILE_NOT_FOUND") {
-        throw createHttpError(410, "Upload expired");
-      }
-      throw error;
-    }
-    const uploadConcatValue = currentFile.metadata?.uploadConcat;
-    if (typeof uploadConcatValue === "string" && uploadConcatValue.startsWith("final;")) {
-      throw createHttpError(403, "Cannot PATCH a final concatenation upload");
-    }
-    let file = await this.storage.write({
-      body: bodyStream,
-      checksum,
-      checksumAlgorithm,
-      contentLength,
-      id,
-      start: uploadOffset
-    });
-    if (uploadLength !== void 0) {
-      if (!this.storage.tusExtension.includes("creation-defer-length")) {
-        throw createHttpError(501, "creation-defer-length extension is not (yet) supported.");
-      }
-      if (file.size !== void 0 && !Number.isNaN(file.size)) {
-        throw createHttpError(412, "Upload-Length has already been set for this upload");
-      }
-      const size = Number.parseInt(uploadLength, 10);
-      if (Number.isNaN(size)) {
-        throw createHttpError(400, "Invalid Upload-Length value");
-      }
-      if (size < file.bytesWritten) {
-        throw createHttpError(400, "Upload-Length is smaller than the current offset");
-      }
-      file = await this.storage.update({ id }, { size });
-      if (file.bytesWritten === file.size) {
-        file = { ...file, status: "completed" };
-      }
-    }
-    return {
-      ...file,
-      headers: this.buildHeaders(file, {
-        "Upload-Offset": file.bytesWritten
-      }),
-      statusCode: file.status === "completed" ? 200 : 204
-    };
-  }
-  /**
-   * Handle TUS HEAD (get upload status).
-   * @param id File ID from URL
-   * @returns Promise resolving to ResponseFile with upload status headers
-   */
-  async handleHead(id) {
-    const file = await this.storage.getMeta(id);
-    await this.storage.checkIfExpired(file);
-    const headers = {
-      ...typeof file.size === "number" && !Number.isNaN(file.size) ? {
-        "Upload-Length": file.size
-      } : {
-        "Upload-Defer-Length": "1"
-      },
-      ...this.buildHeaders(file, {
-        "Cache-Control": HeaderUtilities.createCacheControlPreset("no-store"),
-        "Upload-Metadata": serializeMetadata(file.metadata),
-        "Upload-Offset": file.bytesWritten
-      })
-    };
-    const uploadConcatValue = file.metadata?.uploadConcat;
-    if (typeof uploadConcatValue === "string") {
-      headers["Upload-Concat"] = uploadConcatValue;
-    }
-    return { headers, statusCode: 200 };
-  }
-  /**
-   * Handle TUS GET (get upload metadata).
-   * @param id File ID from URL
-   * @returns Promise resolving to ResponseFile with file metadata as JSON
-   */
-  async handleGet(id) {
-    const file = await this.storage.getMeta(id);
-    return {
-      ...file,
-      body: file,
-      // Return file metadata as JSON
-      headers: this.buildHeaders(file, {
-        "Content-Type": HeaderUtilities.createContentType({
-          mediaType: "application/json"
-        })
-      }),
-      statusCode: 200
-    };
-  }
-  /**
-   * Handle TUS DELETE (terminate upload).
-   * @param id File ID from URL
-   * @returns Promise resolving to ResponseFile with deletion confirmation
-   */
-  async handleDelete(id) {
-    if (this.disableTerminationForFinishedUploads) {
-      const file2 = await this.storage.getMeta(id);
-      if (file2.status === "completed") {
-        throw createHttpError(400, "Termination of finished uploads is disabled");
-      }
-    }
-    const file = await this.storage.delete({ id });
-    if (file.status === void 0) {
-      throw createHttpError(404, "File not found");
-    }
-    return {
-      ...file,
-      headers: this.buildHeaders(file),
-      statusCode: 204
-    };
-  }
-  /**
-   * Build TUS protocol headers including required Tus-Resumable and optional Upload-Expires.
-   * @param file Upload file object with metadata
-   * @param headers Additional headers to include
-   * @returns Headers object with TUS protocol headers
-   */
-  buildHeaders(file, headers = {}) {
-    headers["Tus-Resumable"] = TUS_RESUMABLE_VERSION;
-    if (this.storage.tusExtension.includes("expiration") && file.expiredAt !== void 0) {
-      headers["Upload-Expires"] = new Date(file.expiredAt).toUTCString();
-    }
-    return headers;
-  }
-  /**
-   * Extract checksum algorithm and value from Upload-Checksum header.
-   * @param checksumHeader Upload-Checksum header value
-   * @returns Object containing checksum algorithm and value
-   */
-  // eslint-disable-next-line class-methods-use-this
-  extractChecksum(checksumHeader) {
-    if (!checksumHeader) {
-      return { checksum: void 0, checksumAlgorithm: void 0 };
-    }
-    const [checksumAlgorithm, checksum] = checksumHeader.split(/\s+/).filter(Boolean);
-    return { checksum, checksumAlgorithm };
-  }
-  /**
-   * Validate Tus-Resumable header value.
-   * @param tusResumable Tus-Resumable header value
-   * @throws {Error} 412 if version doesn't match or header is missing
-   */
-  // eslint-disable-next-line class-methods-use-this
-  validateTusResumableHeader(tusResumable) {
-    if (!tusResumable) {
-      throw createHttpError(412, "Missing Tus-Resumable header");
-    }
-    if (tusResumable !== TUS_RESUMABLE_VERSION) {
-      throw createHttpError(412, `Unsupported TUS version: ${tusResumable}. Server supports: ${TUS_RESUMABLE_VERSION}`);
-    }
-  }
-  /**
-   * Concatenate partial uploads into a final upload.
-   * @param finalFile Final file that will contain concatenated content
-   * @param partialFiles Array of partial upload files to concatenate
-   * @returns Promise resolving when concatenation is complete
-   */
-  async concatenateFiles(finalFile, partialFiles) {
-    let offset = 0;
-    for (const partialFile of partialFiles) {
-      if (!this.storage.getStream) {
-        throw createHttpError(501, "getStream is not supported by this storage backend");
-      }
-      const { size, stream } = await this.storage.getStream({ id: partialFile.id });
-      if (size === void 0) {
-        throw createHttpError(500, "Partial upload size is undefined");
-      }
-      const updatedFile = await this.storage.write({
-        ...finalFile,
-        body: stream,
-        contentLength: size,
-        start: offset
-      });
-      Object.assign(finalFile, updatedFile);
-      offset += size;
-    }
-  }
-}
-const TUS_RESUMABLE = TUS_RESUMABLE_VERSION;
-const TUS_VERSION = TUS_VERSION_VERSION;
-
-export { TUS_RESUMABLE, TUS_VERSION, TusBase, parseMetadata, serializeMetadata };

package/dist/packem_shared/Tus-Ck0Hdle5.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-lVB-D59L.js';
-import { B as BaseHandlerNode } from './base-handler-node-BiO2DF87.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 };