@elqnt/chat 3.0.2 → 3.0.3

package/dist/hooks/index.mjs

@@ -372,8 +372,394 @@ function createSSETransport(options = {}) {
   return transport;
 }
 
+// transport/sse-fetch.ts
+function createFetchSSETransport(options = {}) {
+  const {
+    retryConfig = DEFAULT_RETRY_CONFIG,
+    debug = false,
+    logger = createLogger(debug),
+    customFetch = fetch
+  } = options;
+  let abortController;
+  let config;
+  let state = "disconnected";
+  let error;
+  let retryCount = 0;
+  let reconnectTimeout;
+  let intentionalDisconnect = false;
+  const metrics = {
+    latency: 0,
+    messagesSent: 0,
+    messagesReceived: 0,
+    messagesQueued: 0,
+    reconnectCount: 0,
+    transportType: "sse-fetch"
+  };
+  const globalHandlers = /* @__PURE__ */ new Set();
+  const typeHandlers = /* @__PURE__ */ new Map();
+  function emit(event) {
+    metrics.messagesReceived++;
+    metrics.lastMessageAt = Date.now();
+    globalHandlers.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (err) {
+        logger.error("Error in message handler:", err);
+      }
+    });
+    const handlers = typeHandlers.get(event.type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (err) {
+          logger.error(`Error in ${event.type} handler:`, err);
+        }
+      });
+    }
+  }
+  async function sendRest(endpoint, body) {
+    if (!config) {
+      throw new Error("Transport not connected");
+    }
+    const url = `${config.baseUrl}/${endpoint}`;
+    logger.debug(`POST ${endpoint}`, body);
+    const response = await customFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} - ${errorText}`);
+    }
+    const json = await response.json();
+    if (json && typeof json === "object" && "data" in json) {
+      return json.data;
+    }
+    return json;
+  }
+  function parseSSEChunk(chunk) {
+    const events = [];
+    const lines = chunk.split("\n");
+    let eventType = "message";
+    let data = "";
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        eventType = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        data = line.slice(5).trim();
+      } else if (line === "" && data) {
+        try {
+          const parsed = JSON.parse(data);
+          events.push(parsed);
+        } catch {
+          logger.warn("Failed to parse SSE data:", data);
+        }
+        eventType = "message";
+        data = "";
+      }
+    }
+    return events;
+  }
+  async function startStream(cfg) {
+    const url = `${cfg.baseUrl}/stream?orgId=${cfg.orgId}&userId=${cfg.userId}&clientType=${cfg.clientType}${cfg.chatKey ? `&chatId=${cfg.chatKey}` : ""}`;
+    logger.debug("Connecting to:", url);
+    abortController = new AbortController();
+    const response = await customFetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache"
+      },
+      signal: abortController.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Stream connection failed: ${response.status}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null - ReadableStream not supported");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const readStream = async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            logger.info("Stream ended");
+            break;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lastNewline = buffer.lastIndexOf("\n\n");
+          if (lastNewline !== -1) {
+            const complete = buffer.slice(0, lastNewline + 2);
+            buffer = buffer.slice(lastNewline + 2);
+            const events = parseSSEChunk(complete);
+            events.forEach(emit);
+          }
+        }
+      } catch (err) {
+        if (err.name === "AbortError") {
+          logger.debug("Stream aborted");
+          return;
+        }
+        logger.error("Stream error:", err);
+        throw err;
+      }
+      if (!intentionalDisconnect) {
+        state = "disconnected";
+        scheduleReconnect();
+      }
+    };
+    readStream().catch((err) => {
+      if (!intentionalDisconnect) {
+        error = {
+          code: "CONNECTION_FAILED",
+          message: err.message,
+          retryable: true,
+          timestamp: Date.now(),
+          originalError: err
+        };
+        metrics.lastError = error;
+        state = "disconnected";
+        scheduleReconnect();
+      }
+    });
+  }
+  function scheduleReconnect() {
+    if (intentionalDisconnect || !config) return;
+    const maxRetries = retryConfig.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries;
+    if (retryCount >= maxRetries) {
+      logger.error(`Max retries (${maxRetries}) exceeded`);
+      error = {
+        code: "CONNECTION_FAILED",
+        message: `Max retries (${maxRetries}) exceeded`,
+        retryable: false,
+        timestamp: Date.now()
+      };
+      return;
+    }
+    const interval = calculateRetryInterval(retryCount, retryConfig);
+    retryCount++;
+    metrics.reconnectCount++;
+    logger.info(`Reconnecting in ${interval}ms (attempt ${retryCount})`);
+    state = "reconnecting";
+    reconnectTimeout = setTimeout(() => {
+      if (config) {
+        transport.connect(config).catch((err) => {
+          logger.error("Reconnect failed:", err);
+        });
+      }
+    }, interval);
+  }
+  const transport = {
+    async connect(cfg) {
+      config = cfg;
+      intentionalDisconnect = false;
+      if (abortController) {
+        abortController.abort();
+        abortController = void 0;
+      }
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      state = retryCount > 0 ? "reconnecting" : "connecting";
+      const connectionStart = Date.now();
+      try {
+        await startStream(cfg);
+        const connectionTime = Date.now() - connectionStart;
+        logger.info(`Connected in ${connectionTime}ms`);
+        state = "connected";
+        error = void 0;
+        retryCount = 0;
+        metrics.connectedAt = Date.now();
+        metrics.latency = connectionTime;
+      } catch (err) {
+        const connectError = {
+          code: "CONNECTION_FAILED",
+          message: err.message,
+          retryable: true,
+          timestamp: Date.now(),
+          originalError: err
+        };
+        error = connectError;
+        metrics.lastError = connectError;
+        state = "disconnected";
+        if (!intentionalDisconnect) {
+          scheduleReconnect();
+        }
+        throw connectError;
+      }
+    },
+    disconnect(intentional = true) {
+      logger.info("Disconnecting", { intentional });
+      intentionalDisconnect = intentional;
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      if (abortController) {
+        abortController.abort();
+        abortController = void 0;
+      }
+      state = "disconnected";
+      retryCount = 0;
+    },
+    async send(event) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      switch (event.type) {
+        case "message":
+          await sendRest("send", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            message: event.message
+          });
+          break;
+        case "typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: true
+          });
+          break;
+        case "stopped_typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: false
+          });
+          break;
+        case "load_chat":
+          await sendRest("load", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId
+          });
+          break;
+        case "new_chat":
+          await sendRest("create", {
+            orgId: event.orgId,
+            userId: event.userId,
+            metadata: event.data
+          });
+          break;
+        case "end_chat":
+          await sendRest("end", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+          break;
+        default:
+          await sendRest("event", {
+            type: event.type,
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+      }
+      metrics.messagesSent++;
+    },
+    async sendMessage(message) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      await sendRest("send", {
+        orgId: config.orgId,
+        chatKey: config.chatKey,
+        userId: config.userId,
+        message
+      });
+      metrics.messagesSent++;
+    },
+    async createChat(options2) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      const response = await sendRest("create", {
+        orgId: options2.orgId,
+        userId: options2.userId,
+        metadata: options2.metadata
+      });
+      if (!response?.chatKey) {
+        throw new Error("Failed to create chat: no chatKey returned");
+      }
+      return { chatKey: response.chatKey };
+    },
+    async loadChatData(options2) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      const response = await sendRest("load", {
+        orgId: options2.orgId,
+        chatKey: options2.chatKey,
+        userId: options2.userId
+      });
+      if (!response?.chat) {
+        throw new Error("Failed to load chat: no chat data returned");
+      }
+      return {
+        chat: response.chat,
+        agentId: response.agentId
+      };
+    },
+    onMessage(handler) {
+      globalHandlers.add(handler);
+      return () => globalHandlers.delete(handler);
+    },
+    on(eventType, handler) {
+      if (!typeHandlers.has(eventType)) {
+        typeHandlers.set(eventType, /* @__PURE__ */ new Set());
+      }
+      typeHandlers.get(eventType).add(handler);
+      return () => {
+        const handlers = typeHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(handler);
+          if (handlers.size === 0) {
+            typeHandlers.delete(eventType);
+          }
+        }
+      };
+    },
+    getState() {
+      return state;
+    },
+    getMetrics() {
+      return { ...metrics };
+    },
+    getError() {
+      return error;
+    },
+    clearError() {
+      error = void 0;
+    }
+  };
+  return transport;
+}
+
 // hooks/use-chat.ts
 function getDefaultTransport(type, debug) {
+  if (type === "sse-fetch") {
+    return createFetchSSETransport({ debug });
+  }
+  if (type === "sse") {
+    return createSSETransport({ debug });
+  }
+  const isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+  if (isReactNative || typeof EventSource === "undefined") {
+    return createFetchSSETransport({ debug });
+  }
   return createSSETransport({ debug });
 }
 function useChat(options) {
@@ -484,6 +870,7 @@ function useChat(options) {
       throw err;
     }
     setConnectionState("connecting");
+    onConnectionChange?.("connecting");
     try {
       const unsubscribe = transport.onMessage(handleEvent);
       await transport.connect({
@@ -502,6 +889,7 @@ function useChat(options) {
     } catch (err) {
       const transportError = err;
       setConnectionState("disconnected");
+      onConnectionChange?.("disconnected");
       setError(transportError);
       onErrorRef.current?.(transportError);
       throw err;
@@ -531,7 +919,7 @@ function useChat(options) {
     },
     [orgId, userId]
   );
-  const loadChat = useCallback(
+  const loadChat2 = useCallback(
     async (key) => {
       const transport = transportRef.current;
       if (!transport) {
@@ -584,7 +972,7 @@ function useChat(options) {
     },
     [orgId, chatKey, userId]
   );
-  const endChat = useCallback(
+  const endChat2 = useCallback(
     async (reason) => {
       const transport = transportRef.current;
       if (!transport) {
@@ -606,7 +994,7 @@ function useChat(options) {
     },
     [orgId, chatKey, userId]
   );
-  const sendEvent = useCallback(
+  const sendEvent2 = useCallback(
     async (event) => {
       const transport = transportRef.current;
       if (!transport) {
@@ -691,10 +1079,10 @@ function useChat(options) {
     isConnected,
     // Chat operations
     startChat,
-    loadChat,
+    loadChat: loadChat2,
     sendMessage,
-    sendEvent,
-    endChat,
+    sendEvent: sendEvent2,
+    endChat: endChat2,
     // Typing
     startTyping,
     stopTyping,
@@ -709,7 +1097,225 @@ function useChat(options) {
     clearError
   };
 }
+
+// hooks/use-chat-history.ts
+import { useMemo } from "react";
+
+// api/index.ts
+import { browserApiRequest } from "@elqnt/api-client/browser";
+async function getChatHistoryApi(options) {
+  return browserApiRequest("/api/v1/chats", {
+    method: "POST",
+    body: {
+      limit: options.limit || 15,
+      offset: options.offset || 0,
+      ...options.skipCache ? { skipCache: true } : {}
+    },
+    ...options
+  });
+}
+async function getChatApi(chatKey, options) {
+  return browserApiRequest(`/api/v1/chats/${chatKey}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function updateChatApi(chatKey, updates, options) {
+  return browserApiRequest(`/api/v1/chats/${chatKey}`, {
+    method: "PATCH",
+    body: updates,
+    ...options
+  });
+}
+async function deleteChatApi(chatKey, options) {
+  return browserApiRequest(`/api/v1/chats/${chatKey}`, {
+    method: "DELETE",
+    ...options
+  });
+}
+async function getActiveChatsCountApi(options) {
+  return browserApiRequest("/api/v1/chats/active/count", {
+    method: "GET",
+    ...options
+  });
+}
+async function getActiveChatsApi(options) {
+  const params = new URLSearchParams();
+  if (options.pastHours) params.set("pastHours", String(options.pastHours));
+  const queryString = params.toString();
+  return browserApiRequest(`/api/v1/chats/active${queryString ? `?${queryString}` : ""}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getWaitingChatsCountApi(options) {
+  return browserApiRequest("/api/v1/chats/waiting/count", {
+    method: "GET",
+    ...options
+  });
+}
+async function getChatsByUserApi(userEmail, options) {
+  return browserApiRequest(`/api/v1/chats/user/${encodeURIComponent(userEmail)}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function listQueuesApi(options) {
+  return browserApiRequest("/api/v1/queues", {
+    method: "GET",
+    ...options
+  });
+}
+async function getOnlineSessionsApi(options) {
+  return browserApiRequest("/api/v1/agents/sessions/online", {
+    method: "GET",
+    ...options
+  });
+}
+async function getAgentSessionApi(agentId, options) {
+  return browserApiRequest(`/api/v1/agents/sessions/${agentId}`, {
+    method: "GET",
+    ...options
+  });
+}
+
+// hooks/use-chat-history.ts
+import { useApiAsync } from "@elqnt/api-client/hooks";
+
+// hooks/use-options-ref.ts
+import { useRef as useRef2, useEffect as useEffect2 } from "react";
+function useOptionsRef(options) {
+  const optionsRef = useRef2(options);
+  useEffect2(() => {
+    optionsRef.current = options;
+  }, [options]);
+  return optionsRef;
+}
+
+// hooks/use-chat-history.ts
+function useChatHistory(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: getChatHistory, loading: listLoading, error: listError } = useApiAsync(
+    (params) => getChatHistoryApi({ ...optionsRef.current, ...params }),
+    (data) => ({
+      chats: data.chats,
+      total: data.total,
+      hasMore: data.hasMore
+    }),
+    { chats: [], total: 0, hasMore: false }
+  );
+  const { execute: getChat, loading: getLoading, error: getError } = useApiAsync(
+    (chatKey) => getChatApi(chatKey, optionsRef.current),
+    (data) => data.chat || null,
+    null
+  );
+  const { execute: updateChat, loading: updateLoading, error: updateError } = useApiAsync(
+    (chatKey, updates) => updateChatApi(chatKey, updates, optionsRef.current),
+    (data) => !!data.chatKey,
+    false
+  );
+  const { execute: deleteChat, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (chatKey) => deleteChatApi(chatKey, optionsRef.current),
+    (data) => data.success,
+    false
+  );
+  const { execute: getChatsByUser, loading: userChatsLoading, error: userChatsError } = useApiAsync(
+    (userEmail) => getChatsByUserApi(userEmail, optionsRef.current),
+    (data) => data.chats,
+    []
+  );
+  const loading = listLoading || getLoading || updateLoading || deleteLoading || userChatsLoading;
+  const error = listError || getError || updateError || deleteError || userChatsError;
+  return useMemo(
+    () => ({
+      loading,
+      error,
+      getChatHistory,
+      getChat,
+      updateChat,
+      deleteChat,
+      getChatsByUser
+    }),
+    [loading, error, getChatHistory, getChat, updateChat, deleteChat, getChatsByUser]
+  );
+}
+
+// hooks/use-chat-monitoring.ts
+import { useMemo as useMemo2 } from "react";
+import { useApiAsync as useApiAsync2 } from "@elqnt/api-client/hooks";
+function useChatMonitoring(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: getActiveChats, loading: activeLoading, error: activeError } = useApiAsync2(
+    (pastHours) => getActiveChatsApi({ ...optionsRef.current, pastHours }),
+    (data) => data.chats,
+    []
+  );
+  const { execute: getActiveChatsCount, loading: activeCountLoading, error: activeCountError } = useApiAsync2(
+    () => getActiveChatsCountApi(optionsRef.current),
+    (data) => data.count,
+    0
+  );
+  const { execute: getWaitingChatsCount, loading: waitingCountLoading, error: waitingCountError } = useApiAsync2(
+    () => getWaitingChatsCountApi(optionsRef.current),
+    (data) => data.count,
+    0
+  );
+  const { execute: listQueues, loading: queuesLoading, error: queuesError } = useApiAsync2(
+    () => listQueuesApi(optionsRef.current),
+    (data) => data.queues,
+    []
+  );
+  const loading = activeLoading || activeCountLoading || waitingCountLoading || queuesLoading;
+  const error = activeError || activeCountError || waitingCountError || queuesError;
+  return useMemo2(
+    () => ({
+      loading,
+      error,
+      getActiveChats,
+      getActiveChatsCount,
+      getWaitingChatsCount,
+      listQueues
+    }),
+    [loading, error, getActiveChats, getActiveChatsCount, getWaitingChatsCount, listQueues]
+  );
+}
+
+// hooks/use-human-agent-sessions.ts
+import { useMemo as useMemo3 } from "react";
+import { useApiAsync as useApiAsync3 } from "@elqnt/api-client/hooks";
+function useHumanAgentSessions(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: getOnlineSessions, loading: onlineLoading, error: onlineError } = useApiAsync3(
+    () => getOnlineSessionsApi(optionsRef.current),
+    (data) => data.sessions,
+    []
+  );
+  const { execute: getAgentSession, loading: sessionLoading, error: sessionError } = useApiAsync3(
+    (agentId) => getAgentSessionApi(agentId, optionsRef.current),
+    (data) => data.session || null,
+    null
+  );
+  const loading = onlineLoading || sessionLoading;
+  const error = onlineError || sessionError;
+  return useMemo3(
+    () => ({
+      loading,
+      error,
+      getOnlineSessions,
+      getAgentSession
+    }),
+    [loading, error, getOnlineSessions, getAgentSession]
+  );
+}
+
+// hooks/index.ts
+import { useApiAsync as useApiAsync4 } from "@elqnt/api-client/hooks";
 export {
-  useChat
+  useApiAsync4 as useApiAsync,
+  useChat,
+  useChatHistory,
+  useChatMonitoring,
+  useHumanAgentSessions,
+  useOptionsRef
 };
 //# sourceMappingURL=index.mjs.map