@visulima/storage 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/handler/http/hono/index.js

@@ -1,65 +1 @@
-import Multipart from '../../../packem_shared/Multipart-CNFK_Okz.js';
-import RestFetch from '../../../packem_shared/Rest-CAOAEkOj.js';
-import { Tus } from '../../../packem_shared/Tus-B8PmlMgR.js';
-
-const createHandlerFunction = (handler) => async (c) => {
-  try {
-    const request = c.req.raw;
-    return await handler.fetch(request);
-  } catch (error) {
-    const errorObject = error;
-    const statusCode = errorObject.statusCode || (errorObject.status ? Number.parseInt(errorObject.status, 10) : void 0) || 500;
-    return Response.json({ error: errorObject.message || "Request failed" }, { status: statusCode });
-  }
-};
-const createStorageHandler = (app, config) => {
-  const { path, type, ...handlerConfig } = config;
-  let handler;
-  switch (type) {
-    case "multipart": {
-      handler = new Multipart(handlerConfig);
-      break;
-    }
-    case "rest": {
-      handler = new RestFetch(handlerConfig);
-      break;
-    }
-    case "tus": {
-      handler = new Tus(handlerConfig);
-      break;
-    }
-    default: {
-      throw new Error(`Unknown handler type: ${String(type ?? "unknown")}`);
-    }
-  }
-  const handlerFunction = createHandlerFunction(handler);
-  switch (type) {
-    case "multipart": {
-      app.post(path, handlerFunction);
-      app.get(`${path}/:id?/:metadata?`, handlerFunction);
-      app.delete(`${path}/:id`, handlerFunction);
-      app.on("OPTIONS", path, handlerFunction);
-      break;
-    }
-    case "rest": {
-      app.post(path, handlerFunction);
-      app.put(`${path}/:id`, handlerFunction);
-      app.patch(`${path}/:id`, handlerFunction);
-      app.get(`${path}/:id?`, handlerFunction);
-      app.on("HEAD", `${path}/:id`, handlerFunction);
-      app.delete(`${path}/:id?`, handlerFunction);
-      app.on("OPTIONS", path, handlerFunction);
-      break;
-    }
-    case "tus": {
-      app.all(path, handlerFunction);
-      app.all(`${path}/:id`, handlerFunction);
-      break;
-    }
-    default: {
-      throw new Error(`Unknown handler type: ${String(type)}`);
-    }
-  }
-};
-
-export { createStorageHandler };
+var d=Object.defineProperty;var c=(t,n)=>d(t,"name",{value:n,configurable:!0});import u from"../../../packem_shared/Multipart-Bd9YFFn0.js";import l from"../../../packem_shared/Rest-DoonVU7B.js";import{Tus as p}from"../../../packem_shared/Tus-Bd_2Ki2G.js";var w=Object.defineProperty,i=c((t,n)=>w(t,"name",{value:n,configurable:!0}),"a");const m=i(t=>async n=>{try{const e=n.req.raw;return await t.fetch(e)}catch(e){const a=e,s=a.statusCode||(a.status?Number.parseInt(a.status,10):void 0)||500;return Response.json({error:a.message||"Request failed"},{status:s})}},"createHandlerFunction"),g=i((t,n)=>{const{path:e,type:a,...s}=n;let o;switch(a){case"multipart":{o=new u(s);break}case"rest":{o=new l(s);break}case"tus":{o=new p(s);break}default:throw new Error(`Unknown handler type: ${String(a??"unknown")}`)}const r=m(o);switch(a){case"multipart":{t.post(e,r),t.get(`${e}/:id?/:metadata?`,r),t.delete(`${e}/:id`,r),t.on("OPTIONS",e,r);break}case"rest":{t.post(e,r),t.put(`${e}/:id`,r),t.patch(`${e}/:id`,r),t.get(`${e}/:id?`,r),t.on("HEAD",`${e}/:id`,r),t.delete(`${e}/:id?`,r),t.on("OPTIONS",e,r);break}case"tus":{t.all(e,r),t.all(`${e}/:id`,r);break}default:throw new Error(`Unknown handler type: ${String(a)}`)}},"createStorageHandler");export{g as createStorageHandler};

package/dist/handler/http/nextjs/index.d.ts

@@ -1,61 +1,69 @@
-import type { NextRequest } from "next/server";
-import { NextResponse } from "next/server";
-import type { UploadFile } from "../../../storage/utils/index.d.ts";
-import type { UploadOptions } from "../../types.d.ts";
+import { NextRequest, NextResponse } from 'next/server.js';
+import { U as UploadFile } from "../../../packem_shared/storage.d-Cxs42eEK.js";
+import 'node:stream';
+import { U as UploadOptions } from "../../../packem_shared/types.d-LqXtPPaF.js";
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import 'node:events';
+import '@visulima/pagination';
+import "../../../packem_shared/media-transformer.d-CLxm_69K.js";
+import "../../../packem_shared/types.d-76N78ehR.js";
 /**
- * Configuration for Next.js handler.
- */
-export interface NextjsHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
-    /** Handler type to use */
-    type: "multipart" | "rest" | "tus";
+* Configuration for Next.js handler.
+*/
+interface NextjsHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
+  /** Handler type to use */
+  type: "multipart" | "rest" | "tus";
 }
 /**
- * Next.js route handler that automatically exports the correct HTTP methods for each handler type.
- * @example
- * ```ts
- * // app/api/upload/multipart/route.ts
- * import { DiskStorage } from "@visulima/storage";
- * import { createHandler } from "@visulima/storage/handler/http/nextjs";
- *
- * const storage = new DiskStorage({ directory: "./uploads" });
- * const handler = createHandler({ storage, type: "multipart" });
- *
- * export const POST = handler;
- * export const DELETE = handler;
- * export const GET = handler;
- * export const OPTIONS = handler;
- * ```
- * @example
- * ```ts
- * // app/api/upload/rest/route.ts
- * import { DiskStorage } from "@visulima/storage";
- * import { createHandler } from "@visulima/storage/handler/http/nextjs";
- *
- * const storage = new DiskStorage({ directory: "./uploads" });
- * const handler = createHandler({ storage, type: "rest" });
- *
- * export const POST = handler;
- * export const PUT = handler;
- * export const PATCH = handler;
- * export const GET = handler;
- * export const HEAD = handler;
- * export const DELETE = handler;
- * export const OPTIONS = handler;
- * ```
- * @example
- * ```ts
- * // app/api/upload/tus/route.ts
- * import { DiskStorage } from "@visulima/storage";
- * import { createHandler } from "@visulima/storage/handler/http/nextjs";
- *
- * const storage = new DiskStorage({ directory: "./uploads" });
- * const handler = createHandler({ storage, type: "tus" });
- *
- * export const POST = handler;
- * export const PATCH = handler;
- * export const HEAD = handler;
- * export const DELETE = handler;
- * export const OPTIONS = handler;
- * ```
- */
-export declare const createHandler: <TFile extends UploadFile>(config: NextjsHandlerConfig<TFile>) => (request: NextRequest) => Promise<NextResponse>;
+* Next.js route handler that automatically exports the correct HTTP methods for each handler type.
+* @example
+* ```ts
+* // app/api/upload/multipart/route.ts
+* import { DiskStorage } from "@visulima/storage";
+* import { createHandler } from "@visulima/storage/handler/http/nextjs";
+*
+* const storage = new DiskStorage({ directory: "./uploads" });
+* const handler = createHandler({ storage, type: "multipart" });
+*
+* export const POST = handler;
+* export const DELETE = handler;
+* export const GET = handler;
+* export const OPTIONS = handler;
+* ```
+* @example
+* ```ts
+* // app/api/upload/rest/route.ts
+* import { DiskStorage } from "@visulima/storage";
+* import { createHandler } from "@visulima/storage/handler/http/nextjs";
+*
+* const storage = new DiskStorage({ directory: "./uploads" });
+* const handler = createHandler({ storage, type: "rest" });
+*
+* export const POST = handler;
+* export const PUT = handler;
+* export const PATCH = handler;
+* export const GET = handler;
+* export const HEAD = handler;
+* export const DELETE = handler;
+* export const OPTIONS = handler;
+* ```
+* @example
+* ```ts
+* // app/api/upload/tus/route.ts
+* import { DiskStorage } from "@visulima/storage";
+* import { createHandler } from "@visulima/storage/handler/http/nextjs";
+*
+* const storage = new DiskStorage({ directory: "./uploads" });
+* const handler = createHandler({ storage, type: "tus" });
+*
+* export const POST = handler;
+* export const PATCH = handler;
+* export const HEAD = handler;
+* export const DELETE = handler;
+* export const OPTIONS = handler;
+* ```
+*/
+declare const createHandler: <TFile extends UploadFile>(config: NextjsHandlerConfig<TFile>) => ((request: NextRequest) => Promise<NextResponse>);
+export { NextjsHandlerConfig, createHandler };

package/dist/handler/http/nextjs/index.js

@@ -1,37 +1 @@
-import { NextResponse } from 'next/server';
-import Multipart from '../../../packem_shared/Multipart-CNFK_Okz.js';
-import RestFetch from '../../../packem_shared/Rest-CAOAEkOj.js';
-import { Tus } from '../../../packem_shared/Tus-B8PmlMgR.js';
-
-const createHandler = (config) => {
-  let handler;
-  switch (config.type) {
-    case "multipart": {
-      handler = new Multipart(config);
-      break;
-    }
-    case "rest": {
-      handler = new RestFetch(config);
-      break;
-    }
-    case "tus": {
-      handler = new Tus(config);
-      break;
-    }
-    default: {
-      throw new Error(`Unknown handler type: ${String(config.type ?? "unknown")}`);
-    }
-  }
-  const nextjsHandler = async (request) => {
-    try {
-      return await handler.fetch(request);
-    } catch (error) {
-      const errorObject = error;
-      const statusCode = errorObject.statusCode || (errorObject.status ? Number.parseInt(errorObject.status, 10) : void 0) || 500;
-      return NextResponse.json({ error: errorObject.message || "Request failed" }, { status: statusCode });
-    }
-  };
-  return nextjsHandler;
-};
-
-export { createHandler };
+var c=Object.defineProperty;var a=(e,r)=>c(e,"name",{value:r,configurable:!0});import{NextResponse as i}from"next/server.js";import m from"../../../packem_shared/Multipart-Bd9YFFn0.js";import p from"../../../packem_shared/Rest-DoonVU7B.js";import{Tus as d}from"../../../packem_shared/Tus-Bd_2Ki2G.js";var l=Object.defineProperty,n=a((e,r)=>l(e,"name",{value:r,configurable:!0}),"r");const k=n(e=>{let r;switch(e.type){case"multipart":{r=new m(e);break}case"rest":{r=new p(e);break}case"tus":{r=new d(e);break}default:throw new Error(`Unknown handler type: ${String(e.type??"unknown")}`)}return n(async s=>{try{return await r.fetch(s)}catch(o){const t=o,u=t.statusCode||(t.status?Number.parseInt(t.status,10):void 0)||500;return i.json({error:t.message||"Request failed"},{status:u})}},"nextjsHandler")},"createHandler");export{k as createHandler};

package/dist/handler/http/node/index.d.ts

@@ -1,4 +1,361 @@
-export { default as Multipart } from "../../multipart/multipart.d.ts";
-export { default as Rest } from "../../rest/rest.d.ts";
-export { Tus, TUS_RESUMABLE, TUS_VERSION } from "../../tus/tus.d.ts";
-export type { AsyncHandler, BaseHandler, Handlers, MethodHandler, RequestEvent, UploadErrorEvent, UploadEvent, UploadOptions } from "../../types.d.ts";
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { U as UploadFile, l as UploadResponse } from "../../../packem_shared/storage.d-Cxs42eEK.js";
+import { Readable } from 'node:stream';
+import { H as Handlers, A as AsyncHandler, U as UploadOptions, R as ResponseFile, a as ResponseList, M as MethodHandler } from "../../../packem_shared/types.d-LqXtPPaF.js";
+export { type B as BaseHandler, type b as RequestEvent, type c as UploadErrorEvent, type d as UploadEvent } from "../../../packem_shared/types.d-LqXtPPaF.js";
+import { B as BaseHandlerCore } from "../../../packem_shared/tus-base.d-dim7udrK.js";
+export { T as TUS_RESUMABLE, a as TUS_VERSION } from "../../../packem_shared/tus-base.d-dim7udrK.js";
+import 'node:crypto';
+import 'lru-cache';
+import 'node:events';
+import '@visulima/pagination';
+import "../../../packem_shared/media-transformer.d-CLxm_69K.js";
+import "../../../packem_shared/types.d-76N78ehR.js";
+/**
+* Base handler for Node.js platform (IncomingMessage/ServerResponse).
+* Extends BaseHandlerCore with Node.js-specific request/response handling.
+* @template TFile The file type used by this handler.
+* @template NodeRequest The Node.js request type.
+* @template NodeResponse The Node.js response type.
+*/
+declare abstract class BaseHandlerNode<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerCore<TFile> implements MethodHandler<NodeRequest, NodeResponse> {
+  /**
+  * Limiting enabled HTTP method handler.
+  */
+  static readonly methods: Handlers[];
+  /**
+  * Map of registered HTTP method handlers.
+  */
+  protected registeredHandlers: Map<string, AsyncHandler<NodeRequest, NodeResponse>>;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Gets the registered handlers map.
+  * @returns Map of registered handlers.
+  */
+  get handlers(): Map<string, AsyncHandler<NodeRequest, NodeResponse>>;
+  /**
+  * Handles HTTP request (alias for upload method).
+  * @param request Node.js IncomingMessage.
+  * @param response Node.js ServerResponse.
+  */
+  handle: (request: NodeRequest, response: NodeResponse) => Promise<void>;
+  /**
+  * 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: (request: NodeRequest, response: NodeResponse, next?: () => void) => Promise<void>;
+  /**
+  * Compose and register HTTP method handlers.
+  * Subclasses should override this to register their specific handlers.
+  */
+  protected abstract compose(): void;
+  /**
+  * 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.
+  */
+  send(response: NodeResponse, {
+    body,
+    headers,
+    statusCode
+  }: UploadResponse): void;
+  /**
+  * 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.
+  */
+  sendError(response: NodeResponse, error: Error): Promise<void>;
+  /**
+  * 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: NodeResponse, stream: Readable, {
+    headers,
+    range,
+    size,
+    statusCode
+  }: {
+    headers?: Record<string, string | number>;
+    range?: {
+      end: number;
+      start: number;
+    };
+    size?: number;
+    statusCode?: number;
+  }): void;
+  /**
+  * 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
+  */
+  protected finish(_request: NodeRequest, response: NodeResponse, uploadResponse: UploadResponse | ResponseFile<TFile>): void;
+  /**
+  * 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
+  */
+  protected buildFileUrl(request: NodeRequest & {
+    originalUrl?: string;
+  }, file: TFile): string;
+  /**
+  * 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: NodeRequest, supportedTypes: string[]): string | undefined;
+  /**
+  * Default OPTIONS handler.
+  * @param _request HTTP request (unused)
+  * @param _response HTTP response (unused)
+  * @returns Promise resolving to ResponseFile with CORS headers
+  */
+  options(_request: NodeRequest, _response: NodeResponse): Promise<ResponseFile<TFile>>;
+  /**
+  * 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.
+  */
+  get(request: NodeRequest & {
+    originalUrl?: string;
+  }, _response: NodeResponse): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+  /**
+  * 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.
+  */
+  list(request: NodeRequest, _response: NodeResponse): Promise<ResponseList<TFile>>;
+  /**
+  * 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.
+  */
+  download(request: NodeRequest & {
+    originalUrl?: string;
+  }, response: NodeResponse): Promise<void>;
+  /**
+  * Check if error is related to undefined ID or path and throw appropriate HTTP error.
+  * @param error Error object to check
+  */
+  protected override checkForUndefinedIdOrPath(error: unknown): void;
+}
+/**
+* Multipart/form-data upload handler (Node.js version).
+* @example
+* ```ts
+* const multipart = new Multipart({
+*   storage,
+*   maxFileSize: 100 * 1024 * 1024, // 100MB
+* });
+*
+* app.use('/files', multipart.handle);
+* ```
+*/
+declare class Multipart<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerNode<TFile, NodeRequest, NodeResponse> {
+  /**
+  * Limiting enabled http method handler
+  */
+  static override readonly methods: Handlers[];
+  private readonly multipartBase;
+  /**
+  * Maximum file size allowed for multipart uploads
+  */
+  private maxFileSize;
+  /**
+  * Maximum header size allowed for multipart parser
+  */
+  private maxHeaderSize;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Handles multipart/form-data POST requests for file uploads.
+  * @param request Node.js IncomingMessage containing multipart data.
+  * @returns Promise resolving to ResponseFile with upload result.
+  */
+  post(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * Delete an uploaded file.
+  * @param request Node.js IncomingMessage with file ID
+  * @returns Promise resolving to ResponseFile with deletion result
+  */
+  delete(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * Compose and register HTTP method handlers.
+  */
+  protected compose(): void;
+}
+/**
+* REST API handler for direct binary file uploads (Node.js version).
+*
+* This handler provides a clean REST interface for file operations:
+* - POST: Create a new file with raw binary data or initialize chunked upload
+* - PUT: Create or update a file (requires ID in URL)
+* - PATCH: Upload chunks for chunked uploads (requires ID in URL)
+* - GET: Retrieve a file or list files
+* - DELETE: Delete a file (single) or multiple files (via ?ids=id1,id2 or JSON body)
+* - HEAD: Get file metadata and upload progress
+* - OPTIONS: CORS preflight
+* @example
+* ```ts
+* const rest = new Rest({
+*   storage,
+* });
+*
+* app.use('/files', rest.handle);
+* ```
+*/
+declare class Rest<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerNode<TFile, NodeRequest, NodeResponse> {
+  /**
+  * Limiting enabled http method handler
+  */
+  static override readonly methods: Handlers[];
+  private readonly restBase;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Compose and register HTTP method handlers.
+  */
+  protected override compose(): void;
+  /**
+  * 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
+  */
+  protected buildFileUrlForRest(requestUrl: string, file: TFile): string;
+  /**
+  * 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.
+  */
+  post(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * 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
+  */
+  put(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * 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
+  */
+  delete(request: NodeRequest): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+  /**
+  * 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.
+  */
+  patch(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * 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
+  */
+  head(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * Handle OPTIONS requests with REST API capabilities.
+  * @returns Promise resolving to ResponseFile with CORS headers
+  */
+  override options(): Promise<ResponseFile<TFile>>;
+  /**
+  * 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.
+  */
+  override get(request: NodeRequest, response: NodeResponse): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+}
+/**
+* TUS resumable upload protocol handler (Node.js version).
+*
+* [tus resumable upload protocol](https://github.com/tus/tus-resumable-upload-protocol/blob/master/protocol.md)
+* @example
+* ```ts
+* const tus = new Tus({storage});
+*
+* app.all('/files', tus.handle);
+* ```
+*/
+declare class Tus<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerNode<TFile, NodeRequest, NodeResponse> {
+  /**
+  * Limiting enabled http method handler
+  */
+  static override readonly methods: Handlers[];
+  override disableTerminationForFinishedUploads: boolean;
+  private readonly tusBase;
+  constructor(options: UploadOptions<TFile>);
+  /**
+  * Handle OPTIONS requests with TUS protocol capabilities.
+  * @returns Promise resolving to ResponseFile with TUS headers
+  */
+  override options(): Promise<ResponseFile<TFile>>;
+  /**
+  * 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.
+  */
+  post(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * 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
+  */
+  patch(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * 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
+  */
+  head(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * 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
+  */
+  override get(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * Delete a TUS upload and its associated data.
+  * @param request Node.js IncomingMessage with upload ID
+  * @returns Promise resolving to ResponseFile with deletion confirmation
+  */
+  delete(request: NodeRequest): Promise<ResponseFile<TFile>>;
+  /**
+  * 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
+  */
+  override send(response: NodeResponse, {
+    body,
+    headers,
+    statusCode
+  }: UploadResponse): void;
+  /**
+  * Compose and register HTTP method handlers.
+  */
+  protected compose(): void;
+  /**
+  * 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
+  */
+  protected buildFileUrlForTus(requestUrl: string, file: TFile): string;
+}
+export { type AsyncHandler, type Handlers, type MethodHandler, Multipart, Rest, Tus, type UploadOptions };

package/dist/handler/http/node/index.js

@@ -1,4 +1 @@
-export { default as Multipart } from '../../../packem_shared/Multipart-CtUL7BQw.js';
-export { default as Rest } from '../../../packem_shared/Rest-DNuLwBrK.js';
-export { Tus } from '../../../packem_shared/Tus-C4F1aYOl.js';
-export { TUS_RESUMABLE, TUS_VERSION } from '../../../packem_shared/TUS_RESUMABLE-GJzZ9R-f.js';
+import o from"../../../packem_shared/Multipart-D5bcEvga.js";import m from"../../../packem_shared/Rest-CYEBbtCD.js";import{Tus as f}from"../../../packem_shared/Tus-CUBCkuPE.js";import{TUS_RESUMABLE as S,TUS_VERSION as a}from"../../../packem_shared/TUS_RESUMABLE-B7KtPVeC.js";export{o as Multipart,m as Rest,S as TUS_RESUMABLE,a as TUS_VERSION,f as Tus};