@visulima/storage 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/handler/types.d.ts

@@ -0,0 +1,53 @@
+import type { EventEmitter } from "node:events";
+import type { IncomingMessage } from "node:http";
+import type { Readable } from "node:stream";
+import type { PaginationResult } from "@visulima/pagination";
+import type { BaseStorage } from "../storage/storage.d.ts";
+import type { UploadEventType, UploadFile } from "../storage/utils/index.d.ts";
+import type MediaTransformer from "../transformer/media-transformer.d.ts";
+import type { UploadError } from "../utils/errors.d.ts";
+type WebRequest = globalThis.Request;
+type WebResponse = globalThis.Response;
+interface BaseResponse {
+    headers: Record<string, number | string>;
+    statusCode: number;
+}
+export interface StreamingResponse extends BaseResponse {
+    /** Total size of the stream (for Content-Length header) */
+    size?: number;
+    /** Stream of data to send */
+    stream: Readable;
+}
+export interface RequestEvent {
+    request: Pick<IncomingMessage, "headers" | "method" | "url">;
+}
+export type AsyncHandler<Request, Response> = (request: Request, response: Response) => Promise<void | ResponseFile<UploadFile> | ResponseList<UploadFile> | StreamingResponse>;
+export type Handlers = "delete" | "download" | "get" | "head" | "options" | "patch" | "post" | "put";
+export type MethodHandler<Request, Response> = {
+    [h in Handlers]?: AsyncHandler<Request, Response>;
+};
+export type UploadEvent<TFile extends UploadFile> = RequestEvent & TFile;
+export type UploadErrorEvent = RequestEvent & UploadError;
+export type ResponseFile<TFile extends UploadFile> = BaseResponse & TFile & {
+    /** Optional stream for streaming responses instead of content buffer */
+    stream?: Readable;
+};
+export type ResponseList<TFile extends UploadFile> = BaseResponse & {
+    data: PaginationResult<TFile> | TFile[];
+};
+export interface BaseHandler<TFile extends UploadFile> extends EventEmitter {
+    emit: ((event: "error", error: UploadErrorEvent) => boolean) & ((event: UploadEventType, payload: UploadEvent<TFile>) => boolean);
+    fetch: (request: WebRequest) => Promise<WebResponse>;
+    off: ((event: "error", listener: (error: UploadErrorEvent) => void) => this) & ((event: UploadEventType, listener: (payload: UploadEvent<TFile>) => void) => this);
+    on: ((event: "error", listener: (error: UploadErrorEvent) => void) => this) & ((event: UploadEventType, listener: (payload: UploadEvent<TFile>) => void) => this);
+}
+export interface UploadOptions<TFile extends UploadFile> {
+    disableTerminationForFinishedUploads?: boolean;
+    /** Maximum file size for multipart parser (default: min(storage.maxUploadSize, 1GB)) */
+    maxFileSize?: number;
+    /** Maximum header size for multipart parser (default: 64KB) */
+    maxHeaderSize?: number;
+    mediaTransformer?: MediaTransformer;
+    storage: BaseStorage<TFile>;
+}
+export {};

package/dist/handler/utils/request-parser.d.ts

@@ -0,0 +1,72 @@
+import type { IncomingMessage } from "node:http";
+import type { FileInit } from "../../storage/utils/index.d.ts";
+/**
+ * Parses metadata from X-File-Metadata header.
+ * @param request The HTTP request
+ * @param existingMetadata Existing metadata to merge with (optional)
+ * @returns Parsed metadata object
+ */
+export declare const parseMetadata: (request: IncomingMessage, existingMetadata?: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Parses filename from Content-Disposition header value string.
+ * Uses a safer parsing approach to avoid ReDoS vulnerabilities.
+ * @param contentDisposition The Content-Disposition header value
+ * @returns Filename if found, undefined otherwise
+ */
+export declare const parseContentDispositionValue: (contentDisposition: string | null | undefined) => string | undefined;
+/**
+ * Parses filename from Content-Disposition header.
+ * Uses a safer parsing approach to avoid ReDoS vulnerabilities.
+ * @param request The HTTP request
+ * @returns Filename if found, undefined otherwise
+ */
+export declare const parseContentDisposition: (request: IncomingMessage) => string | undefined;
+/**
+ * Parses chunked upload headers (X-Chunk-Offset, X-Total-Size, etc.).
+ * @param request The HTTP request
+ * @returns Object with chunk offset, total size, and chunked upload flag
+ */
+export declare const parseChunkHeaders: (request: IncomingMessage) => {
+    chunkOffset?: number;
+    isChunkedUpload: boolean;
+    totalSize?: number;
+};
+/**
+ * Validates that a request has a body.
+ * @param request The HTTP request
+ * @param allowEmptyForChunked Whether to allow empty body for chunked uploads
+ * @throws {HttpError} If body is required but missing
+ */
+export declare const validateRequestBody: (request: IncomingMessage, allowEmptyForChunked?: boolean) => void;
+/**
+ * Validates Content-Length header.
+ * @param request The HTTP request
+ * @param allowZeroForChunked Whether to allow zero length for chunked uploads
+ * @param maxSize Maximum allowed size
+ * @returns Parsed content length
+ * @throws {HttpError} If Content-Length is invalid or exceeds max size
+ */
+export declare const validateContentLength: (request: IncomingMessage, allowZeroForChunked?: boolean, maxSize?: number) => number;
+/**
+ * Extracts file initialization config from request headers.
+ * @param request The HTTP request
+ * @param contentLength The content length (already validated)
+ * @param contentType The content type (default: application/octet-stream)
+ * @returns FileInit configuration object
+ */
+export declare const extractFileInit: (request: IncomingMessage, contentLength: number, contentType?: string) => FileInit;
+/**
+ * Validates chunk offset and size for chunked uploads.
+ * @param chunkOffset The chunk offset
+ * @param contentLength The chunk content length
+ * @param totalSize The total file size
+ * @throws {HttpError} If validation fails
+ */
+export declare const validateChunk: (chunkOffset: number, contentLength: number, totalSize: number) => void;
+/**
+ * Gets content type from request headers with fallback.
+ * @param request The HTTP request
+ * @param fallback Default content type if not found (default: application/octet-stream)
+ * @returns Content type string
+ */
+export declare const getContentType: (request: IncomingMessage, fallback?: string) => string;

package/dist/handler/utils/response-builder.d.ts

@@ -0,0 +1,83 @@
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import type { Header } from "../../utils/types.d.ts";
+import type { ResponseFile } from "../types.d.ts";
+/**
+ * Builds a standard ResponseFile from a file object and headers.
+ * @param file The file object to convert to a response
+ * @param headers Additional headers to include
+ * @param statusCode HTTP status code (default: 200)
+ * @returns ResponseFile with file data and headers
+ */
+export declare const buildResponseFile: <TFile extends UploadFile>(file: TFile, headers?: Record<string, string | number>, statusCode?: number) => ResponseFile<TFile>;
+/**
+ * Builds standard file headers including Location, expiration, and ETag.
+ * @param file The file object
+ * @param locationUrl The Location header URL
+ * @param additionalHeaders Additional headers to merge in
+ * @returns Headers object with standard file headers
+ */
+export declare const buildFileHeaders: <TFile extends UploadFile>(file: TFile, locationUrl: string, additionalHeaders?: Record<string, string | number>) => Record<string, string | number>;
+/**
+ * Builds chunked upload headers for progress tracking.
+ * @param file The file object with chunked upload metadata
+ * @param isComplete Whether the upload is complete
+ * @returns Headers object with chunked upload progress headers
+ */
+export declare const buildChunkedUploadHeaders: <TFile extends UploadFile>(file: TFile, isComplete: boolean) => Record<string, string | number>;
+/**
+ * Builds a Location header URL for a file.
+ * @param requestUrl The request URL or originalUrl
+ * @param fileId The file ID
+ * @param contentType The file content type (for extension)
+ * @param useRelativeLocation Whether to use relative URLs
+ * @param baseUrl The base URL (for absolute URLs)
+ * @returns Location URL string
+ */
+export declare const buildLocationHeader: (requestUrl: string | undefined, fileId: string, contentType: string, useRelativeLocation: boolean, baseUrl?: string) => string;
+/**
+ * Builds standard file metadata headers for HEAD requests.
+ * @param file The file object
+ * @returns Headers object with file metadata
+ */
+export declare const buildFileMetadataHeaders: <TFile extends UploadFile>(file: TFile) => Record<string, string | number>;
+/**
+ * Converts headers from Record format to string format, handling arrays.
+ * @param headers Headers object that may contain arrays
+ * @returns Headers object with all values as strings
+ */
+export declare const convertHeadersToString: (headers: Record<string, Header>) => Record<string, string>;
+/**
+ * Builds an error response body in standard format.
+ * @param error The error object
+ * @returns Error response body object
+ */
+export declare const buildErrorResponseBody: (error: {
+    code?: string;
+    message?: string;
+    name?: string;
+}) => {
+    error: {
+        code: string;
+        message: string;
+        name: string;
+    };
+};
+/**
+ * Prepares response body and headers for sending, handling different body types.
+ * @param body The response body (string, Buffer, or object)
+ * @param headers Existing headers
+ * @returns Object with prepared data and headers
+ */
+export declare const prepareResponseBody: (body: string | Buffer | object | undefined, headers?: Record<string, string | number>) => {
+    data: Buffer | string;
+    headers: Record<string, string | number>;
+};
+/**
+ * Cleans file data for serialization by removing non-serializable properties.
+ * @param fileData File data object
+ * @returns Cleaned file data object
+ */
+export declare const cleanFileData: <TFile extends UploadFile>(fileData: TFile & {
+    content?: unknown;
+    stream?: unknown;
+}) => Omit<TFile, "content" | "stream">;

package/dist/handler/utils/storage-utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+export declare const waitForStorage: (storage: {
+    isReady: boolean;
+}, timeoutMs?: number) => Promise<void>;

package/dist/handler/utils/stream-utils.d.ts

@@ -0,0 +1,29 @@
+import type { ServerResponse } from "node:http";
+import type { Readable } from "node:stream";
+/**
+ * Creates a range-limited stream that properly handles backpressure.
+ * @param sourceStream Source readable stream to limit
+ * @param start Start byte position (inclusive)
+ * @param end End byte position (inclusive)
+ * @returns New readable stream limited to the specified byte range
+ */
+export declare const createRangeLimitedStream: (sourceStream: Readable, start: number, end: number) => Readable;
+/**
+ * Pipes streams with proper backpressure handling and error management.
+ * @param source Source readable stream to pipe from
+ * @param destination Destination response stream to pipe to
+ * @param sendError Function to send error responses
+ */
+export declare const pipeWithBackpressure: <TResponse extends ServerResponse>(source: Readable, destination: TResponse, sendError: (response: TResponse, error: Error) => Promise<void>) => void;
+/**
+ * Creates a stream response configuration object.
+ * @param stream The readable stream
+ * @param size Optional total size of the stream
+ * @param headers Optional headers to include
+ * @returns Stream response configuration
+ */
+export declare const createStreamResponse: (stream: Readable, size?: number, headers?: Record<string, string | number>) => {
+    headers: Record<string, string | number>;
+    size?: number;
+    stream: Readable;
+};

package/dist/handler/utils/upload-handlers.d.ts

@@ -0,0 +1,76 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Readable } from "node:stream";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import type { ResponseBody, UploadResponse } from "../../utils/types.d.ts";
+import type { ResponseFile, ResponseList } from "../types.d.ts";
+/**
+ * Handles HEAD/OPTIONS requests.
+ * @param file Response file with headers and status code
+ * @param send Function to send response
+ */
+export declare const handleHeadOptionsRequest: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile>, send: (response: NodeResponse, data: {
+    headers: Record<string, string | number>;
+    statusCode: number;
+}) => void, response: NodeResponse) => void;
+/**
+ * Handles GET requests with streaming support.
+ * @param file Response file (may contain stream)
+ * @param request HTTP request
+ * @param response HTTP response
+ * @param next Optional Express next function
+ * @param send Function to send regular response
+ * @param sendStream Function to send stream response
+ * @param parseRangeHeader Function to parse range header
+ */
+export declare const handleGetRequest: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile> | ResponseList<TFile>, request: IncomingMessage, response: NodeResponse, next: (() => void) | undefined, send: (response: NodeResponse, data: UploadResponse<ResponseBody>) => void, sendStream: (response: NodeResponse, stream: Readable, options: {
+    headers: Record<string, string | number>;
+    range?: {
+        end: number;
+        start: number;
+    };
+    size?: number;
+    statusCode: number;
+}) => void, parseRangeHeader: (rangeHeader: string | undefined, fileSize: number) => {
+    end: number;
+    start: number;
+} | undefined) => void;
+/**
+ * Handles completed upload responses.
+ * @param file Response file
+ * @param request HTTP request
+ * @param response HTTP response
+ * @param next Optional Express next function
+ * @param storage Storage instance for onComplete hook
+ * @param logger Optional logger
+ * @param finish Function to finish the response
+ */
+export declare const handleCompletedUpload: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile>, request: IncomingMessage, response: NodeResponse, next: (() => void) | undefined, storage: {
+    onComplete: (file: TFile, responseFile: ResponseFile<TFile>, request?: IncomingMessage) => void | Promise<void>;
+}, logger: {
+    error?: (message: string, error: unknown) => void;
+} | undefined, finish: (request: IncomingMessage, response: NodeResponse, uploadResponse: ResponseFile<TFile>) => void) => Promise<void>;
+/**
+ * Handles partial upload responses.
+ * @param file Response file
+ * @param request HTTP request
+ * @param response HTTP response
+ * @param send Function to send response
+ */
+export declare const handlePartialUpload: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile>, request: IncomingMessage, response: NodeResponse, send: (response: NodeResponse, data: {
+    body: Buffer | string | undefined;
+    headers: Record<string, string>;
+    statusCode: number;
+}) => void) => void;
+/**
+ * Handles errors during upload processing.
+ * @param error The error that occurred
+ * @param request HTTP request
+ * @param emit Function to emit events
+ * @param listenerCount Function to count event listeners
+ * @param logger Optional logger
+ * @param sendError Function to send error response
+ * @param response HTTP response
+ */
+export declare const handleUploadError: <NodeResponse extends ServerResponse>(error: unknown, request: IncomingMessage, emit: (event: string, data: unknown) => boolean, listenerCount: (event: string) => number, logger: {
+    error?: (message: string, error: unknown) => void;
+} | undefined, sendError: (response: NodeResponse, error: Error) => Promise<void>, response: NodeResponse) => Promise<void>;

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+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";

package/dist/index.js

@@ -0,0 +1,13 @@
+export { waitForStorage } from './packem_shared/waitForStorage-Cscw85sx.js';
+export { D as DiskStorage } from './packem_shared/disk-storage-DeivH-J5.js';
+export { default as DiskStorageWithChecksum } from './packem_shared/DiskStorageWithChecksum-B_XY8_cO.js';
+export { L as LocalMetaStorage } from './packem_shared/local-meta-storage-BlOk6m7F.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-CpJpqLdn.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 File } from './packem_shared/File-Bb3P23dr.js';
+export { default as NoOpMetrics } from './packem_shared/NoOpMetrics-DhAk5rXc.js';
+export { default as OpenTelemetryMetrics } from './packem_shared/OpenTelemetryMetrics-BnxhqIaH.js';
+export { Metadata } from './packem_shared/Metadata-DRLXeJ0F.js';

package/dist/metrics/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NoOpMetrics } from "./no-op-metrics.d.ts";
+export { default as OpenTelemetryMetrics } from "./opentelemetry-metrics.d.ts";

package/dist/metrics/no-op-metrics.d.ts

@@ -0,0 +1,15 @@
+/**
+ * No-op metrics implementation.
+ * Used when metrics are not provided, ensuring no overhead when metrics are disabled.
+ */
+import type { Metrics } from "../utils/types.d.ts";
+/**
+ * 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;
+}
+export default NoOpMetrics;

package/dist/metrics/opentelemetry-metrics.d.ts

@@ -0,0 +1,55 @@
+/**
+ * OpenTelemetry Metrics implementation for storage operations.
+ *
+ * Provides counters, timers, and gauges using OpenTelemetry Metrics API.
+ * This allows integration with any OpenTelemetry-compatible observability backend
+ * (Prometheus, Datadog, New Relic, etc.).
+ * @example
+ * ```typescript
+ * import { metrics } from "@opentelemetry/api";
+ * import { OpenTelemetryMetrics } from "@visulima/storage/metrics";
+ * import { S3Storage } from "@visulima/storage/provider/aws";
+ *
+ * // Initialize OpenTelemetry (typically done once in your app)
+ * const meter = metrics.getMeter("@visulima/storage", "1.0.0");
+ *
+ * // Create metrics instance
+ * const storageMetrics = new OpenTelemetryMetrics(meter);
+ *
+ * // Use with storage
+ * const storage = new S3Storage({
+ *     bucket: "my-bucket",
+ *     metrics: storageMetrics,
+ * });
+ * ```
+ */
+import type { Meter } from "@opentelemetry/api";
+import type { Metrics } from "../utils/types.d.ts";
+/**
+ * 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 default OpenTelemetryMetrics;

package/dist/openapi/index.d.ts

@@ -0,0 +1,5 @@
+export { default as restOpenApiSpec } from "./rest.d.ts";
+export { sharedErrorSchemaObject, sharedFileMetaExampleObject, sharedFileMetaSchemaObject, sharedGet, sharedGetList } from "./shared.d.ts";
+export { default as transformOpenApiSpec } from "./transform.d.ts";
+export { default as tusOpenApiSpec } from "./tus.d.ts";
+export { default as xhrOpenApiSpec } from "./xhr.d.ts";

package/dist/openapi/index.js

@@ -0,0 +1,5 @@
+export { default as restOpenApiSpec } from '../packem_shared/restOpenApiSpec-D1zbmid7.js';
+export { sharedErrorSchemaObject, sharedFileMetaExampleObject, sharedFileMetaSchemaObject, sharedGet, sharedGetList } from '../packem_shared/sharedGet-DAyJfjhl.js';
+export { default as transformOpenApiSpec } from '../packem_shared/transformOpenApiSpec-BC0r6PzI.js';
+export { default as tusOpenApiSpec } from '../packem_shared/tusOpenApiSpec-BLIjKf0s.js';
+export { default as xhrOpenApiSpec } from '../packem_shared/xhrOpenApiSpec-kItrSAsc.js';

package/dist/openapi/rest.d.ts

@@ -0,0 +1,7 @@
+import type { OpenAPIV3 } from "openapi-types";
+declare const swaggerSpec: (origin: string, path: string, options: {
+    supportedTransformerFormat?: string[];
+    tags?: string[] | undefined;
+    transformer?: boolean | "audio" | "video" | "image";
+}) => Partial<OpenAPIV3.Document>;
+export default swaggerSpec;

package/dist/openapi/shared.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIV3 } from "openapi-types";
+type TransformType = boolean | "audio" | "video" | "image";
+declare const getOrganizedTransformationParameters: (transform?: TransformType, format?: string[]) => {
+    groups: Record<string, string[]>;
+    parameters: OpenAPIV3.ParameterObject[];
+};
+export { getOrganizedTransformationParameters };
+export declare const sharedGet: (operationId: string, tags: string[] | undefined, transform?: TransformType, transformerFormat?: string[]) => OpenAPIV3.OperationObject;
+export declare const sharedGetMeta: (operationId: string, tags: string[] | undefined) => OpenAPIV3.OperationObject;
+export declare const sharedErrorSchemaObject: Record<string, OpenAPIV3.NonArraySchemaObject>;
+export declare const sharedFileMetaSchemaObject: Record<string, OpenAPIV3.NonArraySchemaObject>;
+export declare const sharedFileMetaExampleObject: Record<string, OpenAPIV3.ExampleObject>;
+export declare const sharedGetList: (operationId: string, tags: string[] | undefined) => OpenAPIV3.OperationObject;

package/dist/openapi/transform.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from "openapi-types";
+declare const swaggerSpec: (path?: string, tags?: string[] | undefined) => Partial<OpenAPIV3.Document>;
+export default swaggerSpec;

package/dist/openapi/tus.d.ts

@@ -0,0 +1,7 @@
+import type { OpenAPIV3 } from "openapi-types";
+declare const swaggerSpec: (path: string, options: {
+    supportedTransformerFormat?: string[];
+    tags?: string[] | undefined;
+    transformer?: boolean | "audio" | "video" | "image";
+}) => Partial<OpenAPIV3.Document>;
+export default swaggerSpec;

package/dist/openapi/xhr.d.ts

@@ -0,0 +1,7 @@
+import type { OpenAPIV3 } from "openapi-types";
+declare const swaggerSpec: (origin: string, path: string, options: {
+    supportedTransformerFormat?: string[];
+    tags?: string[] | undefined;
+    transformer?: boolean | "audio" | "video" | "image";
+}) => Partial<OpenAPIV3.Document>;
+export default swaggerSpec;

package/dist/packem_shared/AwsLightFile-tTneXZgG.js

@@ -0,0 +1,11 @@
+import File from './File-Bb3P23dr.js';
+
+class AwsLightFile extends File {
+  Parts;
+  UploadId;
+  uri;
+  partsUrls;
+  partSize;
+}
+
+export { AwsLightFile as default };

package/dist/packem_shared/AwsLightMetaStorage-D9qWQt6q.js

@@ -0,0 +1,4 @@
+import './MetaStorage-pECeFOad.js';
+import './Metadata-DRLXeJ0F.js';
+export { A as default } from './aws-light-meta-storage-Ba2b_h-o.js';
+import './is-expired-CTThU1q5.js';

package/dist/packem_shared/AwsLightStorage-CEJTYBVv.js

@@ -0,0 +1,133 @@
+import { Readable } from 'node:stream';
+import { S as S3BaseStorage } from './s3-base-storage-CG21uusd.js';
+import { a as AwsLightApiAdapter, A as AwsLightMetaStorage } from './aws-light-meta-storage-Ba2b_h-o.js';
+import AwsLightFile from './AwsLightFile-tTneXZgG.js';
+
+class AwsLightStorage extends S3BaseStorage {
+  static name = "aws-light";
+  s3Api;
+  constructor(config) {
+    const { bucket = process.env.S3_BUCKET || process.env.AWS_S3_BUCKET, region = process.env.S3_REGION || process.env.AWS_REGION } = config;
+    if (!bucket) {
+      throw new Error("S3 bucket is not defined");
+    }
+    if (!region) {
+      throw new Error("S3 region is not defined");
+    }
+    if (!config.accessKeyId) {
+      throw new Error("accessKeyId is required");
+    }
+    if (!config.secretAccessKey) {
+      throw new Error("secretAccessKey is required");
+    }
+    super({
+      bucket,
+      clientDirectUpload: config.clientDirectUpload,
+      expiration: config.expiration?.maxAge ? { maxAge: String(config.expiration.maxAge) } : void 0,
+      filename: config.filename,
+      logger: config.logger,
+      metaStorage: config.metaStorage,
+      metaStorageConfig: config.metaStorageConfig ? { ...config.metaStorageConfig, ...config } : { ...config },
+      partSize: config.partSize,
+      retryConfig: {
+        ...config.retryConfig,
+        shouldRetry: (error) => {
+          const errorWithStatus = error;
+          if (errorWithStatus.statusCode && [408, 429, 500, 502, 503, 504].includes(errorWithStatus.statusCode)) {
+            return true;
+          }
+          return errorWithStatus.retryable ?? false;
+        }
+      }
+    });
+    this.s3Api = new AwsLightApiAdapter({
+      accessKeyId: config.accessKeyId,
+      bucket,
+      endpoint: config.endpoint,
+      region,
+      secretAccessKey: config.secretAccessKey,
+      service: config.service,
+      sessionToken: config.sessionToken
+    });
+    const { metaStorage, metaStorageConfig } = config;
+    if (!metaStorage) {
+      const metaConfig = { ...config, ...metaStorageConfig, logger: this.logger };
+      this.meta = new AwsLightMetaStorage(metaConfig);
+    }
+  }
+  /**
+   * Normalizes AWS S3 errors with S3-specific context.
+   */
+  normalizeError(error) {
+    const awsError = error;
+    if (awsError.statusCode || awsError.code) {
+      return {
+        code: awsError.code || awsError.name,
+        message: awsError.message,
+        name: awsError.name,
+        statusCode: awsError.statusCode || 500
+      };
+    }
+    return super.normalizeError(error);
+  }
+  async update({ id }, metadata) {
+    if (this.config.clientDirectUpload) {
+      const file = await this.getMeta(id);
+      return this.buildPresigned({ ...file, ...metadata });
+    }
+    return super.update({ id }, metadata);
+  }
+  async getStream({ id }) {
+    return this.instrumentOperation("getStream", async () => {
+      const s3Api = this.getS3Api();
+      const { Body, ContentLength, ContentType, ETag, Expires, LastModified } = await this.retry(
+        () => s3Api.getObject({
+          Bucket: this.bucket,
+          Key: id
+        })
+      );
+      await this.checkIfExpired({ expiredAt: Expires });
+      const stream = Body instanceof ReadableStream ? Readable.fromWeb(Body) : Body;
+      const readableStream = new Readable({
+        read() {
+          stream.on("data", (chunk) => {
+            this.push(chunk);
+          });
+          stream.on("end", () => {
+            this.push(null);
+          });
+          stream.on("error", (error) => {
+            this.destroy(error);
+          });
+        }
+      });
+      return {
+        headers: {
+          "Content-Length": ContentLength?.toString() ?? "0",
+          "Content-Type": ContentType,
+          ...ETag && { ETag },
+          ...Expires && { "X-Upload-Expires": Expires.toString() },
+          ...LastModified && { "Last-Modified": LastModified.toString() }
+        },
+        size: Number(ContentLength),
+        stream: readableStream
+      };
+    });
+  }
+  getS3Api() {
+    return this.s3Api;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getFileClass() {
+    return AwsLightFile;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getAcl() {
+    return void 0;
+  }
+  async accessCheck(_maxWaitTime = 30) {
+    await this.s3Api.checkBucketAccess({ Bucket: this.bucket });
+  }
+}
+
+export { AwsLightStorage as default };