@aslaluroba/help-center-react 3.2.16 → 3.2.18

package/src/core/AblyService.ts

@@ -1,243 +0,0 @@
-import * as Ably from 'ably';
-
-type ActionHandlerCallback = (actionType: string | undefined | null, messageData: any) => void | Promise<void>;
-
-export class ClientAblyService {
-  private static client: Ably.Realtime | null = null;
-  private static channel: Ably.RealtimeChannel | null = null;
-  private static isConnected: boolean = false;
-  private static sessionId: string | null = null;
-  private static messageUnsubscribe: (() => void) | null = null;
-  private static onActionReceived: ActionHandlerCallback | null = null;
-
-  static async startConnection(
-    sessionId: string,
-    ablyToken: string,
-    onMessageReceived: Function,
-    tenantId: string,
-    onActionReceived?: ActionHandlerCallback
-  ) {
-    // Prevent multiple connections
-    if (this.isConnected && this.sessionId === sessionId) {
-      return;
-    }
-
-    // Close existing connection if connecting to a different session
-    if (this.isConnected && this.sessionId !== sessionId) {
-      await this.stopConnection();
-    }
-
-    try {
-      // Initialize Ably client with the token
-      this.client = new Ably.Realtime({
-        authUrl: undefined,
-        token: ablyToken,
-        autoConnect: true,
-      });
-
-      this.client.connection.on('failed', (stateChange) => {
-        console.error('[AblyService] Connection state: failed', {
-          reason: stateChange.reason?.message,
-          error: stateChange.reason,
-        });
-      });
-
-      // Wait for connection to be established
-      await new Promise<void>((resolve, reject) => {
-        if (!this.client) {
-          const error = new Error('Failed to initialize Ably client');
-          console.error('[AblyService]', error);
-          reject(error);
-          return;
-        }
-
-        this.client.connection.once('connected', () => {
-          this.isConnected = true;
-          this.sessionId = sessionId;
-          resolve();
-        });
-
-        this.client.connection.once('failed', (stateChange) => {
-          const error = new Error(`Ably connection failed: ${stateChange.reason?.message || 'Unknown error'}`);
-          console.error('[AblyService] Connection failed', {
-            reason: stateChange.reason?.message,
-            error: stateChange.reason,
-          });
-          reject(error);
-        });
-
-        this.client.connection.once('disconnected', (stateChange) => {
-          const error = new Error(`Ably connection disconnected: ${stateChange.reason?.message || 'Unknown error'}`);
-          console.error('[AblyService] Connection disconnected', { reason: stateChange.reason?.message });
-          reject(error);
-        });
-
-        // Set a timeout for connection
-        setTimeout(() => {
-          if (!this.isConnected) {
-            const error = new Error('Ably connection timeout');
-            console.error('[AblyService] Connection timeout after 10 seconds');
-            reject(error);
-          }
-        }, 10000);
-      });
-
-      // Store optional action handler for this connection
-      this.onActionReceived = onActionReceived ?? null;
-
-      // Subscribe to the session room
-      await this.joinChannel(sessionId, onMessageReceived, tenantId);
-    } catch (error) {
-      console.error('[AblyService] Error in startConnection', { error, sessionId });
-      this.isConnected = false;
-      this.sessionId = null;
-      throw error;
-    }
-  }
-
-  private static async joinChannel(sessionId: string, onMessageReceived: Function, tenantId: string) {
-    if (!this.client) {
-      const error = new Error('Chat client not initialized');
-      console.error('[AblyService] joinChannel error:', error);
-      throw error;
-    }
-
-    const roomName = `session:${tenantId}:${sessionId}`;
-
-    // Set up raw channel subscription for server messages
-    if (this.client) {
-      this.channel = this.client.channels.get(roomName);
-
-      this.channel.on('failed', (stateChange) => {
-        console.error('[AblyService] Channel failed', {
-          roomName,
-          reason: stateChange.reason?.message,
-          error: stateChange.reason,
-        });
-      });
-
-      // Subscribe to assistant/system responses
-      this.channel.subscribe('ReceiveMessage', (message) => {
-        try {
-          // Ensure messageContent is always a string (default to empty string if undefined)
-          const rawData = message.data;
-
-          const messageContent =
-            typeof rawData === 'string' ? rawData : rawData?.content ?? rawData?.message ?? '';
-          const senderType = rawData?.senderType || 3; // Assistant
-          const needsAgent = rawData?.needsAgent || rawData?.actionType == 'needs_agent' || false;
-          const attachments = rawData?.attachments || [];
-          const actionType = (rawData && typeof rawData.actionType === 'string' ? rawData.actionType : '') as
-            | string
-            | undefined
-            | null;
-
-          // Extract downloadUrl from attachments (Ably now returns downloadUrl directly)
-          // Attachments can be: strings (URLs), objects with downloadUrl, url, or id only
-          const attachmentUrls: string[] = [];
-          const attachmentIdsFromAttachments: string[] = [];
-          for (const attachment of attachments) {
-            if (typeof attachment === 'string') {
-              if (attachment.startsWith('http://') || attachment.startsWith('https://')) {
-                attachmentUrls.push(attachment);
-              } else {
-                attachmentIdsFromAttachments.push(attachment);
-              }
-            } else if (attachment?.downloadUrl) {
-              attachmentUrls.push(attachment.downloadUrl);
-            } else if (attachment?.url) {
-              attachmentUrls.push(attachment.url);
-            } else if (attachment?.id && typeof attachment.id === 'string') {
-              attachmentIdsFromAttachments.push(attachment.id);
-            }
-          }
-          const attachmentIds =
-            attachmentIdsFromAttachments.length > 0
-              ? attachmentIdsFromAttachments
-              : (rawData?.attachmentIds as string[] | undefined) || [];
-
-          // Invoke optional action handler first (non-blocking for message processing)
-          if (this.onActionReceived && actionType !== undefined) {
-            try {
-              void this.onActionReceived(actionType, rawData);
-            } catch (actionError) {
-              console.error('[AblyService] Error in action handler callback', {
-                error: actionError,
-                actionType,
-                rawData,
-              });
-            }
-          }
-
-          onMessageReceived(messageContent, senderType, needsAgent, attachmentUrls, attachmentIds);
-        } catch (error) {
-          console.error('[AblyService] Error processing message', { error, message });
-        }
-      });
-
-      await this.channel.attach();
-    }
-  }
-
-  static async stopConnection() {
-    try {
-      // Unsubscribe from room messages
-      if (this.messageUnsubscribe) {
-        this.messageUnsubscribe();
-        this.messageUnsubscribe = null;
-      }
-
-      // Unsubscribe and detach from raw channel
-      if (this.channel) {
-        this.channel.unsubscribe();
-        await this.channel.detach();
-        this.channel = null;
-      }
-
-      // Close Ably connection
-      if (this.client) {
-        this.client.close();
-        this.client = null;
-      }
-
-      this.isConnected = false;
-      this.sessionId = null;
-      this.onActionReceived = null;
-    } catch (error) {
-      console.error('[AblyService] Error in stopConnection', { error });
-      // Reset state even if there's an error
-      this.isConnected = false;
-      this.sessionId = null;
-      this.client = null;
-      this.channel = null;
-      this.messageUnsubscribe = null;
-    }
-  }
-
-  static isConnectionActive(): boolean {
-    return this.isConnected && this.client?.connection.state === 'connected';
-  }
-
-  static getConnectionState(): string {
-    return this.client?.connection.state || 'disconnected';
-  }
-
-  // Method to manually send a message (if needed for debugging or direct messaging)
-  static async sendMessage(messageContent: string, senderType: number = 1) {
-    if (!this.channel || !this.isConnected) {
-      throw new Error('Connection not active');
-    }
-
-    try {
-      await this.channel.publish('message', {
-        text: messageContent,
-        metadata: {
-          senderType,
-          sentAt: new Date().toISOString(),
-        },
-      });
-    } catch (error) {
-      throw error;
-    }
-  }
-}

package/src/core/ApiService.ts

@@ -1,116 +0,0 @@
-import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
-import { HelpCenterConfig } from '../lib/types';
-
-export class ApiService {
-  private axiosInstance: AxiosInstance;
-  private config: HelpCenterConfig;
-  private tokenExpiryTime: number = 0;
-  private currentToken: string | null = null;
-
-  constructor(config: HelpCenterConfig) {
-    this.config = config;
-    this.axiosInstance = axios.create({
-      baseURL: config.baseUrl,
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    });
-
-    this.setupInterceptors();
-  }
-
-  private setupInterceptors() {
-    this.axiosInstance.interceptors.request.use(
-      async (config) => {
-        const token = await this.getValidToken();
-        if (token && config.headers) {
-          config.headers.Authorization = `Bearer ${token}`;
-        }
-        return config;
-      },
-      (error) => Promise.reject(error)
-    );
-
-    this.axiosInstance.interceptors.response.use(
-      (response) => response,
-      async (error) => {
-        if (error.response?.status === 401) {
-          // Token might be expired, try to refresh
-          const token = await this.getValidToken(true);
-          if (token && error.config) {
-            error.config.headers.Authorization = `Bearer ${token}`;
-            return this.axiosInstance.request(error.config);
-          }
-        }
-        return Promise.reject(error);
-      }
-    );
-  }
-
-  private async getValidToken(forceRefresh = false): Promise<string> {
-    const currentTime = Math.floor(Date.now() / 1000);
-
-    if (forceRefresh || !this.currentToken || currentTime >= this.tokenExpiryTime) {
-      try {
-        const response = await this.config.getToken();
-        if (!response || !response.token || !response.expiresIn) {
-          throw new Error('Invalid token response');
-        }
-
-        this.currentToken = response.token;
-        this.tokenExpiryTime = currentTime + response.expiresIn;
-        return this.currentToken;
-      } catch (error) {
-        throw error;
-      }
-    }
-
-    return this.currentToken;
-  }
-
-  async get<T>(endpoint: string, config?: AxiosRequestConfig): Promise<T> {
-    try {
-      const response = await this.axiosInstance.get<T>(endpoint, config);
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-
-  async post<T>(endpoint: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    try {
-      const response = await this.axiosInstance.post<T>(endpoint, data, config);
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-
-  async put<T>(endpoint: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    try {
-      const response = await this.axiosInstance.put<T>(endpoint, data, config);
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-
-  async delete<T>(endpoint: string, config?: AxiosRequestConfig): Promise<T> {
-    try {
-      const response = await this.axiosInstance.delete<T>(endpoint, config);
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-
-  private handleError(error: unknown) {
-    if (this.config.onError) {
-      this.config.onError(error instanceof Error ? error : new Error('Unknown error occurred'));
-    }
-  }
-}

package/src/core/api.ts

@@ -1,278 +0,0 @@
-import { defaultLanguage } from '@/i18n';
-import { TokenResponse, PresignUploadRequestDto, PresignUploadResponse, PresignDownloadResponse } from '@/lib/types';
-
-let getTokenFunction: (() => Promise<TokenResponse>) | undefined = undefined;
-let baseUrl: string | null = null;
-
-// Add request cache and connection optimization
-const requestCache = new Map<string, { data: any; timestamp: number; ttl: number }>();
-const CACHE_TTL = 30000; // 30 seconds cache for non-critical requests
-const pendingRequests = new Map<string, Promise<any>>();
-
-export function initializeAPI(url: string, getToken: () => Promise<TokenResponse>) {
-  getTokenFunction = getToken;
-  baseUrl = url;
-}
-
-export async function getValidToken(forceRefresh = false): Promise<string> {
-  if (!getTokenFunction) {
-    throw new Error('API module not initialized. Call initializeAPI(getToken) first.');
-  }
-
-  let storedToken = localStorage.getItem('chatbot-token');
-  let storedExpiry = localStorage.getItem('chatbot-token-expiry');
-  const currentTime = Math.floor(Date.now() / 1000);
-
-  // Add buffer time to prevent token expiry during request
-  const bufferTime = 60; // 1 minute buffer
-  const isTokenExpiring = storedExpiry && currentTime >= Number(storedExpiry) - bufferTime;
-
-  if (!storedToken || !storedExpiry || isTokenExpiring || forceRefresh) {
-    try {
-      const tokenResponse = await getTokenFunction();
-      storedToken = tokenResponse.token;
-      storedExpiry = String(currentTime + (tokenResponse.expiresIn ?? 900));
-
-      localStorage.setItem('chatbot-token', storedToken);
-      localStorage.setItem('chatbot-token-expiry', storedExpiry);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  return storedToken;
-}
-
-// Optimized fetch with retry logic and connection pooling
-async function fetchWithAuth(url: string, options: RequestInit, retry = true): Promise<Response> {
-  const headers = new Headers(options.headers);
-
-  try {
-    const token = await getValidToken();
-    headers.set('Authorization', `Bearer ${token}`);
-
-    // Add performance optimizations
-    headers.set('Accept', 'application/json');
-    headers.set('Accept-Encoding', 'gzip, deflate, br');
-    headers.set('Connection', 'keep-alive');
-
-    options.headers = headers;
-
-    // Add timeout to prevent hanging requests
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
-
-    try {
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal,
-        // Add HTTP/2 optimization hints
-        cache: 'no-cache',
-        mode: 'cors',
-      });
-
-      clearTimeout(timeoutId);
-
-      // Handle 401/403 with token refresh
-      if ((response.status === 401 || response.status === 403) && retry) {
-        const newToken = await getValidToken(true);
-        headers.set('Authorization', `Bearer ${newToken}`);
-        options.headers = headers;
-
-        // Retry the request with new token
-        return fetchWithAuth(url, options, false);
-      }
-
-      return response;
-    } catch (error) {
-      clearTimeout(timeoutId);
-
-      if (error instanceof Error && error.name === 'AbortError') {
-        throw new Error('Request timeout - please try again');
-      }
-      throw error;
-    }
-  } catch (error) {
-    throw error;
-  }
-}
-
-// Cache management functions
-function getCachedResponse(cacheKey: string): any | null {
-  const cached = requestCache.get(cacheKey);
-  if (cached && Date.now() < cached.timestamp + cached.ttl) {
-    return cached.data;
-  }
-
-  if (cached) {
-    requestCache.delete(cacheKey);
-  }
-
-  return null;
-}
-
-function setCachedResponse(cacheKey: string, data: any, ttl: number = CACHE_TTL): void {
-  requestCache.set(cacheKey, {
-    data,
-    timestamp: Date.now(),
-    ttl,
-  });
-}
-
-// Deduplicate concurrent requests
-function getDuplicateRequest(requestKey: string): Promise<any> | null {
-  return pendingRequests.get(requestKey) || null;
-}
-
-function setPendingRequest(requestKey: string, promise: Promise<any>): void {
-  pendingRequests.set(requestKey, promise);
-
-  // Clean up after request completes
-  promise.finally(() => {
-    pendingRequests.delete(requestKey);
-  });
-}
-
-export async function apiRequest(
-  endpoint: string,
-  method = 'GET',
-  body: any = null,
-  options: { cache?: boolean; timeout?: number; language?: 'ar' | 'en' }
-) {
-  if (!baseUrl) throw new Error('API not initialized');
-
-  const url = `${baseUrl}/${endpoint}`;
-  const requestKey = `${method}:${endpoint}:${JSON.stringify(body)}`;
-
-  // Check for duplicate in-flight requests (skip for GET: callers receive Response and call .json();
-  // sharing the same Response causes "body already consumed" when the second caller parses)
-  const duplicateRequest = getDuplicateRequest(requestKey);
-  if (duplicateRequest && method !== 'GET') {
-    return duplicateRequest;
-  }
-
-  // Check cache for GET requests (except real-time endpoints)
-  if (method === 'GET' && options.cache !== false && !endpoint.includes('/send-message')) {
-    const cached = getCachedResponse(requestKey);
-    if (cached) {
-      return Promise.resolve(cached);
-    }
-  }
-
-  const requestOptions: RequestInit = {
-    method,
-    headers: {
-      'Content-Type': 'application/json',
-      'Cache-Control': method === 'GET' ? 'max-age=30' : 'no-cache',
-      'Accept-Language': options.language || defaultLanguage,
-    },
-    body: body ? JSON.stringify(body) : null,
-  };
-
-  const requestPromise = (async () => {
-    try {
-      const response = await fetchWithAuth(url, requestOptions);
-
-      if (!response.ok) {
-        let errorMessage = 'API request failed';
-
-        try {
-          // Clone response before reading to avoid consuming the body
-          const errorResponse = response.clone();
-          const errorData = await errorResponse.json();
-          errorMessage = errorData.message || errorData.error || errorMessage;
-        } catch (parseError) {
-          // If JSON parsing fails, try to get text
-          try {
-            const errorResponse = response.clone();
-            const errorText = await errorResponse.text();
-            errorMessage = errorText || `HTTP ${response.status}: ${response.statusText}`;
-          } catch {
-            errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-          }
-        }
-
-        throw new Error(errorMessage);
-      }
-
-      // Cache successful GET responses
-      // Note: We clone before caching to avoid consuming the original response body
-      if (method === 'GET' && options.cache !== false) {
-        const responseData = response.clone();
-        const data = await responseData.json();
-        setCachedResponse(requestKey, { json: () => Promise.resolve(data) });
-      }
-
-      // Return the original response - it's body hasn't been consumed yet
-      // (we only cloned for caching, and the clone was consumed)
-      return response;
-    } catch (error) {
-      throw error;
-    }
-  })();
-
-  // Track pending request
-  setPendingRequest(requestKey, requestPromise);
-
-  return requestPromise;
-}
-
-export async function presignUpload(
-  chatSessionId: string,
-  file: File,
-  language: 'ar' | 'en' = defaultLanguage
-): Promise<PresignUploadResponse> {
-  const requestBody: PresignUploadRequestDto = {
-    name: file.name,
-    contentType: file.type,
-    sizeBytes: file.size,
-    pathData: {
-      type: 1,
-      chatSessionId: chatSessionId,
-    },
-  };
-
-  const response = await apiRequest('NewFile/presign-upload', 'POST', requestBody, { language });
-
-  if (!response.ok) {
-    throw new Error('Failed to get presigned upload URL');
-  }
-
-  return await response.json();
-}
-export async function presignDownload(fileId: string, language: 'ar' | 'en' = defaultLanguage): Promise<PresignDownloadResponse> {
-  try {
-    const response = await apiRequest(`NewFile/${fileId}/presign-download`, 'GET', null, {
-      language,
-      cache: false, // Don't cache presigned URLs as they have expiration times
-    });
-
-    // If response is not ok, apiRequest would have thrown an error already
-    // So we can safely read the JSON here
-    try {
-      return await response.json();
-    } catch (jsonError) {
-      // If JSON parsing fails, the response body might have been consumed
-      // or the response might not be valid JSON
-      if (jsonError instanceof Error) {
-        if (jsonError.message.includes('already read')) {
-          throw new Error(`Failed to parse response for file ${fileId}: Response body was already consumed`);
-        }
-        throw new Error(`Failed to parse response for file ${fileId}: ${jsonError.message}`);
-      }
-      throw new Error(`Failed to parse response for file ${fileId}`);
-    }
-  } catch (error) {
-    // Handle all types of errors
-    if (error instanceof Error) {
-      // If it's already a descriptive error from apiRequest, re-throw it
-      if (error.message.includes('API request failed') || error.message.includes('HTTP')) {
-        throw new Error(`Failed to get presigned download URL for file ${fileId}: ${error.message}`);
-      }
-      // Otherwise, re-throw with context
-      throw error;
-    }
-    // Handle non-Error types
-    throw new Error(`Failed to get presigned download URL for file ${fileId}: ${String(error)}`);
-  }
-}

package/src/core/token-service.ts

@@ -1,35 +0,0 @@
-type TokenResponse = {
-  token: string
-  expiresIn: number
-}
-
-export class TokenService {
-  private baseUrl: string
-
-  constructor(baseUrl: string) {
-    this.baseUrl = baseUrl
-  }
-
-  async getToken(): Promise<TokenResponse> {
-    try {
-      const response = await fetch(`${this.baseUrl}/Auth/client/get-babylai-token`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        }
-      })
-
-      if (!response.ok) {
-        throw new Error('Failed to fetch token')
-      }
-
-      const data = await response.json()
-      return {
-        token: data.token,
-        expiresIn: data.expiresIn || 3600 // Default to 1 hour if not provided
-      }
-    } catch (error) {
-      throw new Error('Failed to get authentication token')
-    }
-  }
-}