@aslaluroba/help-center-react 3.0.21 → 3.2.1

package/src/core/api.ts

@@ -1,39 +1,30 @@
-import { TokenResponse } from "../lib/types";
+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 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>,
-) {
+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.",
-    );
+    throw new Error('API module not initialized. Call initializeAPI(getToken) first.');
   }
 
-  let storedToken = localStorage.getItem("chatbot-token");
-  let storedExpiry = localStorage.getItem("chatbot-token-expiry");
+  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;
+  const isTokenExpiring = storedExpiry && currentTime >= Number(storedExpiry) - bufferTime;
 
   if (!storedToken || !storedExpiry || isTokenExpiring || forceRefresh) {
     try {
@@ -41,10 +32,9 @@ export async function getValidToken(forceRefresh = false): Promise<string> {
       storedToken = tokenResponse.token;
       storedExpiry = String(currentTime + (tokenResponse.expiresIn ?? 900));
 
-      localStorage.setItem("chatbot-token", storedToken);
-      localStorage.setItem("chatbot-token-expiry", storedExpiry);
+      localStorage.setItem('chatbot-token', storedToken);
+      localStorage.setItem('chatbot-token-expiry', storedExpiry);
     } catch (error) {
-      console.error("Failed to refresh token:", error);
       throw error;
     }
   }
@@ -53,21 +43,17 @@ export async function getValidToken(forceRefresh = false): Promise<string> {
 }
 
 // Optimized fetch with retry logic and connection pooling
-async function fetchWithAuth(
-  url: string,
-  options: RequestInit,
-  retry = true,
-): Promise<Response> {
+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}`);
+    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");
+    headers.set('Accept', 'application/json');
+    headers.set('Accept-Encoding', 'gzip, deflate, br');
+    headers.set('Connection', 'keep-alive');
 
     options.headers = headers;
 
@@ -80,17 +66,16 @@ async function fetchWithAuth(
         ...options,
         signal: controller.signal,
         // Add HTTP/2 optimization hints
-        cache: "no-cache",
-        mode: "cors",
+        cache: 'no-cache',
+        mode: 'cors',
       });
 
       clearTimeout(timeoutId);
 
       // Handle 401/403 with token refresh
       if ((response.status === 401 || response.status === 403) && retry) {
-        console.warn("Token expired, refreshing...");
         const newToken = await getValidToken(true);
-        headers.set("Authorization", `Bearer ${newToken}`);
+        headers.set('Authorization', `Bearer ${newToken}`);
         options.headers = headers;
 
         // Retry the request with new token
@@ -101,13 +86,12 @@ async function fetchWithAuth(
     } catch (error) {
       clearTimeout(timeoutId);
 
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error("Request timeout - please try again");
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Request timeout - please try again');
       }
       throw error;
     }
   } catch (error) {
-    console.error("Fetch error:", error);
     throw error;
   }
 }
@@ -126,11 +110,7 @@ function getCachedResponse(cacheKey: string): any | null {
   return null;
 }
 
-function setCachedResponse(
-  cacheKey: string,
-  data: any,
-  ttl: number = CACHE_TTL,
-): void {
+function setCachedResponse(cacheKey: string, data: any, ttl: number = CACHE_TTL): void {
   requestCache.set(cacheKey, {
     data,
     timestamp: Date.now(),
@@ -154,11 +134,11 @@ function setPendingRequest(requestKey: string, promise: Promise<any>): void {
 
 export async function apiRequest(
   endpoint: string,
-  method = "GET",
+  method = 'GET',
   body: any = null,
-  options: { cache?: boolean; timeout?: number; language: string },
+  options: { cache?: boolean; timeout?: number; language: string }
 ) {
-  if (!baseUrl) throw new Error("API not initialized");
+  if (!baseUrl) throw new Error('API not initialized');
 
   const url = `${baseUrl}/${endpoint}`;
   const requestKey = `${method}:${endpoint}:${JSON.stringify(body)}`;
@@ -170,11 +150,7 @@ export async function apiRequest(
   }
 
   // Check cache for GET requests (except real-time endpoints)
-  if (
-    method === "GET" &&
-    options.cache !== false &&
-    !endpoint.includes("/send-message")
-  ) {
+  if (method === 'GET' && options.cache !== false && !endpoint.includes('/send-message')) {
     const cached = getCachedResponse(requestKey);
     if (cached) {
       return Promise.resolve(cached);
@@ -184,9 +160,9 @@ export async function apiRequest(
   const requestOptions: RequestInit = {
     method,
     headers: {
-      "Content-Type": "application/json",
-      "Cache-Control": method === "GET" ? "max-age=30" : "no-cache",
-      "Accept-Language": options.language,
+      'Content-Type': 'application/json',
+      'Cache-Control': method === 'GET' ? 'max-age=30' : 'no-cache',
+      'Accept-Language': options.language,
     },
     body: body ? JSON.stringify(body) : null,
   };
@@ -196,28 +172,39 @@ export async function apiRequest(
       const response = await fetchWithAuth(url, requestOptions);
 
       if (!response.ok) {
-        let errorMessage = "API request failed";
+        let errorMessage = 'API request failed';
 
         try {
-          const errorData = await response.json();
-          errorMessage = errorData.message || errorMessage;
-        } catch {
-          errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+          // 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
-      if (method === "GET" && options.cache !== false) {
+      // 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) {
-      console.error(`API request failed for ${endpoint}:`, error);
       throw error;
     }
   })();
@@ -227,3 +214,64 @@ export async function apiRequest(
 
   return requestPromise;
 }
+
+export async function presignUpload(
+  chatSessionId: string,
+  file: File,
+  language: string
+): 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: string): 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/lib/types.ts

@@ -1,128 +1,154 @@
 export interface HelpCenterProps extends React.HTMLAttributes<HTMLDivElement> {
-  helpScreenId: string
-  primaryColor?: string
-  secondaryColor?: string
-  logoUrl?: string
+  helpScreenId: string;
+  primaryColor?: string;
+  secondaryColor?: string;
+  logoUrl?: string;
 }
 
 export interface Theme {
-  primary: string
-  secondary: string
-  text: string
-  background: string
-  error: string
-  success: string
+  primary: string;
+  secondary: string;
+  text: string;
+  background: string;
+  error: string;
+  success: string;
 }
 
 export interface UserData {
-  id: string
-  name: string
-  email: string
-  avatar?: string
+  id: string;
+  name: string;
+  email: string;
+  avatar?: string;
 }
 
 export interface Message {
-  id: number
-  senderType: number // 1: Customer, 2: Agent, 3: AI
-  messageContent: string
-  sentAt: Date
-  isSeen: boolean
+  id: number;
+  senderType: number; // 1: Customer, 2: Agent, 3: AI
+  messageContent: string;
+  sentAt: Date;
+  isSeen: boolean;
+  attachmentIds?: string[];
 }
 
 export interface ChatSession {
-  id: string
-  messages: Message[]
-  participants: UserData[]
-  status: 'active' | 'closed'
-  createdAt: Date
-  updatedAt: Date
+  id: string;
+  messages: Message[];
+  participants: UserData[];
+  status: 'active' | 'closed';
+  createdAt: Date;
+  updatedAt: Date;
 }
 
 export interface ChatSessionData {
-  helpScreenId: string
-  user: UserData
-  initialMessage?: string
+  helpScreenId: string;
+  user: UserData;
+  initialMessage?: string;
 }
 
 export interface HelpCenterConfig {
-  baseUrl: string
-  getToken: () => Promise<{ token: string; expiresIn: number }>
-  helpScreenId: string
-  user?: UserData
-  theme?: Partial<Theme>
-  onMessageReceived?: (message: Message) => void
-  onSessionClosed?: () => void
-  onError?: (error: Error) => void
+  baseUrl: string;
+  getToken: () => Promise<{ token: string; expiresIn: number }>;
+  helpScreenId: string;
+  user?: UserData;
+  theme?: Partial<Theme>;
+  onMessageReceived?: (message: Message) => void;
+  onSessionClosed?: () => void;
+  onError?: (error: Error) => void;
 }
 
 export interface HelpScreenOption {
-  id: string
-  title: string
-  paragraphs?: string[]
-  nestedOptions?: HelpScreenOption[]
-  chatWithUs?: boolean
+  id: string;
+  title: string;
+  paragraphs?: string[];
+  nestedOptions?: HelpScreenOption[];
+  chatWithUs?: boolean;
 }
 
 export interface HelpScreen {
-  id: string
-  title: string
-  options: HelpScreenOption[]
+  id: string;
+  title: string;
+  options: HelpScreenOption[];
 }
 
 export interface ApiResponse<T> {
-  data: T
-  success: boolean
-  error?: string
+  data: T;
+  success: boolean;
+  error?: string;
 }
 
 export interface TokenResponse {
-  token: string
-  expiresIn: number
+  token: string;
+  expiresIn: number;
 }
 
 export interface HelpScreenData {
-  id: string
-  tenantId: string
+  id: string;
+  tenantId: string;
   tenant: {
-    id: string
-    name: string
-    key: string
-  }
-  title: string
-  description: string
-  options: Option[]
-  chatWithUs: boolean
+    id: string;
+    name: string;
+    key: string;
+  };
+  title: string;
+  description: string;
+  options: Option[];
+  chatWithUs: boolean;
 }
 
 export interface Option {
-  id: string
-  helpScreenId: string
-  parentOptionId: string | null
-  parentOption: Option | null
-  files: any[]
-  nestedOptions: Option[]
-  title: string
-  paragraphs: string[]
-  chatWithUs: boolean
-  assistantId?: string
+  id: string;
+  helpScreenId: string;
+  parentOptionId: string | null;
+  parentOption: Option | null;
+  files: any[];
+  nestedOptions: Option[];
+  title: string;
+  paragraphs: string[];
+  chatWithUs: boolean;
+  assistantId?: string;
   assistant?: {
-    id: string
-    tenantId: string
+    id: string;
+    tenantId: string;
     tenant: {
-      id: string
-      name: string
-      key: string
-    }
-    name: string
-    openAIAssistantId: string
-    greeting: string
-    closing: string
-  }
-  hasNestedOptions: boolean
-  order: number
+      id: string;
+      name: string;
+      key: string;
+    };
+    name: string;
+    openAIAssistantId: string;
+    greeting: string;
+    closing: string;
+  };
+  hasNestedOptions: boolean;
+  order: number;
 }
 
 export interface ReviewProps {
-  comment: string
-  rating: number
+  comment: string;
+  rating: number;
+}
+
+export interface PresignUploadRequestDto {
+  name: string;
+  contentType: string;
+  sizeBytes: number;
+  pathData: {
+    type: number;
+    chatSessionId: string;
+  };
+}
+
+export interface PresignUploadResponse {
+  id: string;
+  uploadUrl: string;
+  path: string;
+  expiresAt: string;
+}
+
+export interface PresignDownloadResponse {
+  id: string;
+  name: string;
+  downloadUrl: string;
+  contentType: string;
+  expiresAt: string;
 }