@uploadista/core 0.0.2

package/dist/types/data-store.d.ts

@@ -0,0 +1,316 @@
+import { Context, Effect, Layer, type Stream } from "effect";
+import { UploadistaError } from "../errors/uploadista-error";
+import type { UploadFileKVStore } from "./kv-store";
+import type { UploadFile } from "./upload-file";
+/**
+ * Options for writing data to a DataStore.
+ *
+ * @property file_id - Unique identifier for the file being written
+ * @property stream - Stream of byte chunks to write to storage
+ * @property offset - Byte offset where writing should begin (for resumable uploads)
+ */
+export type DataStoreWriteOptions = {
+    file_id: string;
+    stream: Stream.Stream<Uint8Array, UploadistaError>;
+    offset: number;
+};
+/**
+ * Upload strategy type indicating how chunks are uploaded.
+ *
+ * - `single`: Upload file in a single request (traditional upload)
+ * - `parallel`: Upload file chunks in parallel (for large files)
+ */
+export type UploadStrategy = "single" | "parallel";
+/**
+ * Capabilities and constraints of a DataStore implementation.
+ *
+ * This type describes what features a storage backend supports and what
+ * limitations it has. Use this to determine the optimal upload strategy
+ * and validate client requests.
+ *
+ * @property supportsParallelUploads - Can upload chunks in parallel (e.g., S3 multipart)
+ * @property supportsConcatenation - Can concatenate multiple uploads into one file
+ * @property supportsDeferredLength - Can start upload without knowing final size
+ * @property supportsResumableUploads - Can resume interrupted uploads from last offset
+ * @property supportsTransactionalUploads - Guarantees atomic upload success/failure
+ * @property maxConcurrentUploads - Maximum parallel upload parts (if parallel supported)
+ * @property minChunkSize - Minimum size in bytes for each chunk (except last)
+ * @property maxChunkSize - Maximum size in bytes for each chunk
+ * @property maxParts - Maximum number of parts in a multipart upload
+ * @property optimalChunkSize - Recommended chunk size for best performance
+ * @property requiresOrderedChunks - Must receive chunks in sequential order
+ * @property requiresMimeTypeValidation - Validates file MIME type matches declaration
+ * @property maxValidationSize - Maximum file size for MIME type validation
+ *
+ * @example
+ * ```typescript
+ * const capabilities = dataStore.getCapabilities();
+ *
+ * if (capabilities.supportsParallelUploads && fileSize > 10_000_000) {
+ *   // Use parallel upload for large files
+ *   const chunkSize = capabilities.optimalChunkSize || 5_242_880; // 5MB default
+ *   uploadInParallel(file, chunkSize);
+ * } else {
+ *   // Use single upload
+ *   uploadAsSingleChunk(file);
+ * }
+ * ```
+ */
+export type DataStoreCapabilities = {
+    supportsParallelUploads: boolean;
+    supportsConcatenation: boolean;
+    supportsDeferredLength: boolean;
+    supportsResumableUploads: boolean;
+    supportsTransactionalUploads: boolean;
+    maxConcurrentUploads?: number;
+    minChunkSize?: number;
+    maxChunkSize?: number;
+    maxParts?: number;
+    optimalChunkSize?: number;
+    requiresOrderedChunks: boolean;
+    requiresMimeTypeValidation?: boolean;
+    maxValidationSize?: number;
+};
+/**
+ * Core interface for all storage backend implementations.
+ *
+ * DataStore abstracts file storage operations across different backends
+ * (S3, Azure Blob, GCS, local filesystem, etc.). All storage adapters
+ * must implement this interface.
+ *
+ * @template TData - The data type stored (typically UploadFile)
+ *
+ * @property bucket - Optional storage bucket or container name
+ * @property path - Optional base path prefix for all stored files
+ * @property create - Creates a new file record in storage
+ * @property remove - Deletes a file from storage
+ * @property read - Reads complete file contents as bytes
+ * @property write - Writes data stream to storage at specified offset
+ * @property deleteExpired - Optional cleanup of expired files
+ * @property getCapabilities - Returns storage backend capabilities
+ * @property validateUploadStrategy - Validates if strategy is supported
+ *
+ * @example
+ * ```typescript
+ * // Implement a custom DataStore
+ * const myDataStore: DataStore<UploadFile> = {
+ *   bucket: "my-uploads",
+ *   path: "files/",
+ *
+ *   create: (file) => Effect.gen(function* () {
+ *     // Store file metadata
+ *     yield* saveMetadata(file);
+ *     return file;
+ *   }),
+ *
+ *   write: ({ file_id, stream, offset }, { onProgress }) => Effect.gen(function* () {
+ *     // Write chunks to storage
+ *     let bytesWritten = offset;
+ *     yield* Stream.runForEach(stream, (chunk) => Effect.sync(() => {
+ *       writeChunk(file_id, chunk, bytesWritten);
+ *       bytesWritten += chunk.byteLength;
+ *       onProgress?.(chunk.byteLength);
+ *     }));
+ *     return bytesWritten;
+ *   }),
+ *
+ *   read: (file_id) => Effect.gen(function* () {
+ *     // Read complete file
+ *     const data = yield* readFromStorage(file_id);
+ *     return data;
+ *   }),
+ *
+ *   remove: (file_id) => Effect.gen(function* () {
+ *     yield* deleteFromStorage(file_id);
+ *   }),
+ *
+ *   getCapabilities: () => ({
+ *     supportsParallelUploads: true,
+ *     supportsConcatenation: false,
+ *     supportsDeferredLength: true,
+ *     supportsResumableUploads: true,
+ *     supportsTransactionalUploads: false,
+ *     maxConcurrentUploads: 10,
+ *     optimalChunkSize: 5_242_880, // 5MB
+ *     requiresOrderedChunks: false,
+ *   }),
+ *
+ *   validateUploadStrategy: (strategy) =>
+ *     Effect.succeed(strategy === "parallel" || strategy === "single"),
+ * };
+ * ```
+ */
+export type DataStore<TData = unknown> = {
+    readonly bucket?: string;
+    readonly path?: string;
+    readonly create: (file: TData) => Effect.Effect<TData, UploadistaError>;
+    readonly remove: (file_id: string) => Effect.Effect<void, UploadistaError>;
+    readonly read: (file_id: string) => Effect.Effect<Uint8Array, UploadistaError>;
+    readonly write: (options: DataStoreWriteOptions, dependencies: {
+        onProgress?: (chunkSize: number) => void;
+    }) => Effect.Effect<number, UploadistaError>;
+    readonly deleteExpired?: Effect.Effect<number, UploadistaError>;
+    readonly getCapabilities: () => DataStoreCapabilities;
+    readonly validateUploadStrategy: (strategy: UploadStrategy) => Effect.Effect<boolean, never>;
+};
+declare const UploadFileDataStore_base: Context.TagClass<UploadFileDataStore, "UploadFileDataStore", DataStore<UploadFile>>;
+/**
+ * Effect-TS context tag for UploadFile DataStore.
+ *
+ * Use this tag to access the primary DataStore in an Effect context.
+ * This is the standard storage backend for uploaded files.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const dataStore = yield* UploadFileDataStore;
+ *   const file = yield* dataStore.create(uploadFile);
+ *   return file;
+ * });
+ * ```
+ */
+export declare class UploadFileDataStore extends UploadFileDataStore_base {
+}
+declare const BufferedUploadFileDataStore_base: Context.TagClass<BufferedUploadFileDataStore, "BufferedUploadFileDataStore", DataStore<UploadFile>>;
+/**
+ * Effect-TS context tag for buffered/temporary DataStore.
+ *
+ * This is an optional storage backend used for temporary or intermediate files
+ * during flow processing. Not all implementations provide a buffered store.
+ *
+ * @example
+ * ```typescript
+ * const processEffect = Effect.gen(function* () {
+ *   const bufferedStore = yield* BufferedUploadFileDataStore;
+ *   // Store intermediate processing results
+ *   const tempFile = yield* bufferedStore.create(intermediateFile);
+ *   return tempFile;
+ * });
+ * ```
+ */
+export declare class BufferedUploadFileDataStore extends BufferedUploadFileDataStore_base {
+}
+/**
+ * Service interface for managing multiple DataStore instances.
+ *
+ * This allows routing files to different storage backends based on
+ * storageId (e.g., different S3 buckets, Azure containers, or storage tiers).
+ *
+ * @property getDataStore - Retrieves the appropriate DataStore for a given storage ID
+ * @property bufferedDataStore - Optional temporary storage for intermediate files
+ */
+export type UploadFileDataStoresShape = {
+    getDataStore: (storageId: string, clientId: string | null) => Effect.Effect<DataStore<UploadFile>, UploadistaError>;
+    bufferedDataStore: Effect.Effect<DataStore<UploadFile> | undefined, UploadistaError>;
+};
+declare const UploadFileDataStores_base: Context.TagClass<UploadFileDataStores, "UploadFileDataStores", UploadFileDataStoresShape>;
+/**
+ * Effect-TS context tag for the DataStore routing service.
+ *
+ * Provides access to multiple DataStore instances with routing logic.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const dataStores = yield* UploadFileDataStores;
+ *   // Route to specific storage based on storageId
+ *   const dataStore = yield* dataStores.getDataStore("s3-production", clientId);
+ *   const file = yield* dataStore.create(uploadFile);
+ *   return file;
+ * });
+ * ```
+ */
+export declare class UploadFileDataStores extends UploadFileDataStores_base {
+}
+/**
+ * Simplified DataStore configuration for easy setup.
+ *
+ * This type allows flexible configuration:
+ * - Single DataStore instance
+ * - Multiple named stores with routing
+ * - Effect that resolves to a DataStore
+ * - Pre-built Effect Layer
+ *
+ * @example
+ * ```typescript
+ * // Single store
+ * const config: DataStoreConfig = s3DataStore;
+ *
+ * // Multiple stores with routing
+ * const config: DataStoreConfig = {
+ *   stores: {
+ *     "s3-prod": s3ProdStore,
+ *     "s3-dev": s3DevStore,
+ *     "local": localFileStore,
+ *   },
+ *   default: "s3-prod"
+ * };
+ *
+ * // Effect that creates a store
+ * const config: DataStoreConfig = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *   return createS3Store(kvStore);
+ * });
+ *
+ * // Pre-built Layer
+ * const config: DataStoreConfig = Layer.succeed(UploadFileDataStores, {...});
+ * ```
+ */
+export type DataStoreConfig = DataStore<UploadFile> | Effect.Effect<DataStore<UploadFile>, never, UploadFileKVStore> | {
+    stores: Record<string, DataStore<UploadFile> | Effect.Effect<DataStore<UploadFile>, never, UploadFileKVStore>>;
+    default?: string;
+} | Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>;
+/**
+ * Type guard to check if a value is a DataStore instance.
+ *
+ * @param config - The value to check
+ * @returns True if the value is a DataStore
+ *
+ * @example
+ * ```typescript
+ * if (isDataStore(config)) {
+ *   const capabilities = config.getCapabilities();
+ * }
+ * ```
+ */
+export declare const isDataStore: (config: DataStoreConfig) => config is DataStore<UploadFile>;
+/**
+ * Creates an Effect Layer from simplified DataStoreConfig.
+ *
+ * This function converts any DataStoreConfig format into a proper Effect Layer
+ * that can be provided to the UploadFileDataStores context tag.
+ *
+ * It handles:
+ * - Single DataStore: Wraps in a Layer that always returns that store
+ * - Multiple stores: Creates routing logic with optional default
+ * - Effect<DataStore>: Executes the Effect and wraps the result
+ * - Layer: Returns as-is
+ *
+ * @param config - The DataStore configuration
+ * @returns A Layer that provides UploadFileDataStores service
+ *
+ * @example
+ * ```typescript
+ * // Create from single store
+ * const layer = await createDataStoreLayer(s3DataStore);
+ *
+ * // Create from multiple stores
+ * const layer = await createDataStoreLayer({
+ *   stores: {
+ *     "production": s3Store,
+ *     "development": localStore,
+ *   },
+ *   default: "development"
+ * });
+ *
+ * // Use the layer
+ * const program = Effect.gen(function* () {
+ *   const stores = yield* UploadFileDataStores;
+ *   const store = yield* stores.getDataStore("production", null);
+ *   return store;
+ * }).pipe(Effect.provide(layer));
+ * ```
+ */
+export declare const createDataStoreLayer: (config: DataStoreConfig) => Promise<Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>>;
+export {};
+//# sourceMappingURL=data-store.d.ts.map

package/dist/types/data-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-store.d.ts","sourceRoot":"","sources":["../../src/types/data-store.ts"],"names":[],"mappings":"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"}

package/dist/types/data-store.js

@@ -0,0 +1,157 @@
+import { Context, Effect, Layer } from "effect";
+import { UploadistaError } from "../errors/uploadista-error";
+/**
+ * Effect-TS context tag for UploadFile DataStore.
+ *
+ * Use this tag to access the primary DataStore in an Effect context.
+ * This is the standard storage backend for uploaded files.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const dataStore = yield* UploadFileDataStore;
+ *   const file = yield* dataStore.create(uploadFile);
+ *   return file;
+ * });
+ * ```
+ */
+export class UploadFileDataStore extends Context.Tag("UploadFileDataStore")() {
+}
+/**
+ * Effect-TS context tag for buffered/temporary DataStore.
+ *
+ * This is an optional storage backend used for temporary or intermediate files
+ * during flow processing. Not all implementations provide a buffered store.
+ *
+ * @example
+ * ```typescript
+ * const processEffect = Effect.gen(function* () {
+ *   const bufferedStore = yield* BufferedUploadFileDataStore;
+ *   // Store intermediate processing results
+ *   const tempFile = yield* bufferedStore.create(intermediateFile);
+ *   return tempFile;
+ * });
+ * ```
+ */
+export class BufferedUploadFileDataStore extends Context.Tag("BufferedUploadFileDataStore")() {
+}
+/**
+ * Effect-TS context tag for the DataStore routing service.
+ *
+ * Provides access to multiple DataStore instances with routing logic.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const dataStores = yield* UploadFileDataStores;
+ *   // Route to specific storage based on storageId
+ *   const dataStore = yield* dataStores.getDataStore("s3-production", clientId);
+ *   const file = yield* dataStore.create(uploadFile);
+ *   return file;
+ * });
+ * ```
+ */
+export class UploadFileDataStores extends Context.Tag("UploadFileDataStores")() {
+}
+/**
+ * Type guard to check if a value is a DataStore instance.
+ *
+ * @param config - The value to check
+ * @returns True if the value is a DataStore
+ *
+ * @example
+ * ```typescript
+ * if (isDataStore(config)) {
+ *   const capabilities = config.getCapabilities();
+ * }
+ * ```
+ */
+export const isDataStore = (config) => {
+    return "create" in config && "write" in config;
+};
+/**
+ * Creates an Effect Layer from simplified DataStoreConfig.
+ *
+ * This function converts any DataStoreConfig format into a proper Effect Layer
+ * that can be provided to the UploadFileDataStores context tag.
+ *
+ * It handles:
+ * - Single DataStore: Wraps in a Layer that always returns that store
+ * - Multiple stores: Creates routing logic with optional default
+ * - Effect<DataStore>: Executes the Effect and wraps the result
+ * - Layer: Returns as-is
+ *
+ * @param config - The DataStore configuration
+ * @returns A Layer that provides UploadFileDataStores service
+ *
+ * @example
+ * ```typescript
+ * // Create from single store
+ * const layer = await createDataStoreLayer(s3DataStore);
+ *
+ * // Create from multiple stores
+ * const layer = await createDataStoreLayer({
+ *   stores: {
+ *     "production": s3Store,
+ *     "development": localStore,
+ *   },
+ *   default: "development"
+ * });
+ *
+ * // Use the layer
+ * const program = Effect.gen(function* () {
+ *   const stores = yield* UploadFileDataStores;
+ *   const store = yield* stores.getDataStore("production", null);
+ *   return store;
+ * }).pipe(Effect.provide(layer));
+ * ```
+ */
+export const createDataStoreLayer = async (config) => {
+    // Already a Layer, return as-is
+    if (Layer.isLayer(config)) {
+        return config;
+    }
+    // Check if it's an Effect
+    if (Effect.isEffect(config)) {
+        return Layer.effect(UploadFileDataStores, Effect.gen(function* () {
+            const dataStore = config;
+            const resolvedStore = yield* dataStore;
+            return {
+                getDataStore: (_storageId) => Effect.succeed(resolvedStore),
+                bufferedDataStore: Effect.succeed(undefined),
+            };
+        }));
+    }
+    // Single store (most common case)
+    if (isDataStore(config)) {
+        const store = config;
+        return Layer.succeed(UploadFileDataStores, {
+            getDataStore: (_storageId) => Effect.succeed(store),
+            bufferedDataStore: Effect.succeed(undefined),
+        });
+    }
+    // Multiple stores with routing
+    const multiConfig = config;
+    const defaultKey = multiConfig.default || Object.keys(multiConfig.stores)[0];
+    // Resolve any Effects in the stores
+    const resolvedStores = {};
+    for (const [key, storeOrEffect] of Object.entries(multiConfig.stores)) {
+        if ("pipe" in storeOrEffect && !("create" in storeOrEffect)) {
+            resolvedStores[key] = await Effect.runPromise(storeOrEffect);
+        }
+        else {
+            resolvedStores[key] = storeOrEffect;
+        }
+    }
+    return Layer.succeed(UploadFileDataStores, {
+        getDataStore: (storageId) => {
+            const store = resolvedStores[storageId] ||
+                (defaultKey ? resolvedStores[defaultKey] : undefined);
+            if (store) {
+                return Effect.succeed(store);
+            }
+            return Effect.fail(UploadistaError.fromCode("FILE_NOT_FOUND"));
+        },
+        bufferedDataStore: Effect.succeed(undefined),
+    });
+};

package/dist/types/event-broadcaster.d.ts

@@ -0,0 +1,28 @@
+import { Context, type Effect } from "effect";
+import type { UploadistaError } from "../errors";
+/**
+ * Event broadcaster interface for pub/sub messaging across distributed instances.
+ * Used by WebSocketManager to broadcast upload events to all connected instances.
+ */
+export interface EventBroadcaster {
+    /**
+     * Publish a message to a channel
+     */
+    readonly publish: (channel: string, message: string) => Effect.Effect<void, UploadistaError>;
+    /**
+     * Subscribe to messages on a channel
+     */
+    readonly subscribe: (channel: string, handler: (message: string) => void) => Effect.Effect<void, UploadistaError>;
+    /**
+     * Unsubscribe from a channel (optional - not all implementations may support)
+     */
+    readonly unsubscribe?: (channel: string) => Effect.Effect<void, UploadistaError>;
+}
+declare const EventBroadcasterService_base: Context.TagClass<EventBroadcasterService, "EventBroadcaster", EventBroadcaster>;
+/**
+ * Context tag for EventBroadcaster service
+ */
+export declare class EventBroadcasterService extends EventBroadcasterService_base {
+}
+export {};
+//# sourceMappingURL=event-broadcaster.d.ts.map

package/dist/types/event-broadcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-broadcaster.d.ts","sourceRoot":"","sources":["../../src/types/event-broadcaster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,KAC/B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CACrB,OAAO,EAAE,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;CAC3C;;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,4BAG1C;CAAG"}

package/dist/types/event-broadcaster.js

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+/**
+ * Context tag for EventBroadcaster service
+ */
+export class EventBroadcasterService extends Context.Tag("EventBroadcaster")() {
+}