@uploadista/client-core 0.0.3

package/dist/client/uploadista-api.js

@@ -0,0 +1,444 @@
+import { AuthHttpClient } from "../auth";
+import { UploadistaError } from "../error";
+import { defaultClientCapabilities } from "../mock-data-store";
+/**
+ * Maps server error codes to client error names
+ * If no mapping exists, uses a default error name based on context
+ */
+const mapServerErrorCodeToClientName = (serverCode, defaultName) => {
+    if (!serverCode)
+        return defaultName;
+    // Map common server error codes to client error names
+    const errorMap = {
+        FILE_NOT_FOUND: "UPLOAD_NOT_FOUND",
+        UPLOAD_ID_NOT_FOUND: "UPLOAD_NOT_FOUND",
+        FLOW_JOB_NOT_FOUND: "JOB_NOT_FOUND",
+        FLOW_NODE_ERROR: "FLOW_RUN_FAILED",
+        FLOW_STRUCTURE_ERROR: "FLOW_RUN_FAILED",
+        FLOW_CYCLE_ERROR: "FLOW_RUN_FAILED",
+        FLOW_INPUT_VALIDATION_ERROR: "FLOW_RUN_FAILED",
+        FLOW_OUTPUT_VALIDATION_ERROR: "FLOW_RUN_FAILED",
+        VALIDATION_ERROR: "CREATE_UPLOAD_FAILED",
+        DATASTORE_NOT_FOUND: "FLOW_RUN_FAILED",
+    };
+    return errorMap[serverCode] || defaultName;
+};
+/**
+ * Creates an Uploadista API instance for direct server communication.
+ *
+ * This factory creates a low-level API client that handles:
+ * - HTTP requests to upload and flow endpoints
+ * - Authentication via AuthManager (optional)
+ * - WebSocket connections for real-time updates
+ * - Error mapping from server to client error types
+ * - Connection pooling and metrics
+ *
+ * Most applications should use {@link createUploadistaClient} instead,
+ * which wraps this API with higher-level features like automatic retry,
+ * resumption, and smart chunking.
+ *
+ * @param baseURL - Base URL of the Uploadista server (e.g., "https://upload.example.com")
+ * @param uploadistBasePath - Base path for endpoints, typically "uploadista"
+ * @param options - Configuration object
+ * @param options.httpClient - HTTP client for making requests
+ * @param options.logger - Optional logger for debugging
+ * @param options.authManager - Optional authentication manager
+ * @param options.webSocketFactory - Factory for creating WebSocket connections
+ * @returns UploadistaApi instance
+ *
+ * @example Basic API instance
+ * ```typescript
+ * import { createUploadistaApi } from '@uploadista/client-core';
+ *
+ * const api = createUploadistaApi(
+ *   'https://upload.example.com',
+ *   'uploadista',
+ *   {
+ *     httpClient: myHttpClient,
+ *     logger: console,
+ *     webSocketFactory: {
+ *       create: (url) => new WebSocket(url),
+ *     },
+ *   }
+ * );
+ *
+ * // Use the API directly
+ * const { upload } = await api.createUpload({
+ *   storageId: 'my-storage',
+ *   size: 1024,
+ * });
+ * ```
+ *
+ * @example With authentication
+ * ```typescript
+ * const authManager = new DirectAuthManager(authConfig, platformService, logger);
+ *
+ * const api = createUploadistaApi(baseUrl, 'uploadista', {
+ *   httpClient,
+ *   logger,
+ *   authManager, // Automatically adds auth headers to requests
+ *   webSocketFactory,
+ * });
+ * ```
+ *
+ * @see {@link UploadistaApi} for the API interface
+ * @see {@link createUploadistaClient} for the high-level client
+ */
+export function createUploadistaApi(baseURL, uploadistBasePath, { httpClient: baseHttpClient, logger, authManager, webSocketFactory, }) {
+    // Create base HTTP client with connection pooling
+    // Wrap with auth if auth manager is provided
+    const httpClient = authManager
+        ? new AuthHttpClient(baseHttpClient, authManager)
+        : baseHttpClient;
+    // Construct endpoint URLs
+    const uploadEndpoint = `${baseURL}/${uploadistBasePath}/api/upload`;
+    const flowEndpoint = `${baseURL}/${uploadistBasePath}/api/flow`;
+    const jobsEndpoint = `${baseURL}/${uploadistBasePath}/api/jobs`;
+    // WebSocket URLs
+    const wsBaseURL = baseURL.replace("http", "ws");
+    const uploadWsURL = `${wsBaseURL}/uploadista/ws/upload`;
+    const flowWsURL = `${wsBaseURL}/uploadista/ws/flow`;
+    /**
+     * Helper function to extract auth token for WebSocket connection.
+     * Supports both DirectAuthManager (extracts from headers) and SaasAuthManager (gets cached token).
+     */
+    const getAuthTokenForWebSocket = async (manager, jobId) => {
+        logger?.log(`Getting auth token for WebSocket (jobId: ${jobId})`);
+        // Check if this is a SaasAuthManager (has attachToken method)
+        if ("attachToken" in manager) {
+            logger?.log("Detected SaasAuthManager, calling attachToken");
+            const headers = await manager.attachToken({}, jobId);
+            const authHeader = headers.Authorization;
+            if (authHeader?.startsWith("Bearer ")) {
+                logger?.log("Successfully extracted Bearer token from SaasAuthManager");
+                return authHeader.substring(7); // Remove "Bearer " prefix
+            }
+            logger?.log(`No valid Authorization header from SaasAuthManager: ${authHeader}`);
+        }
+        // Check if this is a DirectAuthManager (has attachCredentials method)
+        if ("attachCredentials" in manager) {
+            logger?.log("Detected DirectAuthManager, calling attachCredentials");
+            const headers = await manager.attachCredentials({});
+            const authHeader = headers.Authorization;
+            if (authHeader) {
+                logger?.log("Successfully extracted Authorization header from DirectAuthManager");
+                // Support both "Bearer token" and plain token formats
+                return authHeader.startsWith("Bearer ")
+                    ? authHeader.substring(7)
+                    : authHeader;
+            }
+            logger?.log(`No Authorization header from DirectAuthManager`);
+        }
+        logger?.log("No auth token could be extracted from auth manager");
+        return null;
+    };
+    return {
+        // Upload operations
+        getUpload: async (uploadId) => {
+            const res = await httpClient.request(`${uploadEndpoint}/${uploadId}`);
+            if (!res.ok) {
+                const errorData = (await res.json().catch(() => ({})));
+                const errorName = mapServerErrorCodeToClientName(errorData.code, "UPLOAD_NOT_FOUND");
+                const errorMessage = errorData.error ||
+                    errorData.message ||
+                    `Upload ${uploadId} not found`;
+                throw new UploadistaError({
+                    name: errorName,
+                    message: errorData.code
+                        ? `${errorMessage} (${errorData.code})`
+                        : errorMessage,
+                    status: res.status,
+                });
+            }
+            const data = (await res.json());
+            return { status: res.status, upload: data };
+        },
+        deleteUpload: async (uploadId) => {
+            const res = await httpClient.request(`${uploadEndpoint}/${uploadId}`, {
+                method: "DELETE",
+            });
+            if (!res.ok) {
+                const errorData = (await res.json().catch(() => ({})));
+                const errorName = mapServerErrorCodeToClientName(errorData.code, "DELETE_UPLOAD_FAILED");
+                const errorMessage = errorData.error ||
+                    errorData.message ||
+                    `Failed to delete upload ${uploadId}`;
+                throw new UploadistaError({
+                    name: errorName,
+                    message: errorData.code
+                        ? `${errorMessage} (${errorData.code})`
+                        : errorMessage,
+                    status: res.status,
+                });
+            }
+            return { status: res.status };
+        },
+        createUpload: async (data) => {
+            logger?.log(`createUpload ${JSON.stringify(data)}`);
+            const res = await httpClient.request(uploadEndpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(data),
+            });
+            if (!res.ok) {
+                const errorData = (await res.json().catch(() => ({})));
+                const errorName = mapServerErrorCodeToClientName(errorData.code, "CREATE_UPLOAD_FAILED");
+                const errorMessage = errorData.error || errorData.message || "Failed to create upload";
+                throw new UploadistaError({
+                    name: errorName,
+                    message: errorData.code
+                        ? `${errorMessage} (${errorData.code})`
+                        : errorMessage,
+                    status: res.status,
+                });
+            }
+            const responseData = (await res.json());
+            logger?.log(JSON.stringify(responseData));
+            return { status: res.status, upload: responseData };
+        },
+        uploadChunk: async (uploadId, data, { abortController }) => {
+            try {
+                const res = await httpClient.request(`${uploadEndpoint}/${uploadId}`, {
+                    method: "PATCH",
+                    headers: {
+                        "Content-Type": "application/octet-stream",
+                    },
+                    body: data,
+                    signal: abortController?.signal,
+                });
+                if (!res.ok) {
+                    const errorData = (await res
+                        .json()
+                        .catch(() => ({})));
+                    throw new UploadistaError({
+                        name: "NETWORK_ERROR",
+                        message: errorData.error || errorData.message || "Unknown network error",
+                        status: res.status,
+                    });
+                }
+                const responseData = (await res.json());
+                return { status: res.status, upload: responseData };
+            }
+            catch (err) {
+                if (err instanceof UploadistaError) {
+                    throw err;
+                }
+                throw new UploadistaError({
+                    name: "NETWORK_ERROR",
+                    message: "Network error",
+                    cause: err,
+                });
+            }
+        },
+        // Flow operations
+        getFlow: async (flowId) => {
+            const res = await httpClient.request(`${flowEndpoint}/${flowId}`);
+            if (!res.ok) {
+                const errorData = (await res.json().catch(() => ({})));
+                const errorName = mapServerErrorCodeToClientName(errorData.code, "FLOW_NOT_FOUND");
+                const errorMessage = errorData.error || errorData.message || `Flow ${flowId} not found`;
+                throw new UploadistaError({
+                    name: errorName,
+                    message: errorData.code
+                        ? `${errorMessage} (${errorData.code})`
+                        : errorMessage,
+                    status: res.status,
+                });
+            }
+            const data = (await res.json());
+            logger?.log(`getFlow: ${flowId}`);
+            return { status: res.status, flow: data };
+        },
+        runFlow: async (flowId, storageId, inputs) => {
+            logger?.log(`runFlow: ${flowId} with storage: ${storageId}`);
+            const res = await httpClient.request(`${flowEndpoint}/${flowId}/${storageId}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ inputs }),
+            });
+            if (!res.ok) {
+                const errorData = (await res.json().catch(() => ({})));
+                const errorName = mapServerErrorCodeToClientName(errorData.code, "FLOW_RUN_FAILED");
+                const errorMessage = errorData.error ||
+                    errorData.message ||
+                    `Failed to run flow ${flowId}`;
+                throw new UploadistaError({
+                    name: errorName,
+                    message: errorData.code
+                        ? `${errorMessage} (${errorData.code})`
+                        : errorMessage,
+                    status: res.status,
+                });
+            }
+            const data = (await res.json());
+            logger?.log(`runFlow response: ${JSON.stringify(data)}`);
+            return { status: res.status, job: data };
+        },
+        continueFlow: async (jobId, nodeId, newData, options) => {
+            logger?.log(`continueFlow: ${jobId} at node: ${nodeId}`);
+            const contentType = options?.contentType || "application/json";
+            let body;
+            if (contentType === "application/octet-stream") {
+                // For octet-stream, newData should be a Uint8Array or similar
+                body = newData;
+            }
+            else {
+                // For JSON, wrap newData in an object
+                body = JSON.stringify({ newData });
+            }
+            const res = await httpClient.request(`${jobsEndpoint}/${jobId}/continue/${nodeId}`, {
+                method: "PATCH",
+                headers: {
+                    "Content-Type": contentType,
+                },
+                body,
+            });
+            if (!res.ok) {
+                const errorData = (await res.json().catch(() => ({})));
+                const errorName = mapServerErrorCodeToClientName(errorData.code, "FLOW_CONTINUE_FAILED");
+                const errorMessage = errorData.error ||
+                    errorData.message ||
+                    `Failed to continue flow for job ${jobId}`;
+                throw new UploadistaError({
+                    name: errorName,
+                    message: errorData.code
+                        ? `${errorMessage} (${errorData.code})`
+                        : errorMessage,
+                    status: res.status,
+                });
+            }
+            const data = (await res.json());
+            return data;
+        },
+        // Unified job operations
+        getJobStatus: async (jobId) => {
+            const res = await httpClient.request(`${jobsEndpoint}/${jobId}/status`);
+            if (!res.ok) {
+                const errorData = (await res.json().catch(() => ({})));
+                const errorName = mapServerErrorCodeToClientName(errorData.code, "JOB_NOT_FOUND");
+                const errorMessage = errorData.error || errorData.message || `Job ${jobId} not found`;
+                throw new UploadistaError({
+                    name: errorName,
+                    message: errorData.code
+                        ? `${errorMessage} (${errorData.code})`
+                        : errorMessage,
+                    status: res.status,
+                });
+            }
+            const data = (await res.json());
+            return data;
+        },
+        // WebSocket operations
+        openUploadWebSocket: async (uploadId) => {
+            let wsUrl = `${uploadWsURL}/${uploadId}`;
+            // Attach auth token if auth manager is configured
+            // Note: For cookie-based auth (e.g., HttpOnly cookies with better-auth),
+            // no token is needed as cookies are automatically sent by the browser
+            if (authManager) {
+                try {
+                    const token = await getAuthTokenForWebSocket(authManager, uploadId);
+                    if (token) {
+                        wsUrl += `?token=${encodeURIComponent(token)}`;
+                        logger?.log(`WebSocket token attached for upload: ${uploadId}`);
+                    }
+                    else {
+                        // No token means cookie-based auth - this is fine
+                        logger?.log(`No token for upload WebSocket (using cookie-based auth): ${uploadId}`);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger?.log(`Error getting auth token for upload WebSocket: ${errorMessage}`);
+                    // Don't throw - allow cookie-based auth to proceed
+                    logger?.log(`Proceeding with cookie-based authentication for upload WebSocket: ${uploadId}`);
+                }
+            }
+            const ws = webSocketFactory.create(wsUrl);
+            ws.onopen = () => {
+                logger?.log(`Upload WebSocket connection opened for: ${uploadId}`);
+            };
+            ws.onclose = () => {
+                logger?.log(`Upload WebSocket connection closed for: ${uploadId}`);
+            };
+            ws.onerror = (error) => {
+                logger?.log(`Upload WebSocket error for ${uploadId}: ${error}`);
+            };
+            return ws;
+        },
+        openFlowWebSocket: async (jobId) => {
+            let wsUrl = `${flowWsURL}/${jobId}`;
+            // Attach auth token if auth manager is configured
+            // Note: For cookie-based auth (e.g., HttpOnly cookies with better-auth),
+            // no token is needed as cookies are automatically sent by the browser
+            if (authManager) {
+                try {
+                    const token = await getAuthTokenForWebSocket(authManager, jobId);
+                    if (token) {
+                        wsUrl += `?token=${encodeURIComponent(token)}`;
+                        logger?.log(`WebSocket token attached for flow job: ${jobId}`);
+                    }
+                    else {
+                        // No token means cookie-based auth - this is fine
+                        logger?.log(`No token for flow WebSocket (using cookie-based auth): ${jobId}`);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger?.log(`Error getting auth token for flow WebSocket: ${errorMessage}`);
+                    // Don't throw - allow cookie-based auth to proceed
+                    logger?.log(`Proceeding with cookie-based authentication for flow WebSocket: ${jobId}`);
+                }
+            }
+            const ws = webSocketFactory.create(wsUrl);
+            ws.onopen = () => {
+                logger?.log(`Flow WebSocket connection opened for job: ${jobId}`);
+            };
+            ws.onclose = () => {
+                logger?.log(`Flow WebSocket connection closed for job: ${jobId}`);
+            };
+            ws.onerror = (error) => {
+                logger?.log(`Flow WebSocket error for job ${jobId}: ${error}`);
+            };
+            return ws;
+        },
+        closeWebSocket: (ws) => {
+            ws.close();
+        },
+        // Connection metrics
+        getConnectionMetrics: () => {
+            return httpClient.getMetrics();
+        },
+        getDetailedConnectionMetrics: () => {
+            return httpClient.getDetailedMetrics();
+        },
+        warmupConnections: async (urls) => {
+            return httpClient.warmupConnections(urls);
+        },
+        // Capabilities
+        getCapabilities: async (storageId) => {
+            const capabilitiesUrl = `${uploadEndpoint}/capabilities?storageId=${encodeURIComponent(storageId)}`;
+            try {
+                const response = await httpClient.request(capabilitiesUrl, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                });
+                if (!response.ok) {
+                    logger?.log(`Failed to fetch capabilities: ${response.status} ${response.statusText}`);
+                    return defaultClientCapabilities;
+                }
+                const data = await response.json();
+                return data.capabilities;
+            }
+            catch (error) {
+                logger?.log(`Failed to fetch server capabilities, using defaults: ${error}`);
+                return defaultClientCapabilities;
+            }
+        },
+    };
+}

package/dist/client/uploadista-websocket-manager.d.ts

@@ -0,0 +1,110 @@
+import type { FlowEvent } from "@uploadista/core/flow";
+import type { UploadEvent } from "@uploadista/core/types";
+import type { Logger } from "../logger";
+import type { WebSocketLike } from "../services/websocket-service";
+import type { UploadistaApi } from "./uploadista-api";
+export type UploadistaEvent = UploadEvent | FlowEvent;
+export type UploadistaWebSocketEventHandler = (event: UploadistaEvent) => void;
+export type UploadistaWebSocketMessage = {
+    type: "connection";
+    message: string;
+    id: string;
+    timestamp: string;
+} | {
+    type: "subscribed";
+    payload: {
+        uploadId?: string;
+        jobId?: string;
+    };
+    timestamp: string;
+} | {
+    type: "error";
+    message: string;
+    code?: string;
+} | {
+    type: "pong";
+    timestamp: string;
+} | {
+    type: "upload_event";
+    payload: UploadEvent;
+} | {
+    type: "flow_event";
+    payload: FlowEvent;
+};
+/**
+ * Unified WebSocket management for both upload and flow events
+ */
+export declare class UploadistaWebSocketManager {
+    private uploadistaApi;
+    private logger;
+    private onEvent?;
+    private uploadWebsockets;
+    private flowWebsockets;
+    constructor(uploadistaApi: UploadistaApi, logger: Logger, onEvent?: UploadistaWebSocketEventHandler | undefined);
+    /**
+     * Open a WebSocket connection for upload events
+     */
+    openUploadWebSocket(uploadId: string): Promise<WebSocketLike>;
+    /**
+     * Open a WebSocket connection for flow/job events
+     */
+    openFlowWebSocket(jobId: string): Promise<WebSocketLike>;
+    /**
+     * Open a unified WebSocket connection - automatically determines if it's for upload or flow
+     * based on the ID format (upload IDs typically start with 'upload-', job IDs start with 'job-')
+     */
+    openWebSocket(id: string): Promise<WebSocketLike>;
+    /**
+     * Close upload WebSocket connection
+     */
+    closeUploadWebSocket(uploadId: string): void;
+    /**
+     * Close flow WebSocket connection
+     */
+    closeFlowWebSocket(jobId: string): void;
+    /**
+     * Close WebSocket connection by ID (auto-detects type)
+     */
+    closeWebSocket(id: string): void;
+    /**
+     * Close all WebSocket connections (both upload and flow)
+     */
+    closeAll(): void;
+    /**
+     * Send ping to flow WebSocket
+     */
+    sendPing(jobId: string): boolean;
+    /**
+     * Get upload WebSocket by ID
+     */
+    getUploadWebSocket(uploadId: string): WebSocketLike | undefined;
+    /**
+     * Get flow WebSocket by ID
+     */
+    getFlowWebSocket(jobId: string): WebSocketLike | undefined;
+    /**
+     * Check if upload WebSocket is connected
+     */
+    isUploadConnected(uploadId: string): boolean;
+    /**
+     * Check if flow WebSocket is connected
+     */
+    isFlowConnected(jobId: string): boolean;
+    /**
+     * Check if WebSocket is connected (auto-detects type)
+     */
+    isConnected(id: string): boolean;
+    /**
+     * Get total number of active WebSocket connections
+     */
+    getConnectionCount(): number;
+    /**
+     * Get connection counts by type
+     */
+    getConnectionCountByType(): {
+        upload: number;
+        flow: number;
+        total: number;
+    };
+}
+//# sourceMappingURL=uploadista-websocket-manager.d.ts.map

package/dist/client/uploadista-websocket-manager.d.ts.map

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