@visulima/storage 1.0.0-alpha.3 → 1.0.0-alpha.30

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, K as UploadResponse } from "../../../packem_shared/storage.d-RteRC-cG.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-cI_cMxcZ.js";
+export { type B as BaseHandler, type b as RequestEvent, type c as UploadErrorEvent, type d as UploadEvent } from "../../../packem_shared/types.d-cI_cMxcZ.js";
+import { B as BaseHandlerCore } from "../../../packem_shared/tus-base.d-CygntIPM.js";
+export { T as TUS_RESUMABLE, a as TUS_VERSION } from "../../../packem_shared/tus-base.d-CygntIPM.js";
+import 'node:crypto';
+import 'lru-cache';
+import 'node:events';
+import '@visulima/pagination';
+import "../../../packem_shared/media-transformer.d-C3QvECD7.js";
+import "../../../packem_shared/types.d-DxonY4XS.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-CIFfQksD.js";import m from"../../../packem_shared/Rest-URrQ5FYM.js";import{Tus as f}from"../../../packem_shared/Tus-TNG9HAY8.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};

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-RteRC-cG.js";
+import 'node:stream';
+import { U as UploadOptions } from "../../../packem_shared/types.d-cI_cMxcZ.js";
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+import 'node:events';
+import '@visulima/pagination';
+import "../../../packem_shared/media-transformer.d-C3QvECD7.js";
+import "../../../packem_shared/types.d-DxonY4XS.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-CNFK_Okz.js';
-import RestFetch from '../../../packem_shared/Rest-CAOAEkOj.js';
-import { Tus } from '../../../packem_shared/Tus-B8PmlMgR.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 };
+var i=Object.defineProperty;var a=(t,e)=>i(t,"name",{value:e,configurable:!0});import c from"../../../packem_shared/Multipart-D9WIud9R.js";import d from"../../../packem_shared/Rest-BuD3ySAg.js";import{Tus as l}from"../../../packem_shared/Tus-Fp_hx5ug.js";var p=Object.defineProperty,n=a((t,e)=>p(t,"name",{value:e,configurable:!0}),"s");const b=n(t=>{let e;switch(t.type){case"multipart":{e=new c(t);break}case"rest":{e=new d(t);break}case"tus":{e=new l(t);break}default:throw new Error(`Unknown handler type: ${String(t.type??"unknown")}`)}return n(async s=>{try{return await e.fetch(s.request)}catch(o){const r=o,u=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:u})}},"solidStartHandler")},"createSolidStartHandler");export{b as createSolidStartHandler};

package/dist/index.d.ts

@@ -1,17 +1,58 @@
-export { waitForStorage } from "./handler/utils/storage-utils.d.ts";
-export { NoOpMetrics, OpenTelemetryMetrics } from "./metrics/index.d.ts";
-export { default as DiskStorage } from "./storage/local/disk-storage.d.ts";
-export { default as DiskStorageWithChecksum } from "./storage/local/disk-storage-with-checksum.d.ts";
-export type { LocalMetaStorageOptions } from "./storage/local/local-meta-storage.d.ts";
-export { default as LocalMetaStorage } from "./storage/local/local-meta-storage.d.ts";
-export { default as MetaStorage } from "./storage/meta-storage.d.ts";
-export { BaseStorage as AbstractBaseStorage, defaultCloudStorageFileNameValidation, defaultFilesystemFileNameValidation } from "./storage/storage.d.ts";
-export type { BaseStorageOptions, BatchOperationResponse, BatchOperationResult, DiskStorageOptions, DiskStorageWithChecksumOptions, ExpirationOptions, MetaStorageOptions, OnComplete, OnCreate, OnDelete, OnError, OnUpdate, PurgeList, } from "./storage/types.d.ts";
-export type { FileInit, FilePart, FileQuery, UploadEventType, UploadFile } from "./storage/utils/file/index.d.ts";
-export { File, Metadata } from "./storage/utils/file/index.d.ts";
-export { ErrorMap, ERRORS, isUploadError, throwErrorCode, UploadError } from "./utils/errors.d.ts";
-export type { RetryConfig } from "./utils/retry.d.ts";
-export { createRetryWrapper, isRetryableError, retry } from "./utils/retry.d.ts";
-export type { Header, Headers, HttpError, HttpErrorBody, IncomingMessageWithBody, Metrics, RangeChecksum, RangeHasher, ResponseBody, ResponseBodyType, ResponseTuple, UploadResponse, Validation, ValidationError, ValidatorConfig, } from "./utils/types.d.ts";
-export type { AnyWebReadableByteStreamWithFileType, AnyWebReadableStream, Detector, FileTypeOptions, FileTypeParser, FileTypeResult, StreamOptions, TokenizerPositionError, } from "file-type";
-export { fileTypeFromBlob, fileTypeFromBuffer, fileTypeFromTokenizer, supportedExtensions, supportedMimeTypes } from "file-type";
+export { type D as DownloadResult, type a as FileBody, type b as FileObject, F as Files, type c as FilesOptions, type L as ListOptions, type S as SignedReadUrlOptions, type d as SignedUploadUrlOptions, type U as UploadOptions } from "./packem_shared/index.d-C4Fivh4I.js";
+import { l as Metrics } from "./packem_shared/storage.d-RteRC-cG.js";
+export { B as AbstractBaseStorage, type i as BaseStorageOptions, type m as BatchOperationResponse, type n as BatchOperationResult, type D as DiskStorageOptions, type h as DiskStorageWithChecksumOptions, E as ERRORS, o as ErrorMap, type p as ExpirationOptions, F as File, type e as FileInit, type f as FilePart, type g as FileQuery, type q as Header, type r as Headers, type H as HttpError, type s as HttpErrorBody, type I as IncomingMessageWithBody, type L as LocalMetaStorageOptions, M as MetaStorage, type t as MetaStorageOptions, u as Metadata, type v as OnComplete, type w as OnCreate, type x as OnDelete, type y as OnError, type z as OnUpdate, type P as PurgeList, type A as RangeChecksum, type C as RangeHasher, type G as ResponseBody, type j as ResponseBodyType, type J as ResponseTuple, type R as RetryConfig, b as UploadError, type c as UploadEventType, type U as UploadFile, type K as UploadResponse, type V as Validation, type N as ValidationError, type Q as ValidatorConfig, d as createRetryWrapper, S as defaultCloudStorageFileNameValidation, T as defaultFilesystemFileNameValidation, W as extractHttpStatus, X as isRetryableError, Y as isUploadError, Z as mapStatusToErrorCode, _ as retry, $ as throwErrorCode, a0 as wrapStorageError } from "./packem_shared/storage.d-RteRC-cG.js";
+import { Meter } from '@opentelemetry/api';
+export { D as DiskStorage, a as DiskStorageWithChecksum } from "./packem_shared/disk-storage-with-checksum.d-mHcg2uLw.js";
+export { L as LocalMetaStorage } from "./packem_shared/local-meta-storage.d-B11vHYNm.js";
+export { type AnyWebReadableByteStreamWithFileType, type AnyWebReadableStream, type Detector, type FileTypeOptions, type FileTypeParser, type FileTypeResult, type StreamOptions, type TokenizerPositionError, fileTypeFromBlob, fileTypeFromBuffer, fileTypeFromTokenizer, supportedExtensions, supportedMimeTypes } from 'file-type';
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+/**
+* Wait for storage to be ready before handling requests.
+* This ensures storage initialization (e.g., AWS S3, GCS) completes before processing uploads.
+* @param storage Storage instance with isReady property
+* @param timeoutMs Maximum time to wait in milliseconds (default: 5000)
+* @throws Error if storage doesn't become ready within timeout
+*/
+declare const waitForStorage: (storage: {
+  isReady: boolean;
+}, timeoutMs?: number) => Promise<void>;
+/**
+* No-op metrics that does nothing.
+* Used as a default when metrics are not provided.
+*/
+declare class NoOpMetrics implements Metrics {
+  increment(_name: string, _value?: number, _attributes?: Record<string, string | number>): void;
+  timing(_name: string, _duration: number, _attributes?: Record<string, string | number>): void;
+  gauge(_name: string, _value: number, _attributes?: Record<string, string | number>): void;
+}
+/**
+* OpenTelemetry-based metrics implementation.
+*/
+declare class OpenTelemetryMetrics implements Metrics {
+  private readonly meter;
+  private readonly counters;
+  private readonly histograms;
+  private readonly gauges;
+  /**
+  * Creates a new OpenTelemetryMetrics instance.
+  * @param meter OpenTelemetry Meter instance. If not provided, uses the default meter.
+  * @throws {Error} If \@opentelemetry/api is not installed
+  */
+  constructor(meter?: Meter);
+  /**
+  * Increment a counter metric.
+  */
+  increment(name: string, value?: number, attributes?: Record<string, string | number>): void;
+  /**
+  * Record a duration/timing metric in milliseconds.
+  */
+  timing(name: string, duration: number, attributes?: Record<string, string | number>): void;
+  /**
+  * Set a gauge metric value.
+  */
+  gauge(name: string, value: number, attributes?: Record<string, string | number>): void;
+}
+export { type Metrics, NoOpMetrics, OpenTelemetryMetrics, waitForStorage };

package/dist/index.js

@@ -1,13 +1 @@
-export { waitForStorage } from './packem_shared/waitForStorage-Cscw85sx.js';
-export { D as DiskStorage } from './packem_shared/disk-storage-Bh2wy3YW.js';
-export { default as DiskStorageWithChecksum } from './packem_shared/DiskStorageWithChecksum-BJTmMklc.js';
-export { L as LocalMetaStorage } from './packem_shared/local-meta-storage-By-3SNBI.js';
-export { default as MetaStorage } from './packem_shared/MetaStorage-pECeFOad.js';
-export { B as AbstractBaseStorage, d as defaultCloudStorageFileNameValidation, a as defaultFilesystemFileNameValidation } from './packem_shared/storage-C6NSXb8h.js';
-export { ERRORS, ErrorMap, UploadError, isUploadError, throwErrorCode } from './packem_shared/ERRORS-D0apMqnc.js';
-export { createRetryWrapper, isRetryableError, retry } from './packem_shared/isRetryableError-Dycp7127.js';
-export { fileTypeFromBlob, fileTypeFromBuffer, fileTypeFromTokenizer, supportedExtensions, supportedMimeTypes } from 'file-type';
-export { default as NoOpMetrics } from './packem_shared/NoOpMetrics-DhAk5rXc.js';
-export { default as OpenTelemetryMetrics } from './packem_shared/OpenTelemetryMetrics-BnxhqIaH.js';
-export { default as File } from './packem_shared/File-Bb3P23dr.js';
-export { Metadata } from './packem_shared/Metadata-DRLXeJ0F.js';
+import{Files as o}from"./packem_shared/Files-CJh9_N-9.js";import{waitForStorage as a}from"./packem_shared/waitForStorage-ChSBLhLc.js";import{f as s}from"./packem_shared/disk-storage-CKAJvhcj.js";import{default as l}from"./packem_shared/DiskStorageWithChecksum-BvUTn7O-.js";import{v as i}from"./packem_shared/local-meta-storage-Bi0mK6gD.js";import{default as x}from"./packem_shared/MetaStorage-Y4m1dWgd.js";import{B as S,d as y,a as E}from"./packem_shared/storage-Dh0tJh7j.js";import{ERRORS as g,ErrorMap as c,UploadError as M,extractHttpStatus as T,isUploadError as n,mapStatusToErrorCode as R,throwErrorCode as k,wrapStorageError as B}from"./packem_shared/ERRORS-CyOuSMLY.js";import{createRetryWrapper as b,isRetryableError as h,retry as w}from"./packem_shared/isRetryableError-BhizNeAz.js";import{fileTypeFromBlob as O,fileTypeFromBuffer as D,fileTypeFromTokenizer as U,supportedExtensions as V,supportedMimeTypes as W}from"file-type";import{default as z}from"./packem_shared/File-BhfUgJjs.js";import{default as H}from"./packem_shared/NoOpMetrics-Dky06sf1.js";import{default as j}from"./packem_shared/OpenTelemetryMetrics-9uxQMSlg.js";import{Metadata as G}from"./packem_shared/Metadata-B6Ir0KO7.js";export{S as AbstractBaseStorage,s as DiskStorage,l as DiskStorageWithChecksum,g as ERRORS,c as ErrorMap,z as File,o as Files,i as LocalMetaStorage,x as MetaStorage,G as Metadata,H as NoOpMetrics,j as OpenTelemetryMetrics,M as UploadError,b as createRetryWrapper,y as defaultCloudStorageFileNameValidation,E as defaultFilesystemFileNameValidation,T as extractHttpStatus,O as fileTypeFromBlob,D as fileTypeFromBuffer,U as fileTypeFromTokenizer,h as isRetryableError,n as isUploadError,R as mapStatusToErrorCode,w as retry,V as supportedExtensions,W as supportedMimeTypes,k as throwErrorCode,a as waitForStorage,B as wrapStorageError};