@eka-care/medassist-core 1.0.66 → 1.0.67

package/dist/esm/internal/Api/HttpClient.js

@@ -0,0 +1,131 @@
+import { APIError, APIConnectionTimeoutError, } from "../Error/Error";
+export class HttpClient {
+    baseUrl;
+    headers;
+    timeout;
+    maxRetries;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, ""); // Remove trailing slash
+        this.timeout = config.timeout || 30000;
+        this.maxRetries = config.maxRetries || 3;
+        this.headers = {
+            "Content-Type": "application/json",
+            ...config.headers, // Include custom headers
+        };
+        if (config.authorization) {
+            this.headers["Authorization"] = config.authorization;
+        }
+    }
+    async request(method, path, options) {
+        const maxRetries = options?.retries ?? this.maxRetries;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const url = this.buildUrl(path, options?.params);
+                const response = await fetch(url, {
+                    method,
+                    headers: {
+                        ...this.headers,
+                        ...options?.headers,
+                    },
+                    body: options?.body ? JSON.stringify(options.body) : undefined,
+                    signal: AbortSignal.timeout(this.timeout),
+                });
+                if (!response.ok) {
+                    await this.handleError(response);
+                }
+                return response.json();
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on the last attempt
+                if (attempt === maxRetries) {
+                    break;
+                }
+                // Only retry on network errors and timeouts
+                const shouldRetry = (error instanceof TypeError && error.message === "Failed to fetch") ||
+                    (error instanceof DOMException && error.name === "AbortError") ||
+                    error instanceof SyntaxError;
+                if (!shouldRetry) {
+                    // Don't retry for API errors (4xx, 5xx), parsing errors, etc.
+                    break;
+                }
+                // Exponential backoff: wait 2^attempt * 100ms
+                const delay = Math.pow(2, attempt) * 100;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        // If we get here, all retries failed
+        if (!lastError) {
+            throw new APIError("Unknown error occurred", 500, {
+                type: "UNKNOWN_ERROR",
+            });
+        }
+        if (lastError instanceof TypeError &&
+            lastError.message === "Failed to fetch") {
+            // Network error - no internet, DNS failure, etc.
+            throw new APIError("Network error: Unable to connect to the server. Please check your internet connection.", 0, { type: "NETWORK_ERROR", originalError: lastError.message });
+        }
+        if (lastError instanceof DOMException && lastError.name === "AbortError") {
+            // Timeout error
+            throw new APIConnectionTimeoutError({
+                message: `Request timed out after ${this.timeout}ms`,
+            });
+        }
+        if (lastError instanceof SyntaxError) {
+            // JSON parsing error
+            throw new APIError("Invalid response format from server", 502, {
+                type: "PARSE_ERROR",
+                originalError: lastError.message,
+            });
+        }
+        // If it's already an APIError, re-throw it
+        if (lastError instanceof APIError) {
+            throw lastError;
+        }
+        // Any other unexpected error
+        throw new APIError(`Request failed: ${lastError.message || "Unknown error"}`, 500, { type: "UNKNOWN_ERROR", originalError: lastError });
+    }
+    async get(path, params, options) {
+        return this.request("GET", path, { params, ...options });
+    }
+    async post(path, body, options) {
+        return this.request("POST", path, { body, ...options });
+    }
+    async put(path, body, options) {
+        return this.request("PUT", path, { body, ...options });
+    }
+    async delete(path, options) {
+        return this.request("DELETE", path, { ...options });
+    }
+    async patch(path, body, options) {
+        return this.request("PATCH", path, { body, ...options });
+    }
+    buildUrl(path, params) {
+        let url = `${this.baseUrl}${path}`;
+        if (params) {
+            const queryString = new URLSearchParams(params).toString();
+            url += `?${queryString}`;
+        }
+        return url;
+    }
+    async handleError(response) {
+        let errorMessage;
+        let errorData;
+        try {
+            errorData = await response.json();
+            const body = errorData;
+            const nestedError = body?.error;
+            errorMessage =
+                body?.message ||
+                    body?.msg ||
+                    nestedError?.msg ||
+                    nestedError?.message ||
+                    response.statusText;
+        }
+        catch (error) {
+            errorMessage = response.statusText;
+        }
+        throw APIError.generate(response.status, errorData, errorMessage, response.headers);
+    }
+}

package/dist/esm/internal/Api/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/internal/Error/Error.js

@@ -0,0 +1,229 @@
+export const SynapseErrorCode = {
+    API: "API_ERROR",
+    CONNECTION: "CONNECTION_ERROR",
+    RECORDING: "RECORDING_ERROR",
+    FILE: "FILE_ERROR",
+    SESSION: "SESSION_ERROR",
+    MESSAGE: "MESSAGE_ERROR",
+    STORE: "STORE_ERROR",
+    CONFIGURATION: "CONFIGURATION_ERROR",
+    VALIDATION: "VALIDATION_ERROR",
+    AUTH: "AUTH_ERROR",
+    UNKNOWN: "UNKNOWN_ERROR",
+};
+export class SynapseError extends Error {
+    code;
+    timestamp;
+    cause;
+    context;
+    hint;
+    displayMessage;
+    constructor(message, code = SynapseErrorCode.UNKNOWN, options = {}) {
+        super(message);
+        this.name = "SynapseError";
+        this.code = code;
+        this.timestamp = new Date();
+        this.cause = options.cause;
+        this.context = options.context;
+        this.hint = options.hint;
+        this.displayMessage = options.displayMessage || options?.hint || message;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+export class APIError extends SynapseError {
+    /** HTTP status code */
+    status;
+    /** JSON body of the error response or custom error object */
+    error;
+    /** HTTP response headers */
+    headers;
+    constructor(message, status, error, headers) {
+        const errorMessage = APIError.makeMessage(status, error, message);
+        super(errorMessage, SynapseErrorCode.API, {
+            cause: error,
+            context: {
+                status,
+                hasBody: Boolean(error),
+            },
+            hint: status && status >= 500
+                ? "Retry the request or contact support if the issue persists."
+                : undefined,
+            displayMessage: message || "Something went wrong", //give user friednly message,
+        });
+        this.name = "APIError";
+        this.status = status;
+        this.error = error;
+        this.headers = headers;
+    }
+    static makeMessage(status, error, message) {
+        const msg = error instanceof Error ? error.message : message;
+        if (status && msg) {
+            return `HTTP ${status}: ${msg}`;
+        }
+        if (status) {
+            return `${status} status code (no body)`;
+        }
+        if (msg) {
+            return msg;
+        }
+        return "(no status code or body)";
+    }
+    static generate(status, errorResponse, message, headers) {
+        if (!status) {
+            return new APIUserAbortError({ message });
+        }
+        const extractedError = errorResponse?.["error"];
+        const error = extractedError &&
+            typeof extractedError === "object" &&
+            !Array.isArray(extractedError)
+            ? extractedError
+            : undefined;
+        switch (status) {
+            case 400:
+                return new BadRequestError(message || "Bad Request", status, error, headers);
+            case 401:
+                return new UnauthorizedError(message || "Unauthorized", status, error, headers);
+            case 403:
+                return new PermissionDeniedError(message || "Permission Denied", status, error, headers);
+            case 404:
+                return new NotFoundError(message || "Not Found", status, error, headers);
+            case 405:
+                return new MethodNotAllowedError(message || "Method Not Allowed", status, error, headers);
+            case 429:
+                return new RateLimitError(message || "Rate Limit Exceeded", status, error, headers);
+            case 500:
+                return new InternalServerError(message || "Internal Server Error", status, error, headers);
+            default:
+                return new APIError(message || "API Error", status, error, headers);
+        }
+    }
+}
+export class APIUserAbortError extends APIError {
+    constructor({ message } = {}) {
+        super(message || "Request was aborted.", undefined, undefined, undefined);
+        this.name = "APIUserAbortError";
+    }
+}
+export class APIConnectionTimeoutError extends APIError {
+    constructor({ message } = {}) {
+        super(message || "Request timed out.", undefined, undefined, undefined);
+        this.name = "APIConnectionTimeoutError";
+    }
+}
+export class BadRequestError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "BadRequestError";
+    }
+}
+export class UnauthorizedError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "UnauthorizedError";
+    }
+}
+export class PermissionDeniedError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "PermissionDeniedError";
+    }
+}
+export class NotFoundError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "NotFoundError";
+    }
+}
+export class MethodNotAllowedError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "MethodNotAllowedError";
+    }
+}
+export class RateLimitError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "RateLimitError";
+    }
+}
+export class InternalServerError extends APIError {
+    constructor(message, status, error, headers) {
+        super(message, status, error, headers);
+        this.name = "InternalServerError";
+    }
+}
+export class ConnectionError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.CONNECTION, options);
+        this.name = "ConnectionError";
+    }
+}
+export class RecordingError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.RECORDING, options);
+        this.name = "RecordingError";
+    }
+}
+export class AuthenticationError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.AUTH, options);
+        this.name = "AuthenticationError";
+    }
+}
+export class FileError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.FILE, options);
+        this.name = "FileError";
+    }
+}
+export class SessionError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.SESSION, options);
+        this.name = "SessionError";
+    }
+}
+export class MessageError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.MESSAGE, options);
+        this.name = "MessageError";
+    }
+}
+export class StoreError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.STORE, options);
+        this.name = "StoreError";
+    }
+}
+export class ConfigurationError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.CONFIGURATION, options);
+        this.name = "ConfigurationError";
+    }
+}
+export class ValidationError extends SynapseError {
+    constructor(message, options = {}) {
+        super(message, SynapseErrorCode.VALIDATION, options);
+        this.name = "ValidationError";
+    }
+}
+export function normalizeError(error, ctor, fallbackMessage, options = {}) {
+    if (error instanceof ctor) {
+        return error;
+    }
+    const baseOptions = {
+        ...options,
+        context: {
+            ...(error instanceof SynapseError ? error.context : undefined),
+            ...options.context,
+        },
+        hint: options.hint ?? (error instanceof SynapseError ? error.hint : undefined),
+        cause: options.cause ?? error,
+    };
+    if (error instanceof SynapseError) {
+        return new ctor(error.message, baseOptions);
+    }
+    const message = error instanceof Error && error.message ? error.message : fallbackMessage;
+    return new ctor(message, baseOptions);
+}

package/dist/esm/internal/Error/types.js

@@ -0,0 +1,9 @@
+export const ErrorType = {
+    NETWORK_ERROR: "NETWORK_ERROR",
+    TIMEOUT_ERROR: "TIMEOUT_ERROR",
+    API_ERROR: "API_ERROR",
+    RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR",
+    SERVER_ERROR: "SERVER_ERROR",
+    PARSE_ERROR: "PARSE_ERROR",
+    UNKNOWN_ERROR: "UNKNOWN_ERROR",
+};

package/dist/esm/internal/connection/BaseConnection.js

@@ -0,0 +1,134 @@
+/**
+ * Abstract base class for all connection types
+ */
+import { EventEmitter } from "../events/EventEmitter";
+import { ConnectionStatus, } from "./types";
+export class BaseConnection {
+    /**
+     * Current connection status
+     */
+    status = ConnectionStatus.CONNECTING;
+    /**
+     * Queue to store messages received before callback is registered
+     */
+    queue = [];
+    /**
+     * Event emitter to handle events
+     */
+    eventEmitter = new EventEmitter();
+    /**
+     * Disconnection details (null if still connected)
+     */
+    disconnectionDetails = null;
+    onErrorCallback = null;
+    onDisconnectCallback = null;
+    onMessageCallback = null;
+    onOpenCallback = null;
+    onStatusChangeCallback = null;
+    /**
+     * Get current connection status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Register callback for connection open events
+     */
+    onOpen(callback) {
+        this.onOpenCallback = callback;
+    }
+    /**
+     * Register callback for incoming messages
+     */
+    onMessage(callback) {
+        this.onMessageCallback = callback;
+        if (this.queue.length > 0) {
+            const pendingMessages = [...this.queue];
+            this.queue.length = 0;
+            queueMicrotask(() => {
+                pendingMessages.forEach((message) => {
+                    this.onMessageCallback?.(message);
+                });
+            });
+        }
+    }
+    /**
+     * Register callback for disconnection events
+     */
+    onDisconnect(callback) {
+        this.onDisconnectCallback = callback;
+        const details = this.disconnectionDetails;
+        if (details) {
+            queueMicrotask(() => {
+                this.onDisconnectCallback?.(details);
+            });
+        }
+    }
+    /**
+     * Register callback for error events
+     */
+    onError(callback) {
+        this.onErrorCallback = callback;
+    }
+    /**
+     * Register a listener for a specific event
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    /**
+     * Remove a listener for a specific event
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    /**
+     * Emit an event
+     */
+    emit(event, ...args) {
+        this.eventEmitter.emit(event, ...args);
+    }
+    /**
+     * Register callback for status changes
+     */
+    onStatusChange(callback) {
+        this.onStatusChangeCallback = callback;
+        // Immediately invoke with current status
+        queueMicrotask(() => {
+            callback(this.status);
+        });
+    }
+    /**
+     * Protected method to handle disconnection
+     * Ensures disconnect callback is only invoked once
+     */
+    disconnect(details) {
+        if (!this.disconnectionDetails) {
+            this.disconnectionDetails = details;
+            this.updateStatus(ConnectionStatus.NOT_CONNECTED);
+            this.onDisconnectCallback?.(details);
+        }
+    }
+    /**
+     * Protected method to handle incoming messages
+     * Queues messages if no callback is registered yet
+     * message type can be extended to include more types of messages
+     */
+    handleMessage(message) {
+        if (this.onMessageCallback) {
+            this.onMessageCallback(message);
+        }
+        else {
+            this.queue.push(message);
+        }
+    }
+    /**
+     * Protected method to update connection status
+     */
+    updateStatus(status) {
+        if (this.status !== status) {
+            this.status = status;
+            this.onStatusChangeCallback?.(status);
+        }
+    }
+}

package/dist/esm/internal/connection/types.js

@@ -0,0 +1,17 @@
+/**
+ * Connection types and interfaces for the Synapse SDK
+ */
+export const ConnectionStatus = {
+    CONNECTING: "connecting",
+    CONNECTED: "connected",
+    NOT_CONNECTED: "not_connected",
+};
+export const DisconnectionReason = {
+    CLIENT_CLOSED: "client_closed",
+    SERVER_CLOSED: "server_closed",
+    CONNECTION_ERROR: "connection_error",
+    AUTHENTICATION_ERROR: "authentication_error",
+    MAX_RECONNECT_ATTEMPTS: "max_reconnect_attempts",
+    TIMEOUT: "timeout",
+    NETWORK_ERROR: "network_error",
+};

package/dist/esm/internal/events/EventEmitter.js

@@ -0,0 +1,26 @@
+export class EventEmitter {
+    eventListeners = new Map();
+    on(event, listener) {
+        const listeners = this.eventListeners.get(event) || new Set();
+        listeners.add(listener);
+        this.eventListeners.set(event, listeners);
+    }
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.eventListeners.delete(event);
+            }
+        }
+    }
+    emit(event, ...args) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach((listener) => listener(...args));
+        }
+    }
+    removeAllListeners() {
+        this.eventListeners.clear();
+    }
+}

package/dist/esm/internal/store/index.js

@@ -0,0 +1,5 @@
+/**
+ * make an abstract class for all types of storage (localStorage, sessionStorage, etc.)
+ */
+export class Storage {
+}