@uploadista/adapters-express 0.0.3

package/dist/uploadista-adapter.d.ts

@@ -0,0 +1,78 @@
+import type { IncomingMessage } from "node:http";
+import type { EventBroadcasterService, UploadFileDataStores, UploadistaError } from "@uploadista/core";
+import { type Flow, FlowProvider, FlowServer } from "@uploadista/core/flow";
+import { type BaseEventEmitterService, type BaseKvStoreService, type DataStoreConfig, type UploadFileDataStore, type UploadFileKVStore } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { type GenerateId } from "@uploadista/core/utils";
+import { type MetricsService } from "@uploadista/observability";
+import { type AuthCacheConfig, type AuthResult } from "@uploadista/server";
+import { Effect, Layer } from "effect";
+import type { Request, Response } from "express";
+import type { z } from "zod";
+import { type WebSocketConnection, type WebSocketHandlers } from "./uploadista-adapter-layer";
+export type ExpressUploadistaAdapterOptions<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<Flow<z.ZodSchema<unknown>, z.ZodSchema<unknown>, unknown>, UploadistaError, unknown> = any, TPlugins extends readonly Layer.Layer<any, never, never>[] = Layer.Layer<any, never, never>[]> = {
+    flows: TFlows;
+    plugins?: TPlugins;
+    dataStore: DataStoreConfig;
+    bufferedDataStore?: Layer.Layer<UploadFileDataStore, never, UploadFileKVStore>;
+    baseUrl?: string;
+    kvStore: Layer.Layer<BaseKvStoreService>;
+    eventEmitter?: Layer.Layer<BaseEventEmitterService>;
+    eventBroadcaster?: Layer.Layer<EventBroadcasterService>;
+    generateId?: Layer.Layer<GenerateId>;
+    withTracing?: boolean;
+    authMiddleware?: (req: Request, res: Response) => Promise<AuthResult>;
+    authCacheConfig?: AuthCacheConfig;
+    metricsLayer?: Layer.Layer<MetricsService, never, never>;
+};
+export type InternalExpressUploadistaAdapterOptions<TRequirements = never, TPlugins extends readonly Layer.Layer<TRequirements, never, never>[] = []> = {
+    flowProvider: Layer.Layer<FlowProvider>;
+    plugins?: TPlugins;
+    dataStore: Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>;
+    bufferedDataStore?: Layer.Layer<UploadFileDataStore, never, UploadFileKVStore>;
+    baseUrl: string;
+    kvStore: Layer.Layer<BaseKvStoreService>;
+    eventEmitter: Layer.Layer<BaseEventEmitterService>;
+    generateId?: Layer.Layer<GenerateId>;
+    withTracing?: boolean;
+    authMiddleware?: (req: Request, res: Response) => Promise<AuthResult>;
+    authCacheConfig?: AuthCacheConfig;
+    metricsLayer?: Layer.Layer<MetricsService, never, never>;
+};
+export type ExpressUploadistaAdapter = {
+    baseUrl: string;
+    handler: (req: Request, res: Response, next?: (error?: Error) => void) => void;
+    websocketHandler: (req: IncomingMessage, connection: WebSocketConnection) => WebSocketHandlers;
+    websocketConnectionHandler: (ws: WebSocket, req: IncomingMessage) => void;
+};
+interface WebSocket {
+    readyState: number;
+    OPEN: number;
+    send: (data: string) => void;
+    close: (code?: number, reason?: string) => void;
+    on: (event: string, handler: (...args: any[]) => void) => void;
+}
+export type ExpressUploadistaServer = {
+    handler: (req: Request, res: Response) => Effect.Effect<void, never, never>;
+    uploadServer: Layer.Layer<UploadServer>;
+    flowServer: Layer.Layer<FlowServer>;
+    websocketHandler: (req: IncomingMessage, connection: WebSocketConnection) => WebSocketHandlers;
+};
+/**
+ * Creates an Effect-native unified Express server - combining upload and flow capabilities
+ */
+export declare const createExpressUploadistaServer: <TRequirements = UploadServer>({ baseUrl, flowProvider, eventEmitter, dataStore, bufferedDataStore, kvStore, generateId, authMiddleware, authCacheConfig, metricsLayer, }: InternalExpressUploadistaAdapterOptions<TRequirements>) => Effect.Effect<ExpressUploadistaServer>;
+/**
+ * Creates a Promise-based Express adapter for compatibility with existing Express applications
+ * This wraps the Effect-native version with Promise conversion and caches the server instance
+ */
+export declare const createInternalExpressUploadistaAdapter: <TRequirements = UploadServer, TPlugins extends readonly Layer.Layer<TRequirements, never, never>[] = []>({ baseUrl, flowProvider, plugins, eventEmitter, dataStore, bufferedDataStore, kvStore, withTracing, authMiddleware, authCacheConfig, metricsLayer, }: InternalExpressUploadistaAdapterOptions<TRequirements, TPlugins>) => Promise<ExpressUploadistaAdapter>;
+/**
+ * Creates a Promise-based Uploadista Express adapter for compatibility
+ *
+ * Note: Ensure that the plugins array provides all services required by your flows.
+ * Missing plugin services will result in runtime errors during flow execution.
+ */
+export declare const createExpressUploadistaAdapter: <TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<Flow<z.ZodSchema<unknown>, z.ZodSchema<unknown>, unknown>, UploadistaError, unknown> = any, TPlugins extends readonly Layer.Layer<any, never, never>[] = Layer.Layer<any, never, never>[]>({ baseUrl, flows, plugins, eventEmitter, eventBroadcaster, dataStore, bufferedDataStore, kvStore, generateId, authMiddleware, authCacheConfig, metricsLayer, }: ExpressUploadistaAdapterOptions<TFlows, TPlugins>) => Promise<ExpressUploadistaAdapter>;
+export {};
+//# sourceMappingURL=uploadista-adapter.d.ts.map

package/dist/uploadista-adapter.d.ts.map

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

package/dist/uploadista-adapter.js

@@ -0,0 +1,297 @@
+import { FlowProvider, FlowServer } from "@uploadista/core/flow";
+import { createDataStoreLayer, } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { GenerateIdLive } from "@uploadista/core/utils";
+import { memoryEventBroadcaster } from "@uploadista/event-broadcaster-memory";
+import { webSocketEventEmitter } from "@uploadista/event-emitter-websocket";
+import { NodeSdkLive, NoOpMetricsServiceLive, } from "@uploadista/observability";
+import { AuthCacheServiceLive, AuthContextServiceLive, createFlowServerLayer, createUploadServerLayer, } from "@uploadista/server";
+import { Effect, Layer } from "effect";
+import { handleContinueFlow, handleFlowGet, handleFlowPost, handleJobStatus, } from "./flow-http-handlers";
+import { handleUploadGet, handleUploadPatch, handleUploadPost, } from "./upload-http-handlers";
+import { ExpressUploadistaAdapterService, } from "./uploadista-adapter-layer";
+import { createUploadistaWebSocketHandler } from "./uploadista-websocket-handler";
+// Effect-based service factory for creating the unified adapter layer
+const createExpressUploadistaAdapterServiceLayer = (baseUrl, authMiddleware, authCacheConfig, metricsLayer) => Layer.effect(ExpressUploadistaAdapterService, Effect.gen(function* () {
+    const uploadServer = yield* UploadServer;
+    const flowServer = yield* FlowServer;
+    // Create auth cache layer (always present, even if auth is not enabled)
+    const authCacheLayer = AuthCacheServiceLive(authCacheConfig);
+    return {
+        handler: (req, res) => Effect.gen(function* () {
+            // Call auth middleware if configured and create auth context layer
+            let authContext = null;
+            if (authMiddleware) {
+                // Run auth middleware with timeout protection (5 seconds default)
+                const authMiddlewareWithTimeout = Effect.tryPromise({
+                    try: () => authMiddleware(req, res),
+                    catch: (error) => {
+                        console.error("Auth middleware error:", error);
+                        return { _tag: "AuthError", error };
+                    },
+                }).pipe(Effect.timeout("5 seconds"), Effect.catchAll((error) => {
+                    // Check if timeout occurred
+                    if (error && typeof error === "object" && "_tag" in error) {
+                        if (error._tag === "TimeoutException") {
+                            console.error("Auth middleware timeout exceeded (5 seconds)");
+                            return Effect.succeed({
+                                _tag: "TimeoutError",
+                            });
+                        }
+                    }
+                    return Effect.succeed(null);
+                }));
+                const authResult = yield* authMiddlewareWithTimeout;
+                // If auth middleware timed out, return 503 Service Unavailable
+                if (authResult &&
+                    typeof authResult === "object" &&
+                    "_tag" in authResult &&
+                    authResult._tag === "TimeoutError") {
+                    res.status(503).json({
+                        error: "Authentication service unavailable",
+                        message: "Authentication took too long to respond. Please try again.",
+                    });
+                    return;
+                }
+                // If auth middleware returned null, authentication failed
+                if (authResult === null) {
+                    res.status(401).json({
+                        error: "Unauthorized",
+                        message: "Invalid credentials",
+                    });
+                    return;
+                }
+                // Check for error marker (shouldn't happen after catchAll, but for type safety)
+                if (authResult &&
+                    typeof authResult === "object" &&
+                    "_tag" in authResult &&
+                    authResult._tag === "AuthError") {
+                    res.status(500).json({
+                        error: "Internal Server Error",
+                        message: "An error occurred during authentication",
+                    });
+                    return;
+                }
+                authContext = authResult;
+            }
+            // Create auth context layer for this request
+            const authContextLayer = AuthContextServiceLive(authContext);
+            // Combine auth context, auth cache, and metrics layers
+            // Always provide a metrics layer (either real or no-op) to satisfy type requirements
+            const authLayer = Layer.mergeAll(authContextLayer, authCacheLayer, metricsLayer ?? NoOpMetricsServiceLive);
+            const url = new URL(req.url, `http://${req.get("host")}`);
+            // Check for uploadista/api/ prefix
+            if (!url.pathname.includes(`${baseUrl}/api/`)) {
+                res.status(404).json({ error: "Not found" });
+                return;
+            }
+            // Remove the prefix and get the actual route segments
+            const routeSegments = url.pathname
+                .replace(`${baseUrl}/api/`, "")
+                .split("/")
+                .filter(Boolean);
+            // Parse JSON body for routes that need it
+            const needsJsonBody = (routeSegments.includes("upload") && req.method === "POST") ||
+                (routeSegments.includes("flow") && req.method === "POST") ||
+                (routeSegments.includes("continue") &&
+                    req.get("Content-Type")?.includes("application/json"));
+            if (needsJsonBody && !req.body) {
+                // Manually parse JSON body
+                yield* Effect.tryPromise({
+                    try: async () => {
+                        const chunks = [];
+                        for await (const chunk of req) {
+                            chunks.push(chunk);
+                        }
+                        const body = Buffer.concat(chunks).toString();
+                        req.body = JSON.parse(body);
+                    },
+                    catch: (error) => error,
+                });
+            }
+            // Route based on path
+            if (routeSegments.includes("upload")) {
+                // Upload API routes - these now create jobs behind the scenes
+                switch (req.method) {
+                    case "POST":
+                        return yield* handleUploadPost(req, res, uploadServer).pipe(Effect.provide(authLayer));
+                    case "GET":
+                        return yield* handleUploadGet(req, res, uploadServer).pipe(Effect.provide(authLayer));
+                    case "PATCH":
+                        return yield* handleUploadPatch(req, res, uploadServer).pipe(Effect.provide(authLayer));
+                    default:
+                        res.status(405).json({ error: "Method not allowed" });
+                        return;
+                }
+            }
+            else if (routeSegments.includes("flow")) {
+                // Flow API routes
+                switch (req.method) {
+                    case "GET":
+                        return yield* handleFlowGet(req, res, flowServer).pipe(Effect.provide(authLayer));
+                    case "POST":
+                        return yield* handleFlowPost(req, res, flowServer).pipe(Effect.provide(authLayer));
+                    default:
+                        res.status(405).json({ error: "Method not allowed" });
+                        return;
+                }
+            }
+            else if (routeSegments.includes("jobs")) {
+                // Unified job status routes
+                if (req.method === "GET" && url.pathname.endsWith("/status")) {
+                    return yield* handleJobStatus(req, res, flowServer).pipe(Effect.provide(authLayer));
+                }
+                else if (req.method === "PATCH" &&
+                    routeSegments.includes("continue")) {
+                    return yield* handleContinueFlow(req, res, flowServer).pipe(Effect.provide(authLayer));
+                }
+                res.status(405).json({ error: "Method not allowed" });
+                return;
+            }
+            else {
+                res.status(404).json({ error: "Not found" });
+                return;
+            }
+        }).pipe(Effect.catchAll(() => Effect.sync(() => {
+            res.status(500).json({ error: "Internal server error" });
+        }))),
+        websocketHandler: createUploadistaWebSocketHandler(baseUrl, uploadServer, flowServer),
+    };
+}));
+/**
+ * Creates an Effect-native unified Express server - combining upload and flow capabilities
+ */
+export const createExpressUploadistaServer = ({ baseUrl, flowProvider, eventEmitter, dataStore, bufferedDataStore, kvStore, generateId = GenerateIdLive, authMiddleware, authCacheConfig, metricsLayer, }) => {
+    // Set up upload server dependencies using shared utility
+    const uploadServerLayer = createUploadServerLayer({
+        kvStore,
+        eventEmitter,
+        dataStore,
+        bufferedDataStore,
+        generateId,
+    });
+    // Set up flow server dependencies using shared utility
+    const flowServerLayer = createFlowServerLayer({
+        kvStore,
+        eventEmitter,
+        flowProvider,
+        uploadServer: uploadServerLayer,
+    });
+    // Set up adapter
+    const adapterLayer = Layer.provide(createExpressUploadistaAdapterServiceLayer(baseUrl, authMiddleware, authCacheConfig, metricsLayer), Layer.mergeAll(uploadServerLayer, flowServerLayer));
+    return Effect.gen(function* () {
+        const adapterService = yield* ExpressUploadistaAdapterService;
+        return {
+            handler: (req, res) => adapterService.handler(req, res),
+            websocketHandler: (req, connection) => adapterService.websocketHandler(req, connection),
+            uploadServer: uploadServerLayer,
+            flowServer: flowServerLayer,
+        };
+    }).pipe(Effect.provide(adapterLayer));
+};
+const runProgram = (effect, withTracing) => {
+    if (withTracing) {
+        return Effect.runPromise(effect.pipe(Effect.provide(NodeSdkLive)));
+    }
+    return Effect.runPromise(effect);
+};
+/**
+ * Creates a Promise-based Express adapter for compatibility with existing Express applications
+ * This wraps the Effect-native version with Promise conversion and caches the server instance
+ */
+export const createInternalExpressUploadistaAdapter = async ({ baseUrl, flowProvider, plugins, eventEmitter, dataStore, bufferedDataStore, kvStore, withTracing = false, authMiddleware, authCacheConfig, metricsLayer, }) => {
+    // Create and cache the Effect server instance
+    const uploadistaServer = await Effect.runPromise(createExpressUploadistaServer({
+        baseUrl,
+        flowProvider,
+        eventEmitter,
+        dataStore,
+        bufferedDataStore,
+        kvStore,
+        authMiddleware,
+        authCacheConfig,
+        metricsLayer,
+    }));
+    // Merge all plugin layers so we can provide them when running handlers
+    const pluginLayers = Layer.mergeAll(uploadistaServer.uploadServer, ...(plugins ?? []));
+    return {
+        baseUrl,
+        handler: (req, res, next) => {
+            runProgram(uploadistaServer.handler(req, res).pipe(Effect.provide(pluginLayers)), withTracing).catch((error) => {
+                console.error("Express adapter error:", error);
+                if (next)
+                    next(error);
+            });
+        },
+        websocketHandler: (req, connection) => uploadistaServer.websocketHandler(req, connection),
+        websocketConnectionHandler: (ws, req) => {
+            // Filter to only handle uploadista WebSocket paths
+            if (!req.url?.startsWith(`/${baseUrl}/ws/`)) {
+                ws.close(1008, "Invalid WebSocket path");
+                return;
+            }
+            console.log(`📡 WebSocket connected: ${req.url}`);
+            const connection = {
+                id: `conn_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+                send: (data) => {
+                    if (ws.readyState === ws.OPEN) {
+                        ws.send(data);
+                    }
+                },
+                close: (code, reason) => ws.close(code, reason),
+                readyState: ws.readyState,
+            };
+            // Initialize WebSocket handler with Uploadista and get event handlers
+            const handlers = uploadistaServer.websocketHandler(req, connection);
+            // Attach event handlers
+            ws.on("message", (message) => {
+                handlers.onMessage(message.toString());
+            });
+            ws.on("close", () => {
+                handlers.onClose();
+            });
+            ws.on("error", (error) => {
+                handlers.onError(error);
+            });
+        },
+    };
+};
+/**
+ * Creates a Promise-based Uploadista Express adapter for compatibility
+ *
+ * Note: Ensure that the plugins array provides all services required by your flows.
+ * Missing plugin services will result in runtime errors during flow execution.
+ */
+export const createExpressUploadistaAdapter = async ({ baseUrl = "uploadista", flows, 
+// Default to an empty plugin list while preserving the generic type
+plugins = [], eventEmitter, eventBroadcaster = memoryEventBroadcaster, dataStore, bufferedDataStore, kvStore, generateId = GenerateIdLive, authMiddleware, authCacheConfig, metricsLayer, }) => {
+    // Create a simplified flow provider that uses the flows function directly
+    const createFlowProvider = Effect.succeed({
+        getFlow: (flowId, clientId) => {
+            // The flows function returns an Effect with TRequirements context,
+            // but the FlowProvider interface expects no context.
+            // We cast this to match the interface - the requirements will be provided
+            // at the layer level when the flow adapter is created.
+            return flows(flowId, clientId);
+        },
+    });
+    // Create the flow provider layer that provides the requirements
+    const flowProvider = Layer.effect(FlowProvider, createFlowProvider);
+    // Default eventEmitter to webSocketEventEmitter with the provided eventBroadcaster
+    const finalEventEmitter = eventEmitter ?? webSocketEventEmitter(eventBroadcaster);
+    // Convert DataStoreConfig to Layer
+    const dataStoreLayer = await createDataStoreLayer(dataStore);
+    return createInternalExpressUploadistaAdapter({
+        baseUrl,
+        flowProvider,
+        plugins,
+        eventEmitter: finalEventEmitter,
+        dataStore: dataStoreLayer,
+        bufferedDataStore,
+        kvStore,
+        generateId,
+        authMiddleware,
+        authCacheConfig,
+        metricsLayer,
+    });
+};

package/dist/uploadista-websocket-handler.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage } from "node:http";
+import type { FlowServerShape } from "@uploadista/core/flow";
+import type { UploadServerShape } from "@uploadista/core/upload";
+import type { WebSocketConnection, WebSocketHandlers } from "./uploadista-adapter-layer";
+export declare const createUploadistaWebSocketHandler: (baseUrl: string, uploadServer: UploadServerShape, flowServer: FlowServerShape) => (req: IncomingMessage, connection: WebSocketConnection) => WebSocketHandlers;
+export declare const createWebSocketMessageHandler: (_uploadServer: UploadServerShape, _flowServer: FlowServerShape, _uploadId: string | undefined, _jobId: string | undefined, connection: WebSocketConnection) => (message: string) => void;
+export declare const createWebSocketCloseHandler: (uploadServer: UploadServerShape, flowServer: FlowServerShape, uploadId: string | undefined, jobId: string | undefined) => () => void;
+export declare const createWebSocketErrorHandler: (eventId: string | undefined) => (error: Error) => void;
+//# sourceMappingURL=uploadista-websocket-handler.d.ts.map

package/dist/uploadista-websocket-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadista-websocket-handler.d.ts","sourceRoot":"","sources":["../src/uploadista-websocket-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAM,gCAAgC,GAC3C,SAAS,MAAM,EACf,cAAc,iBAAiB,EAC/B,YAAY,eAAe,MAGzB,KAAK,eAAe,EACpB,YAAY,mBAAmB,KAC9B,iBAoHJ,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,eAAe,iBAAiB,EAChC,aAAa,eAAe,EAC5B,WAAW,MAAM,GAAG,SAAS,EAC7B,QAAQ,MAAM,GAAG,SAAS,EAC1B,YAAY,mBAAmB,MAEvB,SAAS,MAAM,KAAG,IAqB3B,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,cAAc,iBAAiB,EAC/B,YAAY,eAAe,EAC3B,UAAU,MAAM,GAAG,SAAS,EAC5B,OAAO,MAAM,GAAG,SAAS,WAEd,IAwBZ,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,SAAS,MAAM,GAAG,SAAS,MAC7D,OAAO,KAAK,KAAG,IAGxB,CAAC"}

package/dist/uploadista-websocket-handler.js

@@ -0,0 +1,132 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { Effect } from "effect";
+export const createUploadistaWebSocketHandler = (baseUrl, uploadServer, flowServer) => {
+    return (req, connection) => {
+        // Check for ws/uploadista prefix
+        const url = req.url || "";
+        if (!url.includes(`${baseUrl}/ws/`)) {
+            connection.send(JSON.stringify({
+                type: "error",
+                message: `WebSocket path must start with ${baseUrl}/ws/`,
+            }));
+            connection.close(1000, "Invalid path");
+            // Return no-op handlers since connection is closed
+            return {
+                onMessage: () => { },
+                onClose: () => { },
+                onError: () => { },
+            };
+        }
+        // Remove the prefix and get the actual route segments
+        const routeSegments = url
+            .replace(`${baseUrl}/ws/`, "")
+            .split("/")
+            .filter(Boolean);
+        const isUploadRoute = routeSegments.includes("upload");
+        const isFlowRoute = routeSegments.includes("flow");
+        // Extract jobId and uploadId from URL path or query parameters
+        // Path format: /uploadista/ws/flow/{jobId} or /uploadista/ws/upload/{uploadId}
+        let jobId = extractQueryParam(url, "jobId");
+        let uploadId = extractQueryParam(url, "uploadId");
+        // If not in query params, extract from path segments
+        if (!jobId && !uploadId && routeSegments.length >= 2) {
+            const routeType = routeSegments[0]; // 'flow' or 'upload'
+            const id = routeSegments[1]; // the actual ID
+            if (routeType === "flow") {
+                jobId = id;
+            }
+            else if (routeType === "upload") {
+                uploadId = id;
+            }
+        }
+        // Use jobId if available, otherwise use uploadId
+        const eventId = jobId || uploadId;
+        console.log("Uploadista websocket handler", { jobId, uploadId, eventId });
+        const subscribeEffect = Effect.gen(function* () {
+            // Subscribe to flow events if we had a jobId
+            if (isFlowRoute && jobId) {
+                // Subscribe to flow events (this handles job tracking)
+                yield* flowServer.subscribeToFlowEvents(jobId, connection);
+            }
+            // If we have an uploadId, also subscribe to upload events
+            // These will be treated as task events within the job
+            if (isUploadRoute && uploadId) {
+                yield* uploadServer.subscribeToUploadEvents(uploadId, connection);
+            }
+            connection.send(JSON.stringify({
+                type: "connection",
+                message: "Uploadista WebSocket connected",
+                id: eventId,
+                jobId,
+                uploadId,
+                timestamp: new Date().toISOString(),
+            }));
+        }).pipe(Effect.catchAll((error) => Effect.sync(() => {
+            console.error("Error subscribing to events:", error);
+            const errorMessage = error instanceof UploadistaError
+                ? error.body
+                : "Failed to subscribe to events";
+            connection.send(JSON.stringify({
+                type: "error",
+                message: errorMessage,
+                code: error instanceof UploadistaError
+                    ? error.code
+                    : "SUBSCRIPTION_ERROR",
+            }));
+        })));
+        Effect.runFork(subscribeEffect);
+        // Return handlers for WebSocket events
+        return {
+            onMessage: createWebSocketMessageHandler(uploadServer, flowServer, uploadId, jobId, connection),
+            onClose: createWebSocketCloseHandler(uploadServer, flowServer, uploadId, jobId),
+            onError: createWebSocketErrorHandler(eventId),
+        };
+    };
+};
+export const createWebSocketMessageHandler = (_uploadServer, _flowServer, _uploadId, _jobId, connection) => {
+    return (message) => {
+        try {
+            const parsed = JSON.parse(message);
+            if (parsed.type === "ping") {
+                connection.send(JSON.stringify({
+                    type: "pong",
+                    timestamp: new Date().toISOString(),
+                }));
+            }
+        }
+        catch (error) {
+            console.error("Error handling WebSocket message:", error);
+            connection.send(JSON.stringify({
+                type: "error",
+                message: "Invalid message format",
+            }));
+        }
+    };
+};
+export const createWebSocketCloseHandler = (uploadServer, flowServer, uploadId, jobId) => {
+    return () => {
+        const unsubscribeEffect = Effect.gen(function* () {
+            // Unsubscribe from flow events if we had a jobId
+            if (jobId) {
+                yield* flowServer.unsubscribeFromFlowEvents(jobId);
+            }
+            // Unsubscribe from upload events if we had an uploadId
+            if (uploadId) {
+                yield* uploadServer.unsubscribeFromUploadEvents(uploadId);
+            }
+        }).pipe(Effect.catchAll((error) => Effect.sync(() => {
+            console.error("Error unsubscribing from events:", error instanceof UploadistaError ? error.body : error);
+        })));
+        Effect.runFork(unsubscribeEffect);
+    };
+};
+export const createWebSocketErrorHandler = (eventId) => {
+    return (error) => {
+        console.error(`WebSocket error for event ${eventId}:`, error);
+    };
+};
+function extractQueryParam(url, param) {
+    const regex = new RegExp(`[?&]${param}=([^&]*)`);
+    const match = url.match(regex);
+    return match?.[1] ? decodeURIComponent(match[1]) : undefined;
+}

package/dist/websocket-handler.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage } from "node:http";
+import type { UploadServerShape } from "@uploadista/core/upload";
+import type { WebSocketConnection } from "./adapter-layer";
+export declare const createWebSocketHandler: (server: UploadServerShape) => (req: IncomingMessage, connection: WebSocketConnection) => void;
+export declare const createWebSocketMessageHandler: (_server: UploadServerShape, _uploadId: string) => (message: string, connection: WebSocketConnection) => void;
+export declare const createWebSocketCloseHandler: (server: UploadServerShape, uploadId: string) => () => void;
+export declare const createWebSocketErrorHandler: (uploadId: string) => (error: Error) => void;
+//# sourceMappingURL=websocket-handler.d.ts.map

package/dist/websocket-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-handler.d.ts","sourceRoot":"","sources":["../src/websocket-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,eAAO,MAAM,sBAAsB,GAAI,QAAQ,iBAAiB,MACtD,KAAK,eAAe,EAAE,YAAY,mBAAmB,KAAG,IAkDjE,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,SAAS,iBAAiB,EAC1B,WAAW,MAAM,MAET,SAAS,MAAM,EAAE,YAAY,mBAAmB,KAAG,IAqB5D,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,QAAQ,iBAAiB,EACzB,UAAU,MAAM,WAEL,IAgBZ,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,UAAU,MAAM,MAClD,OAAO,KAAK,KAAG,IAGxB,CAAC"}

package/dist/websocket-handler.js

@@ -0,0 +1,82 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { Effect } from "effect";
+export const createWebSocketHandler = (server) => {
+    return (req, connection) => {
+        // Extract uploadId from request params or URL
+        const uploadId = req.url ? extractUploadIdFromUrl(req.url) : undefined;
+        if (!uploadId) {
+            connection.send(JSON.stringify({
+                type: "error",
+                message: "Missing uploadId parameter",
+            }));
+            connection.close(1000, "Missing uploadId");
+            return;
+        }
+        const subscribeEffect = Effect.gen(function* () {
+            yield* server.subscribeToUploadEvents(uploadId, connection);
+            connection.send(JSON.stringify({
+                type: "connection",
+                message: "Upload events WebSocket connected",
+                uploadId,
+                timestamp: new Date().toISOString(),
+            }));
+        }).pipe(Effect.catchAll((error) => Effect.sync(() => {
+            console.error("Error subscribing to upload events:", error);
+            const errorMessage = error instanceof UploadistaError
+                ? error.body
+                : "Failed to subscribe to upload events";
+            connection.send(JSON.stringify({
+                type: "error",
+                message: errorMessage,
+                code: error instanceof UploadistaError
+                    ? error.code
+                    : "SUBSCRIPTION_ERROR",
+            }));
+        })));
+        Effect.runFork(subscribeEffect);
+    };
+};
+export const createWebSocketMessageHandler = (_server, _uploadId) => {
+    return (message, connection) => {
+        try {
+            const parsed = JSON.parse(message);
+            if (parsed.type === "ping") {
+                connection.send(JSON.stringify({
+                    type: "pong",
+                    timestamp: new Date().toISOString(),
+                }));
+            }
+        }
+        catch (error) {
+            console.error("Error handling WebSocket message:", error);
+            connection.send(JSON.stringify({
+                type: "error",
+                message: "Invalid message format",
+            }));
+        }
+    };
+};
+export const createWebSocketCloseHandler = (server, uploadId) => {
+    return () => {
+        const unsubscribeEffect = Effect.gen(function* () {
+            yield* server.unsubscribeFromUploadEvents(uploadId);
+        }).pipe(Effect.catchAll((error) => Effect.sync(() => {
+            console.error("Error unsubscribing from upload events:", error instanceof UploadistaError ? error.body : error);
+        })));
+        Effect.runFork(unsubscribeEffect);
+    };
+};
+export const createWebSocketErrorHandler = (uploadId) => {
+    return (error) => {
+        console.error(`WebSocket error for upload ${uploadId}:`, error);
+    };
+};
+function extractUploadIdFromUrl(url) {
+    const segments = url.split("/").filter(Boolean);
+    // Assuming URL structure like /api/upload/:uploadId/ws
+    const uploadIndex = segments.indexOf("upload");
+    if (uploadIndex !== -1 && uploadIndex + 1 < segments.length) {
+        return segments[uploadIndex + 1];
+    }
+    return undefined;
+}