@uploadista/adapters-express 0.0.3

package/dist/error-types.d.ts

@@ -0,0 +1,24 @@
+import type { UploadistaError } from "@uploadista/core/errors";
+import { AdapterError, BadRequestError as BaseBadRequestError, NotFoundError as BaseNotFoundError, ValidationError as BaseValidationError } from "@uploadista/server";
+import { Effect } from "effect";
+import type { Response } from "express";
+export { AdapterError as ExpressAdapterError, BaseValidationError as ValidationError, BaseNotFoundError as NotFoundError, BaseBadRequestError as BadRequestError, };
+/**
+ * Sends error response using Express Response object
+ */
+export declare const sendErrorResponse: (res: Response, error: AdapterError) => void;
+/**
+ * Sends UploadistaError response using Express Response object
+ */
+export declare const sendUploadistaErrorResponse: (res: Response, error: UploadistaError) => void;
+/**
+ * Sends generic error response using Express Response object
+ */
+export declare const sendGenericErrorResponse: (res: Response, message?: string) => void;
+/**
+ * Universal error handler that sends error response via Express Response.
+ * Handles AdapterError, UploadistaError, and unknown errors.
+ * This is the recommended way to handle errors in HTTP handlers.
+ */
+export declare const handleErrorResponse: (res: Response) => (error: unknown) => Effect.Effect<void, never, never>;
+//# sourceMappingURL=error-types.d.ts.map

package/dist/error-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-types.d.ts","sourceRoot":"","sources":["../src/error-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EACL,YAAY,EACZ,eAAe,IAAI,mBAAmB,EACtC,aAAa,IAAI,iBAAiB,EAClC,eAAe,IAAI,mBAAmB,EAIvC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EACL,YAAY,IAAI,mBAAmB,EACnC,mBAAmB,IAAI,eAAe,EACtC,iBAAiB,IAAI,aAAa,EAClC,mBAAmB,IAAI,eAAe,GACvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,KAAK,QAAQ,EAAE,OAAO,YAAY,KAAG,IAEtE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GACtC,KAAK,QAAQ,EACb,OAAO,eAAe,KACrB,IAEF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GACnC,KAAK,QAAQ,EACb,gBAAiC,KAChC,IAEF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,QAAQ,MAAM,OAAO,OAAO,sCAiDpE,CAAC"}

package/dist/error-types.js

@@ -0,0 +1,65 @@
+import { AdapterError, BadRequestError as BaseBadRequestError, NotFoundError as BaseNotFoundError, ValidationError as BaseValidationError, createErrorResponseBody, createGenericErrorResponseBody, createUploadistaErrorResponseBody, } from "@uploadista/server";
+import { Effect } from "effect";
+// Re-export shared error types for backward compatibility
+export { AdapterError as ExpressAdapterError, BaseValidationError as ValidationError, BaseNotFoundError as NotFoundError, BaseBadRequestError as BadRequestError, };
+/**
+ * Sends error response using Express Response object
+ */
+export const sendErrorResponse = (res, error) => {
+    res.status(error.statusCode).json(createErrorResponseBody(error));
+};
+/**
+ * Sends UploadistaError response using Express Response object
+ */
+export const sendUploadistaErrorResponse = (res, error) => {
+    res.status(error.status).json(createUploadistaErrorResponseBody(error));
+};
+/**
+ * Sends generic error response using Express Response object
+ */
+export const sendGenericErrorResponse = (res, message = "Internal server error") => {
+    res.status(500).json(createGenericErrorResponseBody(message));
+};
+/**
+ * Universal error handler that sends error response via Express Response.
+ * Handles AdapterError, UploadistaError, and unknown errors.
+ * This is the recommended way to handle errors in HTTP handlers.
+ */
+export const handleErrorResponse = (res) => (error) => {
+    console.error(error);
+    // Handle known adapter errors
+    if (error instanceof AdapterError) {
+        return Effect.sync(() => sendErrorResponse(res, error));
+    }
+    // Handle UploadistaError
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        "status" in error &&
+        "body" in error) {
+        return Effect.sync(() => sendUploadistaErrorResponse(res, error));
+    }
+    // Handle unknown errors - try to extract what we can
+    let message = "Internal server error";
+    let code = "UNKNOWN_ERROR";
+    let status = 500;
+    if (typeof error === "object" && error !== null) {
+        const errorObj = error;
+        if ("message" in errorObj && typeof errorObj.message === "string") {
+            message = errorObj.message;
+        }
+        if ("code" in errorObj && typeof errorObj.code === "string") {
+            code = errorObj.code;
+        }
+        if ("status" in errorObj && typeof errorObj.status === "number") {
+            status = errorObj.status;
+        }
+    }
+    return Effect.sync(() => {
+        res.status(status).json({
+            error: message,
+            code,
+            timestamp: new Date().toISOString(),
+        });
+    });
+};

package/dist/flow-adapter.d.ts

@@ -0,0 +1,19 @@
+import { type FlowProvider, FlowServer } from "@uploadista/core/flow";
+import { type BaseEventEmitterService, type BaseKvStoreService } from "@uploadista/core/types";
+import { Layer } from "effect";
+import type { Request, Response } from "express";
+export type ExpressFlowAdapterOptions = {
+    flowProvider: Layer.Layer<FlowProvider>;
+    kvStore: Layer.Layer<BaseKvStoreService>;
+    eventEmitter: Layer.Layer<BaseEventEmitterService>;
+    withTracing?: boolean;
+};
+export type ExpressFlowAdapter = {
+    handler: (req: Request, res: Response) => Promise<void>;
+    flowServer: Layer.Layer<FlowServer>;
+};
+/**
+ * Creates an Express flow adapter
+ */
+export declare const createExpressFlowAdapter: ({ flowProvider, kvStore, eventEmitter, withTracing, }: ExpressFlowAdapterOptions) => Promise<ExpressFlowAdapter>;
+//# sourceMappingURL=flow-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flow-adapter.d.ts","sourceRoot":"","sources":["../src/flow-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,UAAU,EAEX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EAGxB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIjD,MAAM,MAAM,yBAAyB,GAAG;IACtC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACxC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACzC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACnD,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;CACrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAU,uDAK5C,yBAAyB,KAAG,OAAO,CAAC,kBAAkB,CAoGxD,CAAC"}

package/dist/flow-adapter.js

@@ -0,0 +1,80 @@
+import { FlowServer, flowServer, } from "@uploadista/core/flow";
+import { flowEventEmitter, flowJobKvStore, } from "@uploadista/core/types";
+import { NodeSdkLive } from "@uploadista/observability";
+import { Effect, Layer } from "effect";
+/**
+ * Creates an Express flow adapter
+ */
+export const createExpressFlowAdapter = async ({ flowProvider, kvStore, eventEmitter, withTracing = false, }) => {
+    const flowJobKVStoreLayer = Layer.provide(flowJobKvStore, kvStore);
+    const flowEventEmitterLayer = Layer.provide(flowEventEmitter, eventEmitter);
+    const baseDependencies = Layer.mergeAll(flowProvider, flowEventEmitterLayer, flowJobKVStoreLayer);
+    const flowServerLayer = Layer.provide(flowServer, baseDependencies);
+    // Initialize the flow server
+    const runProgram = (effect) => {
+        if (withTracing) {
+            return Effect.runPromise(effect.pipe(Effect.provide(NodeSdkLive)));
+        }
+        return Effect.runPromise(effect);
+    };
+    const handler = async (req, res) => {
+        try {
+            const program = Effect.gen(function* () {
+                const server = yield* FlowServer;
+                switch (req.method) {
+                    case "GET": {
+                        const id = req.url?.split("/").pop();
+                        if (!id) {
+                            return { status: 400, body: { error: "No id" } };
+                        }
+                        const flowData = yield* server.getFlowData(id);
+                        return { status: 200, body: flowData };
+                    }
+                    case "POST": {
+                        const urlSegments = req.url?.split("/") || [];
+                        const storageId = urlSegments.pop();
+                        const flowId = urlSegments.pop();
+                        if (!flowId) {
+                            return { status: 400, body: { error: "No id" } };
+                        }
+                        if (!storageId) {
+                            return { status: 400, body: { error: "No storage id" } };
+                        }
+                        console.log("Flow execution params:", req.body, flowId, storageId);
+                        const result = yield* server.runFlow(flowId, storageId, req.body?.inputs);
+                        return { status: 200, body: result };
+                    }
+                    default:
+                        return { status: 405, body: { error: "Method not allowed" } };
+                }
+            }).pipe(Effect.catchAll((error) => {
+                let status = 500;
+                let message = "Internal server error";
+                if (typeof error === "object" && error !== null) {
+                    const errorObj = error;
+                    if ("message" in errorObj && typeof errorObj.message === "string") {
+                        message = errorObj.message;
+                    }
+                    if ("code" in errorObj && errorObj.code === "FILE_NOT_FOUND") {
+                        status = 404;
+                    }
+                }
+                return Effect.succeed({
+                    status,
+                    body: { error: message },
+                });
+            }));
+            const result = await runProgram(Effect.provide(program, flowServerLayer));
+            res.status(result.status).json(result.body);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Internal server error",
+            });
+        }
+    };
+    return {
+        handler,
+        flowServer: flowServerLayer,
+    };
+};

package/dist/flow-http-handlers.d.ts

@@ -0,0 +1,9 @@
+import type { FlowServerShape } from "@uploadista/core/flow";
+import { AuthCacheService, AuthContextService } from "@uploadista/server";
+import { Effect } from "effect";
+import type { Request, Response } from "express";
+export declare const handleFlowGet: (req: Request, res: Response, flowServer: FlowServerShape) => Effect.Effect<void, never, AuthContextService>;
+export declare const handleFlowPost: <TRequirements = never>(req: Request, res: Response, flowServer: FlowServerShape) => Effect.Effect<void, never, AuthContextService | TRequirements | AuthCacheService>;
+export declare const handleJobStatus: (req: Request, res: Response, flowServer: FlowServerShape) => Effect.Effect<void>;
+export declare const handleContinueFlow: <TRequirements = never>(req: Request, res: Response, flowServer: FlowServerShape) => Effect.Effect<void, never, AuthContextService | TRequirements>;
+//# sourceMappingURL=flow-http-handlers.d.ts.map

package/dist/flow-http-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-http-handlers.d.ts","sourceRoot":"","sources":["../src/flow-http-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGjD,eAAO,MAAM,aAAa,GACxB,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,YAAY,eAAe,mDAkB5B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,aAAa,GAAG,KAAK,EAClD,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,YAAY,eAAe,sFAsD5B,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,YAAY,eAAe,KAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,CAcpB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,aAAa,GAAG,KAAK,EACtD,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,YAAY,eAAe,mEAoE5B,CAAC"}

package/dist/flow-http-handlers.js

@@ -0,0 +1,133 @@
+import { AuthCacheService, AuthContextService, getLastSegment, } from "@uploadista/server";
+import { Effect } from "effect";
+import { handleErrorResponse } from "./error-types";
+export const handleFlowGet = (req, res, flowServer) => {
+    return Effect.gen(function* () {
+        // Access auth context if available
+        const authService = yield* AuthContextService;
+        const clientId = yield* authService.getClientId();
+        const url = new URL(req.url, `http://${req.get("host")}`);
+        const id = getLastSegment(url.pathname);
+        if (!id) {
+            res.status(400).json({ error: "No id" });
+            return;
+        }
+        const flowData = yield* flowServer.getFlowData(id, clientId);
+        res.status(200).json(flowData);
+    }).pipe(Effect.catchAll(handleErrorResponse(res)));
+};
+export const handleFlowPost = (req, res, flowServer) => {
+    return Effect.gen(function* () {
+        const authService = yield* AuthContextService;
+        const authCache = yield* AuthCacheService;
+        const clientId = yield* authService.getClientId();
+        const urlSegments = req.url.split("/");
+        const storageId = urlSegments.pop();
+        const flowId = urlSegments.pop();
+        if (!flowId) {
+            res.status(400).json({ error: "No id" });
+            return;
+        }
+        if (!storageId) {
+            res.status(400).json({ error: "No storage id" });
+            return;
+        }
+        const params = req.body;
+        if (clientId) {
+            console.log(`[Flow] Executing flow: ${flowId}, storage: ${storageId}, client: ${clientId}`);
+            console.log(JSON.stringify(params, null, 2));
+        }
+        else {
+            console.log(`Flow execution params: ${flowId} ${storageId}`);
+            console.log(JSON.stringify(params, null, 2));
+        }
+        // Run flow returns immediately with jobId
+        const result = yield* flowServer.runFlow({
+            flowId,
+            storageId,
+            clientId,
+            inputs: params.inputs,
+        });
+        // Cache auth context for subsequent flow operations (continue, status)
+        const authContext = yield* authService.getAuthContext();
+        if (authContext) {
+            yield* authCache.set(result.id, authContext);
+        }
+        if (clientId) {
+            console.log(`[Flow] Flow started with jobId: ${result.id}, client: ${clientId}`);
+        }
+        res.status(200).json(result);
+    }).pipe(Effect.catchAll(handleErrorResponse(res)));
+};
+export const handleJobStatus = (req, res, flowServer) => {
+    return Effect.gen(function* () {
+        const urlSegments = req.url.split("/");
+        const jobId = urlSegments[urlSegments.length - 2]; // .../jobs/:jobId/status
+        if (!jobId) {
+            res.status(400).json({ error: "No job id" });
+            return;
+        }
+        const result = yield* flowServer.getJobStatus(jobId);
+        res.status(200).json(result);
+    }).pipe(Effect.catchAll(handleErrorResponse(res)));
+};
+export const handleContinueFlow = (req, res, flowServer) => {
+    return Effect.gen(function* () {
+        const authService = yield* AuthContextService;
+        const clientId = yield* authService.getClientId();
+        const url = new URL(req.url, `http://${req.get("host")}`);
+        const urlSegments = url.pathname.split("/");
+        const jobId = urlSegments[urlSegments.length - 3]; // .../jobs/:jobId/continue/:nodeId
+        const nodeId = urlSegments[urlSegments.length - 1]; // .../jobs/:jobId/continue/:nodeId
+        if (!jobId) {
+            console.error("No job id");
+            res.status(400).json({ error: "No job id" });
+            return;
+        }
+        if (!nodeId) {
+            console.error("No node id");
+            res.status(400).json({ error: "No node id" });
+            return;
+        }
+        const contentType = req.get("Content-Type");
+        let newData;
+        // Handle different content types
+        if (contentType?.includes("application/octet-stream")) {
+            // For streaming data, convert Node.js Readable to web ReadableStream
+            newData = new ReadableStream({
+                start(controller) {
+                    req.on("data", (chunk) => {
+                        controller.enqueue(chunk);
+                    });
+                    req.on("end", () => {
+                        controller.close();
+                    });
+                    req.on("error", (error) => {
+                        controller.error(error);
+                    });
+                },
+            });
+        }
+        else if (contentType?.includes("application/json")) {
+            // For JSON data, use the parsed body
+            const body = req.body;
+            if (body.newData === undefined) {
+                console.error("Missing newData");
+                res.status(400).json({ error: "Missing newData" });
+                return;
+            }
+            newData = body.newData;
+        }
+        else {
+            res.status(415).json({ error: "Unsupported Content-Type" });
+            return;
+        }
+        const result = yield* flowServer.continueFlow({
+            jobId,
+            nodeId,
+            newData,
+            clientId,
+        });
+        res.status(200).json(result);
+    }).pipe(Effect.catchAll(handleErrorResponse(res)));
+};

package/dist/http-handlers.d.ts

@@ -0,0 +1,7 @@
+import type { UploadServerShape } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import type { Request, Response } from "express";
+export declare const handlePost: (req: Request, res: Response, server: UploadServerShape) => Effect.Effect<void>;
+export declare const handleGet: (req: Request, res: Response, server: UploadServerShape) => Effect.Effect<void>;
+export declare const handlePatch: (req: Request, res: Response, server: UploadServerShape) => Effect.Effect<void>;
+//# sourceMappingURL=http-handlers.d.ts.map

package/dist/http-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-handlers.d.ts","sourceRoot":"","sources":["../src/http-handlers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAUjD,eAAO,MAAM,UAAU,GACrB,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,QAAQ,iBAAiB,KACxB,MAAM,CAAC,MAAM,CAAC,IAAI,CAkClB,CAAC;AAEJ,eAAO,MAAM,SAAS,GACpB,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,QAAQ,iBAAiB,KACxB,MAAM,CAAC,MAAM,CAAC,IAAI,CA4ClB,CAAC;AAEJ,eAAO,MAAM,WAAW,GACtB,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,QAAQ,iBAAiB,KACxB,MAAM,CAAC,MAAM,CAAC,IAAI,CA4BlB,CAAC"}

package/dist/http-handlers.js

@@ -0,0 +1,78 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { inputFileSchema } from "@uploadista/core/types";
+import { Effect } from "effect";
+import { BadRequestError, NotFoundError, sendErrorResponse, sendGenericErrorResponse, sendUploadistaErrorResponse, ValidationError, } from "./error-types";
+export const handlePost = (req, res, server) => Effect.gen(function* () {
+    const json = req.body;
+    if (!json) {
+        return yield* Effect.fail(new BadRequestError("Invalid JSON payload"));
+    }
+    const parsedInputFile = yield* Effect.sync(() => inputFileSchema.safeParse(json));
+    if (!parsedInputFile.success) {
+        return yield* Effect.fail(new ValidationError("Invalid input file schema"));
+    }
+    const fileCreated = yield* server.createUpload(parsedInputFile.data);
+    res.status(200).json(fileCreated);
+}).pipe(Effect.catchAll((error) => {
+    if (error instanceof ValidationError ||
+        error instanceof BadRequestError) {
+        return Effect.sync(() => sendErrorResponse(res, error));
+    }
+    if (error instanceof UploadistaError) {
+        return Effect.sync(() => sendUploadistaErrorResponse(res, error));
+    }
+    return Effect.sync(() => sendGenericErrorResponse(res));
+}));
+export const handleGet = (req, res, server) => Effect.gen(function* () {
+    const url = new URL(req.url, `http://${req.get("host")}`);
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const lastSegment = pathSegments[pathSegments.length - 1];
+    if (lastSegment === "capabilities") {
+        const storageId = url.searchParams.get("storageId") ||
+            pathSegments[pathSegments.length - 2];
+        if (!storageId) {
+            return yield* Effect.fail(new BadRequestError("storageId is required for capabilities"));
+        }
+        const capabilities = yield* server.getCapabilities(storageId);
+        res.status(200).json({
+            storageId,
+            capabilities,
+            timestamp: new Date().toISOString(),
+        });
+        return;
+    }
+    if (!lastSegment) {
+        return yield* Effect.fail(new BadRequestError("Upload ID is required"));
+    }
+    const fileResult = yield* server.getUpload(lastSegment);
+    res.status(200).json(fileResult);
+}).pipe(Effect.catchAll((error) => {
+    if (error instanceof BadRequestError || error instanceof NotFoundError) {
+        return Effect.sync(() => sendErrorResponse(res, error));
+    }
+    if (error instanceof UploadistaError) {
+        return Effect.sync(() => sendUploadistaErrorResponse(res, error));
+    }
+    return Effect.sync(() => sendGenericErrorResponse(res));
+}));
+export const handlePatch = (req, res, server) => Effect.gen(function* () {
+    const uploadId = req.url.split("/").pop();
+    if (!uploadId) {
+        return yield* Effect.fail(new BadRequestError("Upload ID is required"));
+    }
+    // Convert Express request to ReadableStream
+    const body = req;
+    if (!body) {
+        return yield* Effect.fail(new BadRequestError("Request body is required"));
+    }
+    const fileResult = yield* server.uploadChunk(uploadId, body);
+    res.status(200).json(fileResult);
+}).pipe(Effect.catchAll((error) => {
+    if (error instanceof BadRequestError || error instanceof NotFoundError) {
+        return Effect.sync(() => sendErrorResponse(res, error));
+    }
+    if (error instanceof UploadistaError) {
+        return Effect.sync(() => sendUploadistaErrorResponse(res, error));
+    }
+    return Effect.sync(() => sendGenericErrorResponse(res));
+}));

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./uploadista-adapter";
+export type { ExpressWebSocketHandler, WebSocketConnection, WebSocketHandlers, } from "./uploadista-adapter-layer";
+export { createUploadistaWebSocketHandler, createWebSocketCloseHandler, createWebSocketErrorHandler, createWebSocketMessageHandler, } from "./uploadista-websocket-handler";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AAGrC,YAAY,EACV,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,gCAAgC,EAChC,2BAA2B,EAC3B,2BAA2B,EAC3B,6BAA6B,GAC9B,MAAM,gCAAgC,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./uploadista-adapter";
+export { createUploadistaWebSocketHandler, createWebSocketCloseHandler, createWebSocketErrorHandler, createWebSocketMessageHandler, } from "./uploadista-websocket-handler";

package/dist/upload-http-handlers.d.ts

@@ -0,0 +1,9 @@
+import type { UploadServerShape } from "@uploadista/core/upload";
+import { MetricsService } from "@uploadista/observability";
+import { AuthCacheService, AuthContextService } from "@uploadista/server";
+import { Effect } from "effect";
+import type { Request, Response } from "express";
+export declare const handleUploadPost: (req: Request, res: Response, server: UploadServerShape) => Effect.Effect<void | undefined, never, AuthContextService | AuthCacheService>;
+export declare const handleUploadGet: (req: Request, res: Response, server: UploadServerShape) => Effect.Effect<void | undefined, never, AuthContextService>;
+export declare const handleUploadPatch: (req: Request, res: Response, server: UploadServerShape) => Effect.Effect<void | undefined, never, AuthContextService | AuthCacheService | MetricsService>;
+//# sourceMappingURL=upload-http-handlers.d.ts.map

package/dist/upload-http-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-http-handlers.d.ts","sourceRoot":"","sources":["../src/upload-http-handlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAOjD,eAAO,MAAM,gBAAgB,GAC3B,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,QAAQ,iBAAiB,kFA8CyB,CAAC;AAErD,eAAO,MAAM,eAAe,GAC1B,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,QAAQ,iBAAiB,+DAsCyB,CAAC;AAErD,eAAO,MAAM,iBAAiB,GAC5B,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,QAAQ,iBAAiB,mGA4EyB,CAAC"}

package/dist/upload-http-handlers.js

@@ -0,0 +1,113 @@
+import { inputFileSchema } from "@uploadista/core/types";
+import { MetricsService } from "@uploadista/observability";
+import { AuthCacheService, AuthContextService } from "@uploadista/server";
+import { Effect } from "effect";
+import { BadRequestError, handleErrorResponse, ValidationError, } from "./error-types";
+export const handleUploadPost = (req, res, server) => Effect.gen(function* () {
+    // Access auth context if available
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+    const clientId = yield* authService.getClientId();
+    if (clientId) {
+        console.log(`[Upload] Creating upload for client: ${clientId}`);
+    }
+    const json = req.body;
+    if (!json) {
+        return yield* Effect.fail(new BadRequestError("Invalid JSON payload"));
+    }
+    const parsedInputFile = yield* Effect.sync(() => inputFileSchema.safeParse(json));
+    if (!parsedInputFile.success) {
+        return yield* Effect.fail(new ValidationError("Invalid input file schema"));
+    }
+    const fileCreated = yield* server.createUpload(parsedInputFile.data, clientId);
+    // Cache auth context for subsequent chunk uploads
+    const authContext = yield* authService.getAuthContext();
+    if (authContext) {
+        yield* authCache.set(fileCreated.id, authContext);
+    }
+    if (clientId) {
+        console.log(`[Upload] Upload created: ${fileCreated.id} for client: ${clientId}`);
+    }
+    res.status(200).json(fileCreated);
+}).pipe(Effect.catchAll(handleErrorResponse(res)));
+export const handleUploadGet = (req, res, server) => Effect.gen(function* () {
+    const authService = yield* AuthContextService;
+    const clientId = yield* authService.getClientId();
+    const url = new URL(req.url, `http://${req.get("host")}`);
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const lastSegment = pathSegments[pathSegments.length - 1];
+    if (lastSegment === "capabilities") {
+        const storageId = url.searchParams.get("storageId") ||
+            pathSegments[pathSegments.length - 2];
+        if (!storageId) {
+            return yield* Effect.fail(new BadRequestError("storageId is required for capabilities"));
+        }
+        const capabilities = yield* server.getCapabilities(storageId, clientId);
+        res.status(200).json({
+            storageId,
+            capabilities,
+            timestamp: new Date().toISOString(),
+        });
+        return;
+    }
+    if (!lastSegment) {
+        return yield* Effect.fail(new BadRequestError("Upload ID is required"));
+    }
+    const fileResult = yield* server.getUpload(lastSegment);
+    res.status(200).json(fileResult);
+}).pipe(Effect.catchAll(handleErrorResponse(res)));
+export const handleUploadPatch = (req, res, server) => Effect.gen(function* () {
+    // Try to get auth from current request or cached auth
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+    const metricsService = yield* MetricsService;
+    const uploadId = req.url.split("/").pop();
+    if (!uploadId) {
+        return yield* Effect.fail(new BadRequestError("Upload ID is required"));
+    }
+    // Try current auth first, fallback to cached auth
+    let clientId = yield* authService.getClientId();
+    let authMetadata = yield* authService.getMetadata();
+    if (!clientId) {
+        const cachedAuth = yield* authCache.get(uploadId);
+        clientId = cachedAuth?.clientId ?? null;
+        authMetadata = cachedAuth?.metadata ?? {};
+    }
+    if (clientId) {
+        console.log(`[Upload] Uploading chunk for upload: ${uploadId}, client: ${clientId}`);
+    }
+    // Convert Node.js Readable stream to web ReadableStream
+    const body = new ReadableStream({
+        start(controller) {
+            req.on("data", (chunk) => {
+                controller.enqueue(chunk);
+            });
+            req.on("end", () => {
+                controller.close();
+            });
+            req.on("error", (error) => {
+                controller.error(error);
+            });
+        },
+    });
+    const fileResult = yield* server.uploadChunk(uploadId, clientId, body);
+    // Clear cache and record metrics if upload is complete
+    if (fileResult.size && fileResult.offset >= fileResult.size) {
+        yield* authCache.delete(uploadId);
+        if (clientId) {
+            console.log(`[Upload] Upload completed, cleared auth cache: ${uploadId}`);
+        }
+        // Record upload metrics if we have organization ID
+        if (clientId && fileResult.size) {
+            console.log(`[Upload] Recording metrics for org: ${clientId}, size: ${fileResult.size}`);
+            yield* Effect.forkDaemon(metricsService.recordUpload(clientId, fileResult.size, authMetadata));
+        }
+        else {
+            console.warn(`[Upload] Cannot record metrics - missing organizationId or size`);
+        }
+    }
+    if (clientId) {
+        console.log(`[Upload] Chunk uploaded for upload: ${uploadId}, client: ${clientId}`);
+    }
+    res.status(200).json(fileResult);
+}).pipe(Effect.catchAll(handleErrorResponse(res)));

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

@@ -0,0 +1,24 @@
+import type { IncomingMessage } from "node:http";
+import { type Effect, Context as EffectContext } from "effect";
+import type { Request, Response } from "express";
+export interface WebSocketConnection {
+    id: string;
+    send: (data: string) => void;
+    close: (code?: number, reason?: string) => void;
+    readyState: number;
+}
+export type WebSocketHandlers = {
+    onMessage: (message: string) => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+};
+export type ExpressWebSocketHandler = (req: IncomingMessage, connection: WebSocketConnection) => WebSocketHandlers;
+export type ExpressUploadistaAdapterServiceShape = {
+    handler: (req: Request, res: Response) => Effect.Effect<void, never, never>;
+    websocketHandler: ExpressWebSocketHandler;
+};
+declare const ExpressUploadistaAdapterService_base: EffectContext.TagClass<ExpressUploadistaAdapterService, "ExpressUploadistaAdapterService", ExpressUploadistaAdapterServiceShape>;
+export declare class ExpressUploadistaAdapterService extends ExpressUploadistaAdapterService_base {
+}
+export {};
+//# sourceMappingURL=uploadista-adapter-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uploadista-adapter-layer.d.ts","sourceRoot":"","sources":["../src/uploadista-adapter-layer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,KAAK,MAAM,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEjD,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,CACpC,GAAG,EAAE,eAAe,EACpB,UAAU,EAAE,mBAAmB,KAC5B,iBAAiB,CAAC;AAGvB,MAAM,MAAM,oCAAoC,GAAG;IACjD,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAC5E,gBAAgB,EAAE,uBAAuB,CAAC;CAC3C,CAAC;;AAGF,qBAAa,+BAAgC,SAAQ,oCAEqB;CAAG"}

package/dist/uploadista-adapter-layer.js

@@ -0,0 +1,4 @@
+import { Context as EffectContext } from "effect";
+// Context Tag for the Uploadista adapter service
+export class ExpressUploadistaAdapterService extends EffectContext.Tag("ExpressUploadistaAdapterService")() {
+}