@visulima/storage 1.0.0-alpha.8 → 1.0.0

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

@@ -1,4 +1,368 @@
-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, m as UploadResponse } from "../../../packem_shared/storage.d-CEM1upWM.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-CggTCgXr.js";
+export type { B as BaseHandler, b as RequestEvent, c as UploadErrorEvent, d as UploadEvent } from "../../../packem_shared/types.d-CggTCgXr.js";
+import { B as BaseHandlerCore } from "../../../packem_shared/tus-base.d-DLzKE54M.js";
+export { T as TUS_RESUMABLE, a as TUS_VERSION } from "../../../packem_shared/tus-base.d-DLzKE54M.js";
+import 'node:crypto';
+import 'lru-cache';
+import 'node:events';
+import '@visulima/pagination';
+import "../../../packem_shared/media-transformer.d-Quf4ai47.js";
+import "../../../packem_shared/types.d-CrUWY4On.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).
+  *
+  * On the Node runtime the TUS protocol chain only carries the request *path* (`requestUrl` is
+  * `request.originalUrl || request.url`), so an absolute `Location` can only be produced when that
+  * path is itself an absolute URL (e.g. an upstream proxy rewrote it). When it is just a path the
+  * `Location` is necessarily relative — the request headers are not threaded through the protocol
+  * methods. Use the fetch/hono handlers (which receive `request.url` with the origin) or set
+  * `useRelativeLocation: true` explicitly for relative URLs everywhere.
+  * @param requestUrl Request URL string (path-only on Node unless rewritten to an absolute URL).
+  * @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,8 +1 @@
-import Multipart from '../../../packem_shared/Multipart-C-iU9LXj.js';
-import Rest from '../../../packem_shared/Rest-DTaszQ6n.js';
-import { Tus } from '../../../packem_shared/Tus-BibjweWH.js';
-export { TUS_RESUMABLE, TUS_VERSION } from '../../../packem_shared/TUS_RESUMABLE-BfguFdM1.js';
-
-
-
-export { Multipart, Rest, Tus };
+import o from"../../../packem_shared/Multipart-Btj2mo9r.js";import m from"../../../packem_shared/Rest-BehVaxbl.js";import{Tus as f}from"../../../packem_shared/Tus-BgbON_wQ.js";import{TUS_RESUMABLE as S,TUS_VERSION as a}from"../../../packem_shared/TUS_RESUMABLE-CyTSRvPU.js";export{o as Multipart,m as Rest,S as TUS_RESUMABLE,a as TUS_VERSION,f as Tus};

package/dist/handler/http/solid-start/index.d.ts

@@ -1,60 +1,69 @@
-import type { APIEvent } from "@solidjs/start/server";
-import type { UploadFile } from "../../../storage/utils/index.d.ts";
-import type { UploadOptions } from "../../types.d.ts";
+import { APIEvent } from '@solidjs/start/server';
+import { U as UploadFile } from "../../../packem_shared/storage.d-CEM1upWM.js";
+import 'node:stream';
+import { U as UploadOptions } from "../../../packem_shared/types.d-CggTCgXr.js";
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import 'node:events';
+import '@visulima/pagination';
+import "../../../packem_shared/media-transformer.d-Quf4ai47.js";
+import "../../../packem_shared/types.d-CrUWY4On.js";
 /**
- * Configuration for SolidStart handler.
- */
-export interface SolidStartHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
-    /** Handler type to use */
-    type: "multipart" | "rest" | "tus";
+* Configuration for SolidStart handler.
+*/
+interface SolidStartHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
+  /** Handler type to use */
+  type: "multipart" | "rest" | "tus";
 }
 /**
- * SolidStart API route handler that automatically handles the correct HTTP methods for each handler type.
- * @example
- * ```ts
- * // app/routes/api/upload/multipart.ts
- * import { DiskStorage } from "@visulima/storage";
- * import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
- *
- * const storage = new DiskStorage({ directory: "./uploads" });
- * const handler = createSolidStartHandler({ storage, type: "multipart" });
- *
- * export const POST = handler;
- * export const DELETE = handler;
- * export const GET = handler;
- * export const OPTIONS = handler;
- * ```
- * @example
- * ```ts
- * // app/routes/api/upload/rest.ts
- * import { DiskStorage } from "@visulima/storage";
- * import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
- *
- * const storage = new DiskStorage({ directory: "./uploads" });
- * const handler = createSolidStartHandler({ 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/routes/api/upload/tus.ts
- * import { DiskStorage } from "@visulima/storage";
- * import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
- *
- * const storage = new DiskStorage({ directory: "./uploads" });
- * const handler = createSolidStartHandler({ 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 createSolidStartHandler: <TFile extends UploadFile>(config: SolidStartHandlerConfig<TFile>) => (event: APIEvent) => Promise<Response>;
+* SolidStart API route handler that automatically handles the correct HTTP methods for each handler type.
+* @example
+* ```ts
+* // app/routes/api/upload/multipart.ts
+* import { DiskStorage } from "@visulima/storage";
+* import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
+*
+* const storage = new DiskStorage({ directory: "./uploads" });
+* const handler = createSolidStartHandler({ storage, type: "multipart" });
+*
+* export const POST = handler;
+* export const DELETE = handler;
+* export const GET = handler;
+* export const OPTIONS = handler;
+* ```
+* @example
+* ```ts
+* // app/routes/api/upload/rest.ts
+* import { DiskStorage } from "@visulima/storage";
+* import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
+*
+* const storage = new DiskStorage({ directory: "./uploads" });
+* const handler = createSolidStartHandler({ 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/routes/api/upload/tus.ts
+* import { DiskStorage } from "@visulima/storage";
+* import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
+*
+* const storage = new DiskStorage({ directory: "./uploads" });
+* const handler = createSolidStartHandler({ 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 createSolidStartHandler: <TFile extends UploadFile>(config: SolidStartHandlerConfig<TFile>) => ((event: APIEvent) => Promise<Response>);
+export { SolidStartHandlerConfig, createSolidStartHandler };

package/dist/handler/http/solid-start/index.js

@@ -1,44 +1 @@
-import Multipart from '../../../packem_shared/Multipart-5Xpy7WhY.js';
-import RestFetch from '../../../packem_shared/Rest-DO7OslCs.js';
-import { Tus } from '../../../packem_shared/Tus-BQItPVAC.js';
-
-const createSolidStartHandler = (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 solidStartHandler = async (event) => {
-    try {
-      return await handler.fetch(event.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" },
-        {
-          headers: {
-            "Content-Type": "application/json"
-          },
-          status: statusCode
-        }
-      );
-    }
-  };
-  return solidStartHandler;
-};
-
-export { createSolidStartHandler };
+import o from"../../../packem_shared/Multipart-C4GpuHMU.js";import u from"../../../packem_shared/Rest-ymPCZkKR.js";import{Tus as p}from"../../../packem_shared/Tus-v6jzkaIO.js";const w=t=>{let e;switch(t.type){case"multipart":{e=new o(t);break}case"rest":{e=new u(t);break}case"tus":{e=new p(t);break}default:throw new Error(`Unknown handler type: ${String(t.type??"unknown")}`)}return async n=>{try{return await e.fetch(n.request)}catch(s){const r=s,a=r.statusCode||(r.status?Number.parseInt(r.status,10):void 0)||500;return Response.json({error:r.message||"Request failed"},{headers:{"Content-Type":"application/json"},status:a})}}};export{w as createSolidStartHandler};