@eka-care/medassist-core 1.0.70 → 1.0.71

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

@@ -1,131 +0,0 @@
-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

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

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

@@ -1,229 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,134 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-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

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