@uploadista/core 0.0.2

package/dist/types/middleware.js

@@ -0,0 +1,21 @@
+import { Context, Effect, Layer } from "effect";
+// Effect-based Middleware service
+export class MiddlewareService extends Context.Tag("MiddlewareService")() {
+}
+export const MiddlewareServiceLive = Layer.succeed(MiddlewareService, MiddlewareService.of({
+    execute: (middlewares, context, handler) => Effect.gen(function* () {
+        if (middlewares.length === 0) {
+            return yield* Effect.tryPromise({
+                try: () => handler(),
+                catch: (error) => error,
+            });
+        }
+        const chain = middlewares.reduceRight((next, middleware) => {
+            return () => middleware(context, next);
+        }, handler);
+        return yield* Effect.tryPromise({
+            try: () => chain(),
+            catch: (error) => error,
+        });
+    }),
+}));

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

@@ -0,0 +1,105 @@
+import { z } from "zod";
+export declare enum UploadEventType {
+    UPLOAD_STARTED = "upload-started",
+    UPLOAD_PROGRESS = "upload-progress",
+    UPLOAD_COMPLETE = "upload-complete",
+    UPLOAD_FAILED = "upload-failed",
+    UPLOAD_VALIDATION_SUCCESS = "upload-validation-success",
+    UPLOAD_VALIDATION_FAILED = "upload-validation-failed",
+    UPLOAD_VALIDATION_WARNING = "upload-validation-warning"
+}
+export declare const uploadEventSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodUnion<readonly [z.ZodLiteral<UploadEventType.UPLOAD_STARTED>, z.ZodLiteral<UploadEventType.UPLOAD_COMPLETE>]>;
+    data: z.ZodObject<{
+        id: z.ZodString;
+        size: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodNumber;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        creationDate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        sizeIsDeferred: z.ZodOptional<z.ZodBoolean>;
+        checksum: z.ZodOptional<z.ZodString>;
+        checksumAlgorithm: z.ZodOptional<z.ZodString>;
+        storage: z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            uploadId: z.ZodOptional<z.ZodString>;
+            bucket: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        flow: z.ZodOptional<z.ZodObject<{
+            flowId: z.ZodString;
+            nodeId: z.ZodString;
+            jobId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<UploadEventType.UPLOAD_PROGRESS>;
+    data: z.ZodObject<{
+        id: z.ZodString;
+        progress: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<UploadEventType.UPLOAD_FAILED>;
+    data: z.ZodObject<{
+        id: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strip>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<UploadEventType.UPLOAD_VALIDATION_SUCCESS>;
+    data: z.ZodObject<{
+        id: z.ZodString;
+        validationType: z.ZodEnum<{
+            checksum: "checksum";
+            mimetype: "mimetype";
+        }>;
+        algorithm: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<UploadEventType.UPLOAD_VALIDATION_FAILED>;
+    data: z.ZodObject<{
+        id: z.ZodString;
+        reason: z.ZodString;
+        expected: z.ZodString;
+        actual: z.ZodString;
+    }, z.core.$strip>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<UploadEventType.UPLOAD_VALIDATION_WARNING>;
+    data: z.ZodObject<{
+        id: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
+export type UploadEvent = z.infer<typeof uploadEventSchema>;
+//# sourceMappingURL=upload-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upload-event.d.ts","sourceRoot":"","sources":["../../src/types/upload-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,oBAAY,eAAe;IACzB,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;IACnC,eAAe,oBAAoB;IACnC,aAAa,kBAAkB;IAC/B,yBAAyB,8BAA8B;IACvD,wBAAwB,6BAA6B;IACrD,yBAAyB,8BAA8B;CACxD;AAQD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAqD5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/types/upload-event.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { uploadFileSchema } from "./upload-file";
+export var UploadEventType;
+(function (UploadEventType) {
+    UploadEventType["UPLOAD_STARTED"] = "upload-started";
+    UploadEventType["UPLOAD_PROGRESS"] = "upload-progress";
+    UploadEventType["UPLOAD_COMPLETE"] = "upload-complete";
+    UploadEventType["UPLOAD_FAILED"] = "upload-failed";
+    UploadEventType["UPLOAD_VALIDATION_SUCCESS"] = "upload-validation-success";
+    UploadEventType["UPLOAD_VALIDATION_FAILED"] = "upload-validation-failed";
+    UploadEventType["UPLOAD_VALIDATION_WARNING"] = "upload-validation-warning";
+})(UploadEventType || (UploadEventType = {}));
+const flowContextSchema = z.object({
+    flowId: z.string(),
+    nodeId: z.string(),
+    jobId: z.string(),
+}).optional();
+export const uploadEventSchema = z.union([
+    z.object({
+        type: z.union([
+            z.literal(UploadEventType.UPLOAD_STARTED),
+            z.literal(UploadEventType.UPLOAD_COMPLETE),
+        ]),
+        data: uploadFileSchema,
+        flow: flowContextSchema,
+    }),
+    z.object({
+        type: z.literal(UploadEventType.UPLOAD_PROGRESS),
+        data: z.object({
+            id: z.string(),
+            progress: z.number(),
+            total: z.number(),
+        }),
+        flow: flowContextSchema,
+    }),
+    z.object({
+        type: z.literal(UploadEventType.UPLOAD_FAILED),
+        data: z.object({
+            id: z.string(),
+            error: z.string(),
+        }),
+        flow: flowContextSchema,
+    }),
+    z.object({
+        type: z.literal(UploadEventType.UPLOAD_VALIDATION_SUCCESS),
+        data: z.object({
+            id: z.string(),
+            validationType: z.enum(["checksum", "mimetype"]),
+            algorithm: z.string().optional(),
+        }),
+        flow: flowContextSchema,
+    }),
+    z.object({
+        type: z.literal(UploadEventType.UPLOAD_VALIDATION_FAILED),
+        data: z.object({
+            id: z.string(),
+            reason: z.string(),
+            expected: z.string(),
+            actual: z.string(),
+        }),
+        flow: flowContextSchema,
+    }),
+    z.object({
+        type: z.literal(UploadEventType.UPLOAD_VALIDATION_WARNING),
+        data: z.object({
+            id: z.string(),
+            message: z.string(),
+        }),
+        flow: flowContextSchema,
+    }),
+]);

package/dist/types/upload-file.d.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+/**
+ * Zod schema for validating UploadFile objects.
+ *
+ * This schema defines the structure and validation rules for upload file metadata.
+ * Use this schema to parse and validate UploadFile data from external sources.
+ *
+ * @see {@link UploadFile} for the TypeScript type
+ */
+export declare const uploadFileSchema: z.ZodObject<{
+    id: z.ZodString;
+    size: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    creationDate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    sizeIsDeferred: z.ZodOptional<z.ZodBoolean>;
+    checksum: z.ZodOptional<z.ZodString>;
+    checksumAlgorithm: z.ZodOptional<z.ZodString>;
+    storage: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        uploadId: z.ZodOptional<z.ZodString>;
+        bucket: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Represents an uploaded file with its metadata and storage information.
+ *
+ * This is the core data structure that tracks file uploads throughout their lifecycle.
+ * It contains all metadata needed to resume uploads, track progress, and locate files
+ * in storage backends.
+ *
+ * @property id - Unique identifier for this upload
+ * @property offset - Current byte offset (how many bytes have been uploaded)
+ * @property storage - Storage backend information
+ * @property storage.id - Storage backend identifier (e.g., "s3-production")
+ * @property storage.type - Storage backend type (e.g., "s3", "azure", "gcs")
+ * @property storage.path - Optional path prefix within the storage backend
+ * @property storage.uploadId - Optional backend-specific upload ID (e.g., S3 multipart upload ID)
+ * @property storage.bucket - Optional bucket or container name
+ * @property flow - Optional flow processing information (when file is part of a flow)
+ * @property flow.flowId - ID of the flow processing this file
+ * @property flow.nodeId - ID of the flow node that created this file
+ * @property flow.jobId - ID of the flow job execution
+ * @property size - Total file size in bytes (undefined if deferred)
+ * @property metadata - Custom key-value metadata attached to the file
+ * @property creationDate - ISO 8601 timestamp when upload was created
+ * @property url - Optional public URL to access the file
+ * @property sizeIsDeferred - True if file size is not known at upload start
+ * @property checksum - Optional file checksum/hash value
+ * @property checksumAlgorithm - Algorithm used for checksum (e.g., "md5", "sha256")
+ *
+ * @example
+ * ```typescript
+ * // Create an UploadFile for a new upload
+ * const uploadFile: UploadFile = {
+ *   id: "upload_abc123",
+ *   offset: 0,
+ *   size: 1024000,
+ *   storage: {
+ *     id: "s3-production",
+ *     type: "s3",
+ *     bucket: "my-uploads",
+ *     path: "files/"
+ *   },
+ *   metadata: {
+ *     fileName: "image.jpg",
+ *     contentType: "image/jpeg",
+ *     userId: "user_123"
+ *   },
+ *   creationDate: new Date().toISOString(),
+ *   checksum: "5d41402abc4b2a76b9719d911017c592",
+ *   checksumAlgorithm: "md5"
+ * };
+ *
+ * // UploadFile with flow processing
+ * const flowFile: UploadFile = {
+ *   id: "upload_xyz789",
+ *   offset: 0,
+ *   size: 2048000,
+ *   storage: {
+ *     id: "s3-temp",
+ *     type: "s3",
+ *     bucket: "temp-processing"
+ *   },
+ *   flow: {
+ *     flowId: "flow_resize_optimize",
+ *     nodeId: "input_1",
+ *     jobId: "job_456"
+ *   }
+ * };
+ *
+ * // Resume an interrupted upload
+ * const resumingFile: UploadFile = {
+ *   id: "upload_resume",
+ *   offset: 524288, // Already uploaded 512KB
+ *   size: 1024000,
+ *   storage: {
+ *     id: "s3-production",
+ *     type: "s3",
+ *     uploadId: "multipart_xyz" // S3 multipart upload ID
+ *   }
+ * };
+ * ```
+ */
+export type UploadFile = {
+    id: string;
+    offset: number;
+    storage: {
+        id: string;
+        type: string;
+        path?: string | undefined;
+        uploadId?: string | undefined;
+        bucket?: string | undefined;
+    };
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    };
+    size?: number | undefined;
+    metadata?: Record<string, string | number | boolean> | undefined;
+    creationDate?: string | undefined;
+    url?: string | undefined;
+    sizeIsDeferred?: boolean | undefined;
+    checksum?: string | undefined;
+    checksumAlgorithm?: string | undefined;
+};
+//# sourceMappingURL=upload-file.d.ts.map

package/dist/types/upload-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-file.d.ts","sourceRoot":"","sources":["../../src/types/upload-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAwB3B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE;QACP,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KAC7B,CAAC;IACF,IAAI,CAAC,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAAC;IACjE,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC,CAAC"}

package/dist/types/upload-file.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+/**
+ * Zod schema for validating UploadFile objects.
+ *
+ * This schema defines the structure and validation rules for upload file metadata.
+ * Use this schema to parse and validate UploadFile data from external sources.
+ *
+ * @see {@link UploadFile} for the TypeScript type
+ */
+export const uploadFileSchema = z.object({
+    id: z.string(),
+    size: z.number().optional(),
+    offset: z.number(),
+    metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+    creationDate: z.string().optional(),
+    url: z.string().optional(),
+    sizeIsDeferred: z.boolean().optional(),
+    checksum: z.string().optional(),
+    checksumAlgorithm: z.string().optional(),
+    storage: z.object({
+        id: z.string(),
+        type: z.string(),
+        path: z.string().optional(),
+        uploadId: z.string().optional(),
+        bucket: z.string().optional(),
+    }),
+    flow: z
+        .object({
+        flowId: z.string(),
+        nodeId: z.string(),
+        jobId: z.string(),
+    })
+        .optional(),
+});

package/dist/types/websocket.d.ts

@@ -0,0 +1,144 @@
+import z from "zod";
+/**
+ * Platform-agnostic WebSocket connection interface
+ */
+export interface WebSocketConnection {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    readonly readyState: number;
+    readonly id: string;
+}
+/**
+ * WebSocket message that can be sent/received
+ */
+export declare const webSocketMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"upload_event">;
+    payload: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodUnion<readonly [z.ZodLiteral<import("./upload-event").UploadEventType.UPLOAD_STARTED>, z.ZodLiteral<import("./upload-event").UploadEventType.UPLOAD_COMPLETE>]>;
+        data: z.ZodObject<{
+            id: z.ZodString;
+            size: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodNumber;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            creationDate: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            sizeIsDeferred: z.ZodOptional<z.ZodBoolean>;
+            checksum: z.ZodOptional<z.ZodString>;
+            checksumAlgorithm: z.ZodOptional<z.ZodString>;
+            storage: z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                uploadId: z.ZodOptional<z.ZodString>;
+                bucket: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            flow: z.ZodOptional<z.ZodObject<{
+                flowId: z.ZodString;
+                nodeId: z.ZodString;
+                jobId: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        flow: z.ZodOptional<z.ZodObject<{
+            flowId: z.ZodString;
+            nodeId: z.ZodString;
+            jobId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("./upload-event").UploadEventType.UPLOAD_PROGRESS>;
+        data: z.ZodObject<{
+            id: z.ZodString;
+            progress: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strip>;
+        flow: z.ZodOptional<z.ZodObject<{
+            flowId: z.ZodString;
+            nodeId: z.ZodString;
+            jobId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("./upload-event").UploadEventType.UPLOAD_FAILED>;
+        data: z.ZodObject<{
+            id: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strip>;
+        flow: z.ZodOptional<z.ZodObject<{
+            flowId: z.ZodString;
+            nodeId: z.ZodString;
+            jobId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("./upload-event").UploadEventType.UPLOAD_VALIDATION_SUCCESS>;
+        data: z.ZodObject<{
+            id: z.ZodString;
+            validationType: z.ZodEnum<{
+                checksum: "checksum";
+                mimetype: "mimetype";
+            }>;
+            algorithm: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        flow: z.ZodOptional<z.ZodObject<{
+            flowId: z.ZodString;
+            nodeId: z.ZodString;
+            jobId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("./upload-event").UploadEventType.UPLOAD_VALIDATION_FAILED>;
+        data: z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodString;
+            expected: z.ZodString;
+            actual: z.ZodString;
+        }, z.core.$strip>;
+        flow: z.ZodOptional<z.ZodObject<{
+            flowId: z.ZodString;
+            nodeId: z.ZodString;
+            jobId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<import("./upload-event").UploadEventType.UPLOAD_VALIDATION_WARNING>;
+        data: z.ZodObject<{
+            id: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>;
+        flow: z.ZodOptional<z.ZodObject<{
+            flowId: z.ZodString;
+            nodeId: z.ZodString;
+            jobId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"flow_event">;
+    payload: z.ZodAny;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"subscribed">;
+    payload: z.ZodObject<{
+        eventKey: z.ZodString;
+    }, z.core.$strip>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"connection">;
+    message: z.ZodOptional<z.ZodString>;
+    uploadId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export type WebSocketMessage<TEvent = unknown> = z.infer<typeof webSocketMessageSchema> | {
+    type: "upload_event";
+    payload: TEvent;
+    timestamp?: string;
+} | {
+    type: "flow_event";
+    payload: TEvent;
+    timestamp?: string;
+};
+//# sourceMappingURL=websocket.d.ts.map

package/dist/types/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../src/types/websocket.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAkCjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,CAAC,MAAM,GAAG,OAAO,IACzC,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,GACtC;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACD;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/types/websocket.js

@@ -0,0 +1,40 @@
+import z from "zod";
+import { uploadEventSchema } from "./upload-event";
+/**
+ * WebSocket message that can be sent/received
+ */
+export const webSocketMessageSchema = z.union([
+    z.object({
+        type: z.literal("upload_event"),
+        payload: uploadEventSchema,
+        timestamp: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("flow_event"),
+        payload: z.any(), // FlowEvent doesn't have a zod schema, using z.any() for now
+        timestamp: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("subscribed"),
+        payload: z.object({ eventKey: z.string() }),
+        timestamp: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("error"),
+        message: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("pong"),
+        timestamp: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("ping"),
+        timestamp: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("connection"),
+        message: z.string().optional(),
+        uploadId: z.string().optional(),
+        timestamp: z.string().optional(),
+    }),
+]);

package/dist/types-BT-cvi7T.cjs

@@ -0,0 +1 @@
+const e=require(`./chunk-CUT6urMc.cjs`),t=require(`./uploadista-error-BB-Wdiz9.cjs`);let n=require(`effect`);n=e.__toESM(n);let r=require(`zod`);r=e.__toESM(r);var i=class extends n.Context.Tag(`UploadFileDataStore`)(){},a=class extends n.Context.Tag(`BufferedUploadFileDataStore`)(){},o=class extends n.Context.Tag(`UploadFileDataStores`)(){},s=class extends n.Context.Tag(`DataStoreRegistry`)(){},c=class{constructor(e,t){this.baseEmitter=e,this.eventToMessage=t}subscribe=(e,t)=>this.baseEmitter.subscribe(e,t);unsubscribe=e=>this.baseEmitter.unsubscribe(e);emit=(e,t)=>{let n=this.eventToMessage(t);return this.baseEmitter.emit(e,n)}};const l=e=>({eventToMessage:t=>JSON.stringify({type:e,payload:t,timestamp:new Date().toISOString()})});var u=class extends n.Context.Tag(`BaseEventEmitter`)(){},d=class extends n.Context.Tag(`UploadEventEmitter`)(){};const f=n.Layer.effect(d,n.Effect.gen(function*(){let e=yield*u;return new c(e,l(`upload_event`).eventToMessage)}));var p=class extends n.Context.Tag(`FlowEventEmitter`)(){};const m=n.Layer.effect(p,n.Effect.gen(function*(){let e=yield*u;return new c(e,l(`flow_event`).eventToMessage)})),h=r.z.object({uploadLengthDeferred:r.z.boolean().optional(),storageId:r.z.string(),size:r.z.number(),type:r.z.string(),fileName:r.z.string().optional(),lastModified:r.z.number().optional(),metadata:r.z.string().optional()});var g=class{constructor(e,t,n){this.baseStore=e,this.serialize=t,this.deserialize=n}get=e=>this.baseStore.get(e).pipe(n.Effect.flatMap(r=>{if(r===null)return n.Effect.fail(t.UploadistaError.fromCode(`FILE_NOT_FOUND`,{cause:`Key "${e}" not found`}));try{return n.Effect.succeed(this.deserialize(r))}catch(r){return n.Effect.fail(new t.UploadistaError({code:`VALIDATION_ERROR`,status:400,body:`Failed to deserialize value for key "${e}"`,cause:r}))}}));set=(e,r)=>{try{let t=this.serialize(r);return this.baseStore.set(e,t)}catch(r){return n.Effect.fail(new t.UploadistaError({code:`VALIDATION_ERROR`,status:400,body:`Failed to serialize value for key "${e}"`,cause:r}))}};delete=e=>this.baseStore.delete(e);list=()=>this.baseStore.list?this.baseStore.list():n.Effect.fail(new t.UploadistaError({code:`UNKNOWN_ERROR`,status:501,body:`List operation not supported by this store`}))};const _={serialize:e=>JSON.stringify(e),deserialize:e=>JSON.parse(e)};var v=class extends n.Context.Tag(`BaseKvStore`)(){},y=class extends n.Context.Tag(`UploadFileKVStore`)(){};const b=n.Layer.effect(y,n.Effect.gen(function*(){let e=yield*v;return new g(e,_.serialize,_.deserialize)}));var x=class extends n.Context.Tag(`FlowJobKVStore`)(){};const S=n.Layer.effect(x,n.Effect.gen(function*(){let e=yield*v;return new g(e,_.serialize,_.deserialize)}));var C=class extends n.Context.Tag(`MiddlewareService`)(){};const w=n.Layer.succeed(C,C.of({execute:(e,t,r)=>n.Effect.gen(function*(){if(e.length===0)return yield*n.Effect.tryPromise({try:()=>r(),catch:e=>e});let i=e.reduceRight((e,n)=>()=>n(t,e),r);return yield*n.Effect.tryPromise({try:()=>i(),catch:e=>e})})})),T=r.z.object({id:r.z.string(),size:r.z.number().optional(),offset:r.z.number(),metadata:r.z.record(r.z.string(),r.z.string()).optional(),creationDate:r.z.string().optional(),url:r.z.string().optional(),sizeIsDeferred:r.z.boolean().optional(),storage:r.z.object({id:r.z.string(),type:r.z.string(),path:r.z.string().optional(),uploadId:r.z.string().optional(),bucket:r.z.string().optional()})});let E=function(e){return e.UPLOAD_STARTED=`upload-started`,e.UPLOAD_PROGRESS=`upload-progress`,e.UPLOAD_COMPLETE=`upload-complete`,e.UPLOAD_FAILED=`upload-failed`,e}({});const D=r.z.union([r.z.object({type:r.z.union([r.z.literal(E.UPLOAD_STARTED),r.z.literal(E.UPLOAD_COMPLETE)]),data:T}),r.z.object({type:r.z.literal(E.UPLOAD_PROGRESS),data:r.z.object({id:r.z.string(),progress:r.z.number(),total:r.z.number()})}),r.z.object({type:r.z.literal(E.UPLOAD_FAILED),data:r.z.object({id:r.z.string(),error:r.z.string()})})]),O=r.default.union([r.default.object({type:r.default.literal(`upload_event`),payload:D,timestamp:r.default.string().optional()}),r.default.object({type:r.default.literal(`flow_event`),payload:r.default.any(),timestamp:r.default.string().optional()}),r.default.object({type:r.default.literal(`subscribed`),payload:r.default.object({uploadId:r.default.string()}),timestamp:r.default.string().optional()}),r.default.object({type:r.default.literal(`error`),message:r.default.string().optional()}),r.default.object({type:r.default.literal(`pong`),timestamp:r.default.string().optional()}),r.default.object({type:r.default.literal(`ping`),timestamp:r.default.string().optional()}),r.default.object({type:r.default.literal(`connection`),message:r.default.string().optional(),uploadId:r.default.string().optional(),timestamp:r.default.string().optional()})]);Object.defineProperty(exports,`BaseEventEmitterService`,{enumerable:!0,get:function(){return u}}),Object.defineProperty(exports,`BaseKvStoreService`,{enumerable:!0,get:function(){return v}}),Object.defineProperty(exports,`BufferedUploadFileDataStore`,{enumerable:!0,get:function(){return a}}),Object.defineProperty(exports,`DataStoreRegistry`,{enumerable:!0,get:function(){return s}}),Object.defineProperty(exports,`FlowEventEmitter`,{enumerable:!0,get:function(){return p}}),Object.defineProperty(exports,`FlowJobKVStore`,{enumerable:!0,get:function(){return x}}),Object.defineProperty(exports,`MiddlewareService`,{enumerable:!0,get:function(){return C}}),Object.defineProperty(exports,`MiddlewareServiceLive`,{enumerable:!0,get:function(){return w}}),Object.defineProperty(exports,`TypedEventEmitter`,{enumerable:!0,get:function(){return c}}),Object.defineProperty(exports,`TypedKvStore`,{enumerable:!0,get:function(){return g}}),Object.defineProperty(exports,`UploadEventEmitter`,{enumerable:!0,get:function(){return d}}),Object.defineProperty(exports,`UploadEventType`,{enumerable:!0,get:function(){return E}}),Object.defineProperty(exports,`UploadFileDataStore`,{enumerable:!0,get:function(){return i}}),Object.defineProperty(exports,`UploadFileDataStores`,{enumerable:!0,get:function(){return o}}),Object.defineProperty(exports,`UploadFileKVStore`,{enumerable:!0,get:function(){return y}}),Object.defineProperty(exports,`eventToMessageSerializer`,{enumerable:!0,get:function(){return l}}),Object.defineProperty(exports,`flowEventEmitter`,{enumerable:!0,get:function(){return m}}),Object.defineProperty(exports,`flowJobKvStore`,{enumerable:!0,get:function(){return S}}),Object.defineProperty(exports,`inputFileSchema`,{enumerable:!0,get:function(){return h}}),Object.defineProperty(exports,`jsonSerializer`,{enumerable:!0,get:function(){return _}}),Object.defineProperty(exports,`uploadEventEmitter`,{enumerable:!0,get:function(){return f}}),Object.defineProperty(exports,`uploadEventSchema`,{enumerable:!0,get:function(){return D}}),Object.defineProperty(exports,`uploadFileKvStore`,{enumerable:!0,get:function(){return b}}),Object.defineProperty(exports,`uploadFileSchema`,{enumerable:!0,get:function(){return T}}),Object.defineProperty(exports,`webSocketMessageSchema`,{enumerable:!0,get:function(){return O}});

package/dist/types-DhU2j-XF.js

@@ -0,0 +1,2 @@
+import{UploadistaError as e}from"./uploadista-error-BVsVxqvz.js";import{Context as t,Effect as n,Layer as r}from"effect";import i,{z as a}from"zod";var o=class extends t.Tag(`UploadFileDataStore`)(){},s=class extends t.Tag(`BufferedUploadFileDataStore`)(){},c=class extends t.Tag(`UploadFileDataStores`)(){},l=class extends t.Tag(`DataStoreRegistry`)(){},u=class{constructor(e,t){this.baseEmitter=e,this.eventToMessage=t}subscribe=(e,t)=>this.baseEmitter.subscribe(e,t);unsubscribe=e=>this.baseEmitter.unsubscribe(e);emit=(e,t)=>{let n=this.eventToMessage(t);return this.baseEmitter.emit(e,n)}};const d=e=>({eventToMessage:t=>JSON.stringify({type:e,payload:t,timestamp:new Date().toISOString()})});var f=class extends t.Tag(`BaseEventEmitter`)(){},p=class extends t.Tag(`UploadEventEmitter`)(){};const m=r.effect(p,n.gen(function*(){let e=yield*f;return new u(e,d(`upload_event`).eventToMessage)}));var h=class extends t.Tag(`FlowEventEmitter`)(){};const g=r.effect(h,n.gen(function*(){let e=yield*f;return new u(e,d(`flow_event`).eventToMessage)})),_=a.object({uploadLengthDeferred:a.boolean().optional(),storageId:a.string(),size:a.number(),type:a.string(),fileName:a.string().optional(),lastModified:a.number().optional(),metadata:a.string().optional()});var v=class{constructor(e,t,n){this.baseStore=e,this.serialize=t,this.deserialize=n}get=t=>this.baseStore.get(t).pipe(n.flatMap(r=>{if(r===null)return n.fail(e.fromCode(`FILE_NOT_FOUND`,{cause:`Key "${t}" not found`}));try{return n.succeed(this.deserialize(r))}catch(r){return n.fail(new e({code:`VALIDATION_ERROR`,status:400,body:`Failed to deserialize value for key "${t}"`,cause:r}))}}));set=(t,r)=>{try{let e=this.serialize(r);return this.baseStore.set(t,e)}catch(r){return n.fail(new e({code:`VALIDATION_ERROR`,status:400,body:`Failed to serialize value for key "${t}"`,cause:r}))}};delete=e=>this.baseStore.delete(e);list=()=>this.baseStore.list?this.baseStore.list():n.fail(new e({code:`UNKNOWN_ERROR`,status:501,body:`List operation not supported by this store`}))};const y={serialize:e=>JSON.stringify(e),deserialize:e=>JSON.parse(e)};var b=class extends t.Tag(`BaseKvStore`)(){},x=class extends t.Tag(`UploadFileKVStore`)(){};const S=r.effect(x,n.gen(function*(){let e=yield*b;return new v(e,y.serialize,y.deserialize)}));var C=class extends t.Tag(`FlowJobKVStore`)(){};const w=r.effect(C,n.gen(function*(){let e=yield*b;return new v(e,y.serialize,y.deserialize)}));var T=class extends t.Tag(`MiddlewareService`)(){};const E=r.succeed(T,T.of({execute:(e,t,r)=>n.gen(function*(){if(e.length===0)return yield*n.tryPromise({try:()=>r(),catch:e=>e});let i=e.reduceRight((e,n)=>()=>n(t,e),r);return yield*n.tryPromise({try:()=>i(),catch:e=>e})})})),D=a.object({id:a.string(),size:a.number().optional(),offset:a.number(),metadata:a.record(a.string(),a.string()).optional(),creationDate:a.string().optional(),url:a.string().optional(),sizeIsDeferred:a.boolean().optional(),storage:a.object({id:a.string(),type:a.string(),path:a.string().optional(),uploadId:a.string().optional(),bucket:a.string().optional()})});let O=function(e){return e.UPLOAD_STARTED=`upload-started`,e.UPLOAD_PROGRESS=`upload-progress`,e.UPLOAD_COMPLETE=`upload-complete`,e.UPLOAD_FAILED=`upload-failed`,e}({});const k=a.union([a.object({type:a.union([a.literal(O.UPLOAD_STARTED),a.literal(O.UPLOAD_COMPLETE)]),data:D}),a.object({type:a.literal(O.UPLOAD_PROGRESS),data:a.object({id:a.string(),progress:a.number(),total:a.number()})}),a.object({type:a.literal(O.UPLOAD_FAILED),data:a.object({id:a.string(),error:a.string()})})]),A=i.union([i.object({type:i.literal(`upload_event`),payload:k,timestamp:i.string().optional()}),i.object({type:i.literal(`flow_event`),payload:i.any(),timestamp:i.string().optional()}),i.object({type:i.literal(`subscribed`),payload:i.object({uploadId:i.string()}),timestamp:i.string().optional()}),i.object({type:i.literal(`error`),message:i.string().optional()}),i.object({type:i.literal(`pong`),timestamp:i.string().optional()}),i.object({type:i.literal(`ping`),timestamp:i.string().optional()}),i.object({type:i.literal(`connection`),message:i.string().optional(),uploadId:i.string().optional(),timestamp:i.string().optional()})]);export{f as BaseEventEmitterService,b as BaseKvStoreService,s as BufferedUploadFileDataStore,l as DataStoreRegistry,h as FlowEventEmitter,C as FlowJobKVStore,T as MiddlewareService,E as MiddlewareServiceLive,u as TypedEventEmitter,v as TypedKvStore,p as UploadEventEmitter,O as UploadEventType,o as UploadFileDataStore,c as UploadFileDataStores,x as UploadFileKVStore,d as eventToMessageSerializer,g as flowEventEmitter,w as flowJobKvStore,_ as inputFileSchema,y as jsonSerializer,m as uploadEventEmitter,k as uploadEventSchema,S as uploadFileKvStore,D as uploadFileSchema,A as webSocketMessageSchema};
+//# sourceMappingURL=types-DhU2j-XF.js.map

package/dist/types-DhU2j-XF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DhU2j-XF.js","names":["baseEmitter: BaseEventEmitter","eventToMessage: (event: TEvent) => string","baseStore: BaseKvStore","serialize: (data: TData) => string","deserialize: (str: string) => TData","z"],"sources":["../src/types/data-store.ts","../src/types/data-store-registry.ts","../src/types/event-emitter.ts","../src/types/input-file.ts","../src/types/kv-store.ts","../src/types/middleware.ts","../src/types/upload-file.ts","../src/types/upload-event.ts","../src/types/websocket.ts"],"sourcesContent":["import type { Effect, Stream } from \"effect\";\nimport { Context } from \"effect\";\nimport type { UploadistaError } from \"../errors/uploadista-error\";\nimport type { UploadFile } from \"./upload-file\";\n\nexport type DataStoreWriteOptions = {\n  file_id: string;\n  stream: Stream.Stream<Uint8Array, UploadistaError>;\n  offset: number;\n};\n\nexport type UploadStrategy = \"single\" | \"parallel\";\n\nexport type DataStoreCapabilities = {\n  supportsParallelUploads: boolean;\n  supportsConcatenation: boolean;\n  supportsDeferredLength: boolean;\n  supportsResumableUploads: boolean;\n  supportsTransactionalUploads: boolean;\n  maxConcurrentUploads?: number;\n  minChunkSize?: number;\n  maxChunkSize?: number;\n  maxParts?: number;\n  optimalChunkSize?: number;\n  requiresOrderedChunks: boolean;\n};\n\nexport type DataStore<TData = unknown> = {\n  readonly bucket?: string;\n  readonly path?: string;\n  readonly create: (file: TData) => Effect.Effect<TData, UploadistaError>;\n  readonly remove: (file_id: string) => Effect.Effect<void, UploadistaError>;\n  readonly read: (\n    file_id: string,\n  ) => Effect.Effect<Uint8Array, UploadistaError>;\n  readonly write: (\n    options: DataStoreWriteOptions,\n    dependencies: {\n      onProgress?: (chunkSize: number) => void;\n    },\n  ) => Effect.Effect<number, UploadistaError>;\n  readonly deleteExpired?: Effect.Effect<number, UploadistaError>;\n  readonly getCapabilities: () => DataStoreCapabilities;\n  readonly validateUploadStrategy: (\n    strategy: UploadStrategy,\n  ) => Effect.Effect<boolean, never>;\n};\n\nexport class UploadFileDataStore extends Context.Tag(\"UploadFileDataStore\")<\n  UploadFileDataStore,\n  DataStore<UploadFile>\n>() {}\n\nexport class BufferedUploadFileDataStore extends Context.Tag(\n  \"BufferedUploadFileDataStore\",\n)<BufferedUploadFileDataStore, DataStore<UploadFile>>() {}\n\nexport type UploadFileDataStoresShape = {\n  getDataStore: (\n    storageId: string,\n    isBuffer?: boolean,\n  ) => Effect.Effect<DataStore<UploadFile>, UploadistaError>;\n};\n\nexport class UploadFileDataStores extends Context.Tag(\"UploadFileDataStores\")<\n  UploadFileDataStores,\n  UploadFileDataStoresShape\n>() {}\n","import { Context, type Effect } from \"effect\";\nimport type { UploadistaError } from \"../errors\";\nimport type { DataStore } from \"./data-store\";\nimport type { UploadFile } from \"./upload-file\";\n\n// Data Store Registry service for managing multiple data stores\nexport class DataStoreRegistry extends Context.Tag(\"DataStoreRegistry\")<\n  DataStoreRegistry,\n  {\n    readonly register: <T extends DataStore<UploadFile>>(\n      id: string,\n      store: Effect.Effect<T, UploadistaError>,\n    ) => Effect.Effect<void, never>;\n    readonly get: (\n      id: string,\n    ) => Effect.Effect<DataStore<UploadFile>, UploadistaError>;\n    readonly list: () => Effect.Effect<Array<string>, never>;\n  }\n>() {}\n","import { Context, Effect, Layer } from \"effect\";\nimport type { UploadistaError } from \"../errors\";\nimport type { FlowEvent } from \"../flow/event\";\nimport type { UploadEvent } from \"./upload-event\";\nimport type { WebSocketConnection } from \"./websocket\";\n\n// Base untyped EventEmitter interface - emits raw strings\nexport interface BaseEventEmitter {\n  readonly subscribe: (\n    key: string,\n    connection: WebSocketConnection,\n  ) => Effect.Effect<void, UploadistaError>;\n  readonly unsubscribe: (key: string) => Effect.Effect<void, UploadistaError>;\n  readonly emit: (\n    key: string,\n    event: string,\n  ) => Effect.Effect<void, UploadistaError>;\n}\n\n// Typed EventEmitter interface - handles serialization/deserialization\nexport type EventEmitter<TEvent> = {\n  readonly subscribe: (\n    key: string,\n    connection: WebSocketConnection,\n  ) => Effect.Effect<void, UploadistaError>;\n  readonly unsubscribe: (key: string) => Effect.Effect<void, UploadistaError>;\n  readonly emit: (\n    key: string,\n    event: TEvent,\n  ) => Effect.Effect<void, UploadistaError>;\n};\n\n// Typed wrapper class that uses a base event emitter with serialization\nexport class TypedEventEmitter<TEvent> implements EventEmitter<TEvent> {\n  constructor(\n    private baseEmitter: BaseEventEmitter,\n    private eventToMessage: (event: TEvent) => string,\n  ) {}\n\n  subscribe = (\n    key: string,\n    connection: WebSocketConnection,\n  ): Effect.Effect<void, UploadistaError> =>\n    this.baseEmitter.subscribe(key, connection);\n\n  unsubscribe = (key: string): Effect.Effect<void, UploadistaError> =>\n    this.baseEmitter.unsubscribe(key);\n\n  emit = (key: string, event: TEvent): Effect.Effect<void, UploadistaError> => {\n    const message = this.eventToMessage(event);\n    return this.baseEmitter.emit(key, message);\n  };\n}\n\n// Default JSON serialization helper\nexport const eventToMessageSerializer = (\n  messageType: \"upload_event\" | \"flow_event\",\n) => ({\n  eventToMessage: <T>(event: T): string =>\n    JSON.stringify({\n      type: messageType,\n      payload: event,\n      timestamp: new Date().toISOString(),\n    }),\n});\n\n// Context tags\nexport class BaseEventEmitterService extends Context.Tag(\"BaseEventEmitter\")<\n  BaseEventEmitterService,\n  BaseEventEmitter\n>() {}\n\nexport class UploadEventEmitter extends Context.Tag(\"UploadEventEmitter\")<\n  UploadEventEmitter,\n  EventEmitter<UploadEvent>\n>() {}\n\nexport const uploadEventEmitter = Layer.effect(\n  UploadEventEmitter,\n  Effect.gen(function* () {\n    const baseEmitter = yield* BaseEventEmitterService;\n    return new TypedEventEmitter<UploadEvent>(\n      baseEmitter,\n      eventToMessageSerializer(\"upload_event\").eventToMessage,\n    );\n  }),\n);\n\nexport class FlowEventEmitter extends Context.Tag(\"FlowEventEmitter\")<\n  FlowEventEmitter,\n  EventEmitter<FlowEvent>\n>() {}\n\nexport const flowEventEmitter = Layer.effect(\n  FlowEventEmitter,\n  Effect.gen(function* () {\n    const baseEmitter = yield* BaseEventEmitterService;\n    return new TypedEventEmitter<FlowEvent>(\n      baseEmitter,\n      eventToMessageSerializer(\"flow_event\").eventToMessage,\n    );\n  }),\n);\n","import { z } from \"zod\";\n\nexport const inputFileSchema = z.object({\n  uploadLengthDeferred: z.boolean().optional(),\n  storageId: z.string(),\n  size: z.number(),\n  type: z.string(),\n  fileName: z.string().optional(),\n  lastModified: z.number().optional(),\n  metadata: z.string().optional(),\n});\n\nexport type InputFile = z.infer<typeof inputFileSchema>;\n","import { Context, Effect, Layer } from \"effect\";\nimport { UploadistaError } from \"../errors\";\nimport type { FlowJob } from \"../flow\";\nimport type { UploadFile } from \"./upload-file\";\n\n// Base untyped KV store interface - stores raw strings\nexport interface BaseKvStore {\n  readonly get: (key: string) => Effect.Effect<string | null, UploadistaError>;\n  readonly set: (\n    key: string,\n    value: string,\n  ) => Effect.Effect<void, UploadistaError>;\n  readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;\n  readonly list?: () => Effect.Effect<Array<string>, UploadistaError>;\n}\n\n// Typed KV store interface - handles serialization/deserialization\nexport type KvStore<TData> = {\n  readonly get: (key: string) => Effect.Effect<TData, UploadistaError>;\n  readonly set: (\n    key: string,\n    value: TData,\n  ) => Effect.Effect<void, UploadistaError>;\n  readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;\n  readonly list?: () => Effect.Effect<Array<string>, UploadistaError>;\n};\n\n// Typed wrapper class that uses a base store with serialization\nexport class TypedKvStore<TData> implements KvStore<TData> {\n  constructor(\n    private baseStore: BaseKvStore,\n    private serialize: (data: TData) => string,\n    private deserialize: (str: string) => TData,\n  ) {}\n\n  get = (key: string): Effect.Effect<TData, UploadistaError> =>\n    this.baseStore.get(key).pipe(\n      Effect.flatMap((value) => {\n        if (value === null) {\n          return Effect.fail(\n            UploadistaError.fromCode(\"FILE_NOT_FOUND\", {\n              cause: `Key \"${key}\" not found`,\n            }),\n          );\n        }\n        try {\n          return Effect.succeed(this.deserialize(value));\n        } catch (error) {\n          return Effect.fail(\n            new UploadistaError({\n              code: \"VALIDATION_ERROR\",\n              status: 400,\n              body: `Failed to deserialize value for key \"${key}\"`,\n              cause: error,\n            }),\n          );\n        }\n      }),\n    );\n\n  set = (key: string, value: TData): Effect.Effect<void, UploadistaError> => {\n    try {\n      const serialized = this.serialize(value);\n      return this.baseStore.set(key, serialized);\n    } catch (error) {\n      return Effect.fail(\n        new UploadistaError({\n          code: \"VALIDATION_ERROR\",\n          status: 400,\n          body: `Failed to serialize value for key \"${key}\"`,\n          cause: error,\n        }),\n      );\n    }\n  };\n\n  delete = (key: string): Effect.Effect<void, UploadistaError> =>\n    this.baseStore.delete(key);\n\n  list = (): Effect.Effect<Array<string>, UploadistaError> => {\n    if (this.baseStore.list) {\n      return this.baseStore.list();\n    }\n    return Effect.fail(\n      new UploadistaError({\n        code: \"UNKNOWN_ERROR\",\n        status: 501,\n        body: \"List operation not supported by this store\",\n      }),\n    );\n  };\n}\n\n// Default JSON serialization helpers\nexport const jsonSerializer = {\n  serialize: <T>(data: T): string => JSON.stringify(data),\n  deserialize: <T>(str: string): T => JSON.parse(str),\n};\n\n// Context tags\nexport class BaseKvStoreService extends Context.Tag(\"BaseKvStore\")<\n  BaseKvStoreService,\n  BaseKvStore\n>() {}\n\nexport class UploadFileKVStore extends Context.Tag(\"UploadFileKVStore\")<\n  UploadFileKVStore,\n  KvStore<UploadFile>\n>() {}\n\nexport const uploadFileKvStore = Layer.effect(\n  UploadFileKVStore,\n  Effect.gen(function* () {\n    const baseStore = yield* BaseKvStoreService;\n    return new TypedKvStore<UploadFile>(\n      baseStore,\n      jsonSerializer.serialize,\n      jsonSerializer.deserialize,\n    );\n  }),\n);\n\nexport class FlowJobKVStore extends Context.Tag(\"FlowJobKVStore\")<\n  FlowJobKVStore,\n  KvStore<FlowJob>\n>() {}\n\nexport const flowJobKvStore = Layer.effect(\n  FlowJobKVStore,\n  Effect.gen(function* () {\n    const baseStore = yield* BaseKvStoreService;\n    return new TypedKvStore<FlowJob>(\n      baseStore,\n      jsonSerializer.serialize,\n      jsonSerializer.deserialize,\n    );\n  }),\n);\n","import { Context, Effect, Layer } from \"effect\";\nimport type { UploadistaError } from \"../errors\";\n\nexport type MiddlewareContext = {\n  request: Request;\n  uploadId?: string;\n  metadata?: Record<string, string>;\n};\n\nexport type MiddlewareNext = () => Promise<Response>;\n\nexport type Middleware = (\n  context: MiddlewareContext,\n  next: MiddlewareNext,\n) => Promise<Response>;\n\n// Effect-based Middleware service\nexport class MiddlewareService extends Context.Tag(\"MiddlewareService\")<\n  MiddlewareService,\n  {\n    readonly execute: (\n      middlewares: Middleware[],\n      context: MiddlewareContext,\n      handler: MiddlewareNext,\n    ) => Effect.Effect<Response, UploadistaError>;\n  }\n>() {}\n\nexport const MiddlewareServiceLive = Layer.succeed(\n  MiddlewareService,\n  MiddlewareService.of({\n    execute: (middlewares, context, handler) =>\n      Effect.gen(function* () {\n        if (middlewares.length === 0) {\n          return yield* Effect.tryPromise({\n            try: () => handler(),\n            catch: (error) => error as UploadistaError,\n          });\n        }\n\n        const chain = middlewares.reduceRight(\n          (next: MiddlewareNext, middleware: Middleware) => {\n            return () => middleware(context, next);\n          },\n          handler,\n        );\n\n        return yield* Effect.tryPromise({\n          try: () => chain(),\n          catch: (error) => error as UploadistaError,\n        });\n      }),\n  }),\n);\n","import { z } from \"zod\";\n\nexport const uploadFileSchema = z.object({\n  id: z.string(),\n  size: z.number().optional(),\n  offset: z.number(),\n  metadata: z.record(z.string(), z.string()).optional(),\n  creationDate: z.string().optional(),\n  url: z.string().optional(),\n  sizeIsDeferred: z.boolean().optional(),\n  storage: z.object({\n    id: z.string(),\n    type: z.string(),\n    path: z.string().optional(),\n    uploadId: z.string().optional(),\n    bucket: z.string().optional(),\n  }),\n});\n\nexport type UploadFile = {\n  id: string;\n  offset: number;\n  storage: {\n    id: string;\n    isBuffer?: boolean;\n    type: string;\n    path?: string | undefined;\n    uploadId?: string | undefined;\n    bucket?: string | undefined;\n  };\n  size?: number | undefined;\n  metadata?: Record<string, string> | undefined;\n  creationDate?: string | undefined;\n  url?: string | undefined;\n  sizeIsDeferred?: boolean | undefined;\n};\n","import { z } from \"zod\";\nimport { uploadFileSchema } from \"./upload-file\";\n\nexport enum UploadEventType {\n  UPLOAD_STARTED = \"upload-started\",\n  UPLOAD_PROGRESS = \"upload-progress\",\n  UPLOAD_COMPLETE = \"upload-complete\",\n  UPLOAD_FAILED = \"upload-failed\",\n}\n\nexport const uploadEventSchema = z.union([\n  z.object({\n    type: z.union([\n      z.literal(UploadEventType.UPLOAD_STARTED),\n      z.literal(UploadEventType.UPLOAD_COMPLETE),\n    ]),\n    data: uploadFileSchema,\n  }),\n  z.object({\n    type: z.literal(UploadEventType.UPLOAD_PROGRESS),\n    data: z.object({\n      id: z.string(),\n      progress: z.number(),\n      total: z.number(),\n    }),\n  }),\n  z.object({\n    type: z.literal(UploadEventType.UPLOAD_FAILED),\n    data: z.object({\n      id: z.string(),\n      error: z.string(),\n    }),\n  }),\n]);\n\nexport type UploadEvent = z.infer<typeof uploadEventSchema>;\n","import z from \"zod\";\nimport { uploadEventSchema } from \"./upload-event\";\n\n/**\n * Platform-agnostic WebSocket connection interface\n */\nexport interface WebSocketConnection {\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  readonly readyState: number;\n  readonly id: string;\n}\n\n/**\n * WebSocket message that can be sent/received\n */\n\nexport const webSocketMessageSchema = z.union([\n  z.object({\n    type: z.literal(\"upload_event\"),\n    payload: uploadEventSchema,\n    timestamp: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"flow_event\"),\n    payload: z.any(), // FlowEvent doesn't have a zod schema, using z.any() for now\n    timestamp: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"subscribed\"),\n    payload: z.object({ uploadId: z.string() }),\n    timestamp: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"error\"),\n    message: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"pong\"),\n    timestamp: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"ping\"),\n    timestamp: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"connection\"),\n    message: z.string().optional(),\n    uploadId: z.string().optional(),\n    timestamp: z.string().optional(),\n  }),\n]);\n\nexport type WebSocketMessage<TEvent = unknown> =\n  | z.infer<typeof webSocketMessageSchema>\n  | {\n      type: \"upload_event\";\n      payload: TEvent;\n      timestamp?: string;\n    }\n  | {\n      type: \"flow_event\";\n      payload: TEvent;\n      timestamp?: string;\n    };\n"],"mappings":"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"}