@uploadista/core 0.2.0 → 1.0.0-beta.2

package/dist/upload-strategy-negotiator-EmOrc2bn.d.cts

@@ -0,0 +1,455 @@
+import { n as UploadistaError } from "./uploadista-error-eZtG4iyf.cjs";
+import { B as DataStoreCapabilities, G as StreamingConfig, O as WebSocketConnection, Y as UploadStrategy, at as UploadFileKVStore, j as UploadEvent, jn as UploadFile, o as InputFile, q as UploadFileDataStores, rt as KvStore, t as Middleware, w as UploadEventEmitter, x as EventEmitter, z as DataStore } from "./middleware-BlrOGKrp.cjs";
+import { a as GenerateIdShape, t as GenerateId } from "./generate-id-BAMRQzMr.cjs";
+import { Context, Effect, Layer, Stream } from "effect";
+
+//#region src/upload/mime.d.ts
+/**
+ * Detect MIME type from buffer using magic bytes (file signatures).
+ * Supports a wide range of common file types including images, videos, audio, documents, and archives.
+ *
+ * @param buffer - File content as Uint8Array
+ * @param filename - Optional filename for extension-based fallback
+ * @returns Detected MIME type or "application/octet-stream" if unknown
+ */
+declare const detectMimeType: (buffer: Uint8Array, filename?: string) => string;
+/**
+ * Compare two MIME types with lenient matching.
+ * Matches on major type (e.g., "image/*") to allow for minor variations.
+ *
+ * @param declared - MIME type provided by client
+ * @param detected - MIME type detected from file content
+ * @returns true if MIME types are compatible
+ *
+ * @example
+ * compareMimeTypes("image/png", "image/apng") // true
+ * compareMimeTypes("image/jpeg", "image/png") // true (both images)
+ * compareMimeTypes("image/png", "application/pdf") // false
+ */
+declare function compareMimeTypes(declared: string, detected: string): boolean;
+//#endregion
+//#region src/upload/upload-engine.d.ts
+/**
+ * Legacy configuration options for UploadEngine.
+ *
+ * @deprecated Use Effect Layers instead of this configuration object.
+ * This type is kept for backward compatibility.
+ *
+ * @property dataStore - DataStore instance or factory function
+ * @property kvStore - KV store for upload metadata
+ * @property eventEmitter - Event emitter for upload progress
+ * @property generateId - Optional ID generator (defaults to UUID)
+ * @property middlewares - Optional request middlewares
+ * @property withTracing - Enable Effect tracing for debugging
+ */
+type UploadEngineOptions = {
+  dataStore: ((storageId: string) => Promise<DataStore<UploadFile>>) | DataStore<UploadFile>;
+  kvStore: KvStore<UploadFile>;
+  eventEmitter: EventEmitter<UploadEvent>;
+  generateId?: GenerateIdShape;
+  middlewares?: Middleware[];
+  withTracing?: boolean;
+};
+/**
+ * UploadEngine service interface.
+ *
+ * This is the core upload handling service that provides all file upload operations.
+ * It manages upload lifecycle, resumable uploads, progress tracking, and storage integration.
+ *
+ * All operations return Effect types for composable, type-safe error handling.
+ *
+ * @property createUpload - Initiates a new upload and returns metadata
+ * @property uploadChunk - Uploads a chunk of data for an existing upload
+ * @property getCapabilities - Returns storage backend capabilities
+ * @property upload - Complete upload in one operation (create + upload data)
+ * @property uploadFromUrl - Uploads a file from a remote URL
+ * @property getUpload - Retrieves upload metadata by ID
+ * @property read - Reads the complete uploaded file data
+ * @property delete - Deletes an upload and its data
+ * @property subscribeToUploadEvents - Subscribes WebSocket to upload progress events
+ * @property unsubscribeFromUploadEvents - Unsubscribes from upload events
+ *
+ * @example
+ * ```typescript
+ * // Basic upload flow
+ * const program = Effect.gen(function* () {
+ *   const server = yield* UploadEngine;
+ *
+ *   // 1. Create upload
+ *   const inputFile: InputFile = {
+ *     storageId: "s3-production",
+ *     size: 1024000,
+ *     type: "image/jpeg",
+ *     fileName: "photo.jpg"
+ *   };
+ *   const upload = yield* server.createUpload(inputFile, "client123");
+ *
+ *   // 2. Upload chunks
+ *   const chunk = new ReadableStream(...);
+ *   const updated = yield* server.uploadChunk(upload.id, "client123", chunk);
+ *
+ *   // 3. Read the uploaded file
+ *   const data = yield* server.read(upload.id, "client123");
+ *
+ *   return upload;
+ * });
+ *
+ * // Upload with WebSocket progress tracking
+ * const uploadWithProgress = Effect.gen(function* () {
+ *   const server = yield* UploadEngine;
+ *
+ *   // Subscribe to progress events
+ *   yield* server.subscribeToUploadEvents(uploadId, websocket);
+ *
+ *   // Upload (events will be emitted automatically)
+ *   const result = yield* server.upload(inputFile, clientId, stream);
+ *
+ *   // Unsubscribe when done
+ *   yield* server.unsubscribeFromUploadEvents(uploadId);
+ *
+ *   return result;
+ * });
+ *
+ * // Upload from URL
+ * const urlUpload = Effect.gen(function* () {
+ *   const server = yield* UploadEngine;
+ *
+ *   const inputFile: InputFile = {
+ *     storageId: "s3-production",
+ *     size: 0, // Unknown initially
+ *     type: "image/png",
+ *     fileName: "remote-image.png"
+ *   };
+ *
+ *   const upload = yield* server.uploadFromUrl(
+ *     inputFile,
+ *     "client123",
+ *     "https://example.com/image.png"
+ *   );
+ *
+ *   return upload;
+ * });
+ * ```
+ */
+type UploadEngineShape = {
+  createUpload: (inputFile: InputFile, clientId: string | null) => Effect.Effect<UploadFile, UploadistaError>;
+  uploadChunk: (uploadId: string, clientId: string | null, chunk: ReadableStream) => Effect.Effect<UploadFile, UploadistaError>;
+  getCapabilities: (storageId: string, clientId: string | null) => Effect.Effect<DataStoreCapabilities, UploadistaError>;
+  upload: (file: InputFile, clientId: string | null, stream: ReadableStream) => Effect.Effect<UploadFile, UploadistaError>;
+  uploadFromUrl: (inputFile: InputFile, clientId: string | null, url: string) => Effect.Effect<UploadFile, UploadistaError>;
+  getUpload: (uploadId: string) => Effect.Effect<UploadFile, UploadistaError>;
+  /**
+   * Reads the complete uploaded file data as bytes (buffered mode).
+   * For large files, consider using readStream() for memory efficiency.
+   */
+  read: (uploadId: string, clientId: string | null) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Reads file content as a stream of chunks for memory-efficient processing.
+   * Falls back to buffered read if the underlying DataStore doesn't support streaming.
+   *
+   * @param uploadId - The unique identifier of the upload to read
+   * @param clientId - Client identifier for multi-tenant routing
+   * @param config - Optional streaming configuration (chunk size)
+   * @returns An Effect that resolves to a Stream of byte chunks
+   *
+   * @example
+   * ```typescript
+   * const server = yield* UploadEngine;
+   * const stream = yield* server.readStream(uploadId, clientId, { chunkSize: 65536 });
+   * // Process stream chunk by chunk with bounded memory
+   * yield* Stream.runForEach(stream, (chunk) => processChunk(chunk));
+   * ```
+   */
+  readStream: (uploadId: string, clientId: string | null, config?: StreamingConfig) => Effect.Effect<Stream.Stream<Uint8Array, UploadistaError>, UploadistaError>;
+  /**
+   * Uploads file content from a stream with unknown final size.
+   * Creates upload with deferred length, streams content to storage,
+   * and updates the upload record with final size when complete.
+   *
+   * Falls back to buffered upload if the underlying DataStore
+   * doesn't support streaming writes.
+   *
+   * @param file - Input file configuration (size is optional)
+   * @param clientId - Client identifier for multi-tenant routing
+   * @param stream - Effect Stream of byte chunks to upload
+   * @returns The completed UploadFile with final size
+   *
+   * @example
+   * ```typescript
+   * const server = yield* UploadEngine;
+   * const result = yield* server.uploadStream(
+   *   {
+   *     storageId: "s3-production",
+   *     type: "image/webp",
+   *     uploadLengthDeferred: true,
+   *     fileName: "optimized.webp",
+   *   },
+   *   clientId,
+   *   transformedStream,
+   * );
+   * console.log(`Uploaded ${result.size} bytes`);
+   * ```
+   */
+  uploadStream: (file: Omit<InputFile, "size"> & {
+    size?: number;
+    sizeHint?: number;
+  }, clientId: string | null, stream: Stream.Stream<Uint8Array, UploadistaError>) => Effect.Effect<UploadFile, UploadistaError>;
+  delete: (uploadId: string, clientId: string | null) => Effect.Effect<void, UploadistaError>;
+  subscribeToUploadEvents: (uploadId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError>;
+  unsubscribeFromUploadEvents: (uploadId: string) => Effect.Effect<void, UploadistaError>;
+};
+declare const UploadEngine_base: Context.TagClass<UploadEngine, "UploadEngine", UploadEngineShape>;
+/**
+ * Effect-TS context tag for the UploadEngine service.
+ *
+ * Use this tag to access the UploadEngine in an Effect context.
+ * The server must be provided via a Layer or dependency injection.
+ *
+ * @example
+ * ```typescript
+ * // Access UploadEngine in an Effect
+ * const uploadEffect = Effect.gen(function* () {
+ *   const server = yield* UploadEngine;
+ *   const upload = yield* server.createUpload(inputFile, clientId);
+ *   return upload;
+ * });
+ *
+ * // Provide UploadEngine layer
+ * const program = uploadEffect.pipe(
+ *   Effect.provide(uploadEngine),
+ *   Effect.provide(uploadFileKvStore),
+ *   Effect.provide(dataStoreLayer),
+ *   Effect.provide(eventEmitterLayer)
+ * );
+ * ```
+ */
+declare class UploadEngine extends UploadEngine_base {}
+/**
+ * Creates the UploadEngine implementation.
+ *
+ * This function constructs the UploadEngine service by composing all required
+ * dependencies (KV store, data stores, event emitter, ID generator). It implements
+ * all upload operations defined in UploadEngineShape.
+ *
+ * The server automatically handles:
+ * - Upload lifecycle management (create, resume, complete)
+ * - Progress tracking and event emission
+ * - Storage backend routing based on storageId
+ * - Error handling with proper UploadistaError types
+ *
+ * @returns An Effect that yields the UploadEngineShape implementation
+ *
+ * @example
+ * ```typescript
+ * // Create a custom UploadEngine layer
+ * const myUploadEngine = Layer.effect(
+ *   UploadEngine,
+ *   createUploadEngine()
+ * );
+ *
+ * // Use in a program
+ * const program = Effect.gen(function* () {
+ *   const server = yield* UploadEngine;
+ *   // Use server operations...
+ * }).pipe(Effect.provide(myUploadEngine));
+ * ```
+ */
+declare function createUploadEngine(): Effect.Effect<{
+  upload: (inputFile: InputFile, clientId: string | null, stream: ReadableStream) => Effect.Effect<UploadFile, UploadistaError, never>;
+  uploadFromUrl: (inputFile: InputFile, clientId: string | null, url: string) => Effect.Effect<UploadFile, UploadistaError, never>;
+  createUpload: (inputFile: InputFile, clientId: string | null) => Effect.Effect<UploadFile, UploadistaError, never>;
+  uploadChunk: (uploadId: string, clientId: string | null, chunk: ReadableStream) => Effect.Effect<UploadFile, UploadistaError, never>;
+  getUpload: (uploadId: string) => Effect.Effect<UploadFile, UploadistaError, never>;
+  read: (uploadId: string, clientId: string | null) => Effect.Effect<Uint8Array<ArrayBufferLike>, UploadistaError, never>;
+  readStream: (uploadId: string, clientId: string | null, config?: StreamingConfig) => Effect.Effect<Stream.Stream<Uint8Array<ArrayBufferLike>, UploadistaError, never>, UploadistaError, never>;
+  uploadStream: (file: Omit<InputFile, "size"> & {
+    size?: number;
+    sizeHint?: number;
+  }, clientId: string | null, stream: Stream.Stream<Uint8Array, UploadistaError>) => Effect.Effect<UploadFile, UploadistaError, never>;
+  delete: (uploadId: string, clientId: string | null) => Effect.Effect<void, UploadistaError, never>;
+  getCapabilities: (storageId: string, clientId: string | null) => Effect.Effect<DataStoreCapabilities, UploadistaError, never>;
+  subscribeToUploadEvents: (uploadId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError, never>;
+  unsubscribeFromUploadEvents: (uploadId: string) => Effect.Effect<void, UploadistaError, never>;
+}, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
+/**
+ * Pre-built UploadEngine Effect Layer.
+ *
+ * This layer provides a ready-to-use UploadEngine implementation that can be
+ * composed with other layers to build a complete upload system.
+ *
+ * Required dependencies:
+ * - UploadFileKVStore: For storing upload metadata
+ * - UploadFileDataStores: For routing to storage backends
+ * - UploadEventEmitter: For progress events
+ * - GenerateId: For creating upload IDs
+ *
+ * @example
+ * ```typescript
+ * // Compose a complete upload system
+ * const fullUploadSystem = Layer.mergeAll(
+ *   uploadEngine,
+ *   uploadFileKvStore,
+ *   dataStoreLayer,
+ *   uploadEventEmitter,
+ *   generateIdLayer
+ * );
+ *
+ * // Use in application
+ * const app = Effect.gen(function* () {
+ *   const server = yield* UploadEngine;
+ *   // Perform uploads...
+ * }).pipe(Effect.provide(fullUploadSystem));
+ * ```
+ */
+declare const uploadEngine: Layer.Layer<UploadEngine, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
+//#endregion
+//#region src/upload/upload-strategy-negotiator.d.ts
+/**
+ * Configuration options for upload strategy negotiation.
+ *
+ * @property fileSize - Size of the file to be uploaded in bytes
+ * @property preferredStrategy - Preferred upload strategy (single, parallel, resumable)
+ * @property preferredChunkSize - Preferred chunk size in bytes
+ * @property parallelUploads - Number of parallel upload connections
+ * @property minChunkSizeForParallel - Minimum file size to consider parallel uploads
+ */
+type UploadStrategyOptions = {
+  fileSize: number;
+  preferredStrategy?: UploadStrategy;
+  preferredChunkSize?: number;
+  parallelUploads?: number;
+  minChunkSizeForParallel?: number;
+};
+/**
+ * Result of upload strategy negotiation.
+ *
+ * @property strategy - The negotiated upload strategy
+ * @property chunkSize - The negotiated chunk size in bytes
+ * @property parallelUploads - The negotiated number of parallel uploads
+ * @property reasoning - Array of reasoning strings explaining the decisions
+ * @property warnings - Array of warning messages about adjustments made
+ */
+type NegotiatedStrategy = {
+  strategy: UploadStrategy;
+  chunkSize: number;
+  parallelUploads: number;
+  reasoning: string[];
+  warnings: string[];
+};
+/**
+ * Negotiates the optimal upload strategy based on data store capabilities and file characteristics.
+ *
+ * This class analyzes data store capabilities, file size, and user preferences to determine
+ * the best upload strategy (single, parallel, resumable) and optimal parameters like chunk size
+ * and parallel connection count.
+ *
+ * The negotiator considers:
+ * - Data store capabilities (parallel uploads, resumable uploads, concatenation)
+ * - File size and chunk size constraints
+ * - User preferences and requirements
+ * - Performance optimization opportunities
+ *
+ * @example
+ * ```typescript
+ * // Create negotiator for S3 data store
+ * const negotiator = new UploadStrategyNegotiator(
+ *   s3Capabilities,
+ *   (strategy) => s3Capabilities.supportsStrategy(strategy)
+ * );
+ *
+ * // Negotiate strategy for large file
+ * const result = negotiator.negotiateStrategy({
+ *   fileSize: 100_000_000, // 100MB
+ *   preferredStrategy: "parallel",
+ *   preferredChunkSize: 5_000_000, // 5MB chunks
+ *   parallelUploads: 4
+ * });
+ *
+ * console.log(result.strategy); // "parallel"
+ * console.log(result.chunkSize); // 5_000_000
+ * console.log(result.reasoning); // ["Using preferred strategy: parallel", ...]
+ * ```
+ */
+declare class UploadStrategyNegotiator {
+  private capabilities;
+  private validateUploadStrategy;
+  /**
+   * Creates a new upload strategy negotiator.
+   *
+   * @param capabilities - Data store capabilities and constraints
+   * @param validateUploadStrategy - Function to validate if a strategy is supported
+   */
+  constructor(capabilities: DataStoreCapabilities, validateUploadStrategy: (strategy: UploadStrategy) => boolean);
+  /**
+   * Negotiates the optimal upload strategy based on options and data store capabilities.
+   *
+   * This method analyzes the provided options and data store capabilities to determine
+   * the best upload strategy, chunk size, and parallel upload settings. It considers
+   * user preferences, file size, and data store constraints to make optimal decisions.
+   *
+   * The negotiation process:
+   * 1. Validates preferred strategy against data store capabilities
+   * 2. Automatically selects strategy based on file size and capabilities
+   * 3. Adjusts chunk size to fit within data store constraints
+   * 4. Validates parallel upload settings
+   * 5. Ensures final strategy is supported by the data store
+   *
+   * @param options - Upload strategy options including file size and preferences
+   * @returns Negotiated strategy with reasoning and warnings
+   *
+   * @example
+   * ```typescript
+   * const result = negotiator.negotiateStrategy({
+   *   fileSize: 50_000_000, // 50MB
+   *   preferredStrategy: "parallel",
+   *   preferredChunkSize: 5_000_000, // 5MB
+   *   parallelUploads: 3
+   * });
+   *
+   * console.log(result.strategy); // "parallel"
+   * console.log(result.chunkSize); // 5_000_000
+   * console.log(result.parallelUploads); // 3
+   * console.log(result.reasoning); // ["Using preferred strategy: parallel", ...]
+   * console.log(result.warnings); // [] (no warnings)
+   * ```
+   */
+  negotiateStrategy(options: UploadStrategyOptions): NegotiatedStrategy;
+  /**
+   * Gets the data store capabilities used by this negotiator.
+   *
+   * @returns The data store capabilities and constraints
+   */
+  getDataStoreCapabilities(): DataStoreCapabilities;
+  /**
+   * Validates upload strategy configuration against data store capabilities.
+   *
+   * This method checks if the provided configuration is valid for the current
+   * data store capabilities without performing the actual negotiation. It's
+   * useful for pre-validation before attempting to negotiate a strategy.
+   *
+   * @param options - Upload strategy options to validate
+   * @returns Validation result with validity flag and error messages
+   *
+   * @example
+   * ```typescript
+   * const validation = negotiator.validateConfiguration({
+   *   fileSize: 10_000_000,
+   *   preferredStrategy: "parallel",
+   *   preferredChunkSize: 1_000_000,
+   *   parallelUploads: 5
+   * });
+   *
+   * if (!validation.valid) {
+   *   console.log("Configuration errors:", validation.errors);
+   *   // Handle validation errors
+   * }
+   * ```
+   */
+  validateConfiguration(options: UploadStrategyOptions): {
+    valid: boolean;
+    errors: string[];
+  };
+}
+//#endregion
+export { UploadEngineOptions as a, uploadEngine as c, UploadEngine as i, compareMimeTypes as l, UploadStrategyNegotiator as n, UploadEngineShape as o, UploadStrategyOptions as r, createUploadEngine as s, NegotiatedStrategy as t, detectMimeType as u };
+//# sourceMappingURL=upload-strategy-negotiator-EmOrc2bn.d.cts.map

package/dist/upload-strategy-negotiator-EmOrc2bn.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-strategy-negotiator-EmOrc2bn.d.cts","names":[],"sources":["../src/upload/mime.ts","../src/upload/upload-engine.ts","../src/upload/upload-strategy-negotiator.ts"],"mappings":"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"}