humanbehavior-js 0.0.5 → 0.0.8

package/src/api.ts

@@ -0,0 +1,360 @@
+export const MAX_CHUNK_SIZE_BYTES = 1024 * 1024 * 10; // 10MB chunk size
+
+export function isChunkSizeExceeded(currentChunk: any[], newEvent: any, sessionId: string): boolean {
+    const nextChunkSize = new TextEncoder().encode(JSON.stringify({
+        sessionId,
+        events: [...currentChunk, newEvent]
+    })).length;
+    
+    return nextChunkSize > MAX_CHUNK_SIZE_BYTES;
+}
+
+export function validateSingleEventSize(event: any, sessionId: string): void {
+    const singleEventSize = new TextEncoder().encode(JSON.stringify({
+        sessionId,
+        events: [event]
+    })).length;
+
+    if (singleEventSize > MAX_CHUNK_SIZE_BYTES) {
+        throw new Error(`Single event size (${singleEventSize} bytes) exceeds maximum chunk size (${MAX_CHUNK_SIZE_BYTES} bytes)`);
+    }
+}
+
+export class HumanBehaviorAPI {
+    private apiKey: string;
+    private baseUrl: string;
+
+    constructor({ apiKey, ingestionUrl }: { apiKey: string, ingestionUrl: string }) {
+        this.apiKey = apiKey;
+        this.baseUrl = ingestionUrl;
+    }
+
+    public async init(sessionId: string, userId: string | null) {
+        // Get current page URL and referrer if in browser environment
+        let entryURL = null;
+        let referrer = null;
+        
+        if (typeof window !== 'undefined') {
+            entryURL = window.location.href;
+            referrer = document.referrer;
+        }
+
+        const response = await fetch(`${this.baseUrl}/api/ingestion/init`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Referer': referrer || ''
+            },
+            body: JSON.stringify({
+                sessionId: sessionId,
+                endUserId: userId,
+                entryURL: entryURL,
+                referrer: referrer
+            })
+        });
+
+        if (!response.ok) {
+            throw new Error(`Failed to initialize ingestion: ${response.statusText}`);
+        } 
+
+        const responseJson = await response.json();
+        return {
+            sessionId: responseJson.sessionId,
+            endUserId: responseJson.endUserId
+        }
+    }
+
+    async sendEvents(events: any[], sessionId: string, userId: string) {
+        const response = await fetch(`${this.baseUrl}/api/ingestion/events`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                sessionId,
+                events: events,
+                endUserId: userId
+            })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`Failed to send events: ${response.statusText}`);
+        }
+    }
+    
+    async sendEventsChunked(events: any[], sessionId: string) {
+        try {
+            const results = [];
+            let currentChunk: any[] = [];
+            
+            for (const event of events) {
+                if (isChunkSizeExceeded(currentChunk, event, sessionId)) {
+                    // If current chunk is not empty, send it first
+                    if (currentChunk.length > 0) {
+                        const response = await fetch(`${this.baseUrl}/api/ingestion/events`, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'Authorization': `Bearer ${this.apiKey}`
+                            },
+                            body: JSON.stringify({
+                                sessionId,
+                                events: currentChunk
+                            })
+                        });
+                        
+                        if (!response.ok) {
+                            throw new Error(`Failed to send events: ${response.statusText}`);
+                        }
+                        
+                        results.push(await response.json());
+                        currentChunk = [];
+                    }
+
+                    // Validate single event size
+                    validateSingleEventSize(event, sessionId);
+                    
+                    // Start new chunk with this event
+                    currentChunk = [event];
+                } else {
+                    // Add event to current chunk
+                    currentChunk.push(event);
+                }
+            }
+            
+            // Send any remaining events
+            if (currentChunk.length > 0) {
+                const response = await fetch(`${this.baseUrl}/api/ingestion/events`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        sessionId,
+                        events: currentChunk
+                    })
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`Failed to send events: ${response.statusText}`);
+                }
+                
+                results.push(await response.json());
+            }
+            
+            return results.flat();
+        } catch (error) {
+            console.error('Error sending events:', error);
+            throw error;
+        }
+    }
+
+    async sendUserData(userId: string, userData: Record<string, any>, sessionId: string) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/ingestion/user`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    userId: userId,
+                    userAttributes: userData,
+                    sessionId: sessionId
+                })
+            });
+            
+            if (!response.ok) {
+                throw new Error(`Failed to send user data: ${response.statusText} with API key: ${this.apiKey}`);
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('Error sending user data:', error);
+            throw error;
+        }
+    }
+
+    async sendUserAuth(userId: string, userData: Record<string, any>, sessionId: string, authFields: string[]) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/ingestion/user/auth`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    userId: userId,
+                    userAttributes: userData,
+                    sessionId: sessionId,
+                    authFields: authFields
+                })
+            });
+            
+            if (!response.ok) {
+                throw new Error(`Failed to authenticate user: ${response.statusText} with API key: ${this.apiKey}`);
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('Error authenticating user:', error);
+            throw error;
+        }
+    }
+
+    async sendSessionComplete(sessionId: string) {
+        const response = await fetch(`${this.baseUrl}/api/ingestion/sessionComplete`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({ sessionId })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`Failed to send session complete: ${response.statusText}`);
+        }
+    }
+
+    async sendCustomEvent(eventName: string, eventProperties: Record<string, any>, sessionId: string) {
+        const maxRetries = 3;
+        let retryCount = 0;
+        
+        while (retryCount < maxRetries) {
+            try {
+                const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        name: eventName,
+                        properties: eventProperties,
+                        sessionId: sessionId,
+                        timestamp: new Date().toISOString()
+                    })
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`Failed to send custom event: ${response.statusText}`);
+                }
+                
+                return await response.json();
+            } catch (error) {
+                retryCount++;
+                if (retryCount === maxRetries) {
+                    console.error('Error sending custom event after max retries:', error);
+                    throw error;
+                }
+                // Exponential backoff
+                await new Promise(resolve => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
+            }
+        }
+    }
+
+    async sendCustomEvents(events: any[], sessionId: string) {
+        const maxRetries = 3;
+        let retryCount = 0;
+        
+        while (retryCount < maxRetries) {
+            try {
+                const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent/batch`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        events: events.map(event => ({
+                            ...event,
+                            sessionId: sessionId
+                        }))
+                    })
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`Failed to send custom events: ${response.statusText}`);
+                }
+                
+                return await response.json();
+            } catch (error) {
+                retryCount++;
+                if (retryCount === maxRetries) {
+                    console.error('Error sending custom events after max retries:', error);
+                    throw error;
+                }
+                // Exponential backoff
+                await new Promise(resolve => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
+            }
+        }
+    }
+
+    public sendBeaconEvents(events: any[], sessionId: string, isSessionComplete: boolean = false) {
+        const data = new URLSearchParams()
+        data.append('events', encodeURIComponent(JSON.stringify(events)))
+        data.append('sessionId', encodeURIComponent(sessionId))
+        data.append('timestamp', encodeURIComponent(Date.now().toString()))
+        data.append('apiKey', encodeURIComponent(this.apiKey))
+        if (isSessionComplete) {
+            console.log('Session complete beacon sending');
+            localStorage.setItem('koalaware_session_complete', Date.now().toString());
+            data.append('sessionComplete', encodeURIComponent('true'))
+        }
+
+        const success = navigator.sendBeacon(
+            `${this.baseUrl}/api/ingestion/events`, 
+            data
+        );
+
+        // KoalawareTracker.logToStorage(`Sending events beacon: ${this.baseUrl}/api/ingestion/events`);
+        // KoalawareTracker.logToStorage(`Events beacon success: ${success}`);
+    }
+
+    public sendBeaconSessionComplete(sessionId: string) {
+        const data = new URLSearchParams()
+        data.append('sessionId', sessionId)
+        data.append('apiKey', this.apiKey)
+        data.append('sessionComplete', 'true')
+        
+        const success = navigator.sendBeacon(
+            `${this.baseUrl}/api/ingestion/sessionComplete`, 
+            data
+        );
+
+        // KoalawareTracker.logToStorage(`Sending completion beacon: ${this.baseUrl}/api/ingestion/sessionComplete`);
+        // KoalawareTracker.logToStorage(`Complete beacon success: ${success}`);
+    }
+
+    public sendBeaconCustomEvent(eventName: string, eventProperties: Record<string, any>, sessionId: string) {
+        const data = new URLSearchParams()
+        data.append('name', encodeURIComponent(eventName))
+        data.append('properties', encodeURIComponent(JSON.stringify(eventProperties)))
+        data.append('sessionId', encodeURIComponent(sessionId))
+        data.append('timestamp', encodeURIComponent(new Date().toISOString()))
+        data.append('apiKey', encodeURIComponent(this.apiKey))
+
+        return navigator.sendBeacon(
+            `${this.baseUrl}/api/ingestion/customEvent`,
+            data
+        );
+    }
+
+    public sendBeaconCustomEvents(events: any[], sessionId: string) {
+        const data = new URLSearchParams()
+        data.append('events', encodeURIComponent(JSON.stringify(events.map(event => ({
+            ...event,
+            sessionId: sessionId
+        })))))
+        data.append('apiKey', encodeURIComponent(this.apiKey))
+
+        return navigator.sendBeacon(
+            `${this.baseUrl}/api/ingestion/customEvent/batch`,
+            data
+        );
+    }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Main entry point for the HumanBehavior SDK
+ */
+
+import { HumanBehaviorTracker } from './tracker';
+
+// Export everything from the tracker module
+export * from './tracker';
+
+// Export everything from the API module
+export * from './api';
+
+// Export redaction functionality
+export * from './redact';
+
+// Also export the tracker as the default export
+export { HumanBehaviorTracker as default } from './tracker';
+
+// For UMD builds, expose the main class globally
+if (typeof window !== 'undefined') {
+  (window as any).HumanBehaviorTracker = HumanBehaviorTracker;
+}

package/src/react/index.tsx

@@ -0,0 +1,189 @@
+import React, { useEffect, useState, createContext, useContext, ReactNode } from "react";
+import { HumanBehaviorTracker } from "..";
+
+// Check if we're in a browser environment
+const isBrowser = () => typeof window !== 'undefined';
+
+// Define the public interface that components will interact with
+interface HumanBehaviorInterface {
+  addEvent: (event: any) => void;
+  addUserInfo: (userProperties: Record<string, any>) => Promise<void>;
+  start: () => void;
+  stop: () => void;
+  viewLogs: () => void;
+}
+
+interface HumanBehaviorContextType {
+  humanBehavior: HumanBehaviorTracker | null;
+  queueEvent: (event: any) => void;
+}
+
+interface HumanBehaviorProviderProps {
+  // Either provide an apiKey to create a new client, or provide an existing client
+  apiKey?: string;
+  client?: HumanBehaviorTracker;
+  children: ReactNode;
+}
+
+const defaultContext: HumanBehaviorContextType = {
+  humanBehavior: null,
+  queueEvent: (event: any) => {
+    // In server-side, just no-op
+    if (typeof window === 'undefined') {
+      return;
+    }
+    console.warn('HumanBehavior not initialized yet, event queued:', event);
+  }
+};
+
+const HumanBehaviorContext = createContext<HumanBehaviorContextType>(defaultContext);
+
+export const HumanBehaviorProvider = ({ apiKey, client, children }: HumanBehaviorProviderProps) => {
+  const [humanBehavior, setHumanBehavior] = useState<HumanBehaviorTracker | null>(client || null);
+  const [eventQueue, setEventQueue] = useState<any[]>([]);
+  const [isMounted, setIsMounted] = useState(false);
+  const [isInitialized, setIsInitialized] = useState(false);
+
+  // Function to queue events before initialization
+  const queueEvent = (event: any) => {
+    setEventQueue(prev => [...prev, event]);
+  };
+
+  // Handle mounting state
+  useEffect(() => {
+    setIsMounted(true);
+  }, []);
+
+  useEffect(() => {
+    // Only run in browser
+    if (!(isBrowser())) {
+      return;
+    }
+
+    // Skip if not mounted yet (handles Next.js hydration)
+    if (!isMounted) {
+      return;
+    }
+
+    // If client is provided, use that
+    if (client) {
+      setHumanBehavior(client);
+      setIsInitialized(true);
+      return;
+    }
+
+    // If no client is provided, apiKey is required
+    if (!apiKey || apiKey.trim() === '') {
+      console.error("An apiKey is required when no client is provided");
+      return;
+    }
+
+    if (humanBehavior !== null) {
+      return;
+    }
+
+    // Create new tracker instance with the validated apiKey
+    const tracker = new HumanBehaviorTracker(apiKey.trim(), process.env.NEXT_PUBLIC_INGESTION_URL || 'https://ingestion.humanbehavior.ai');
+    setHumanBehavior(tracker);
+
+    // Wait for initialization to complete
+    tracker.initializationPromise?.then(() => {
+      setIsInitialized(true);
+      
+      // Process any queued events
+      if (eventQueue.length > 0) {
+        eventQueue.forEach(event => {
+          if (event.type === 'identify') {
+            console.log('Processing queued identify event', event.userProperties);
+            tracker.addUserInfo(event.userProperties);
+          } else {
+            tracker.addEvent(event);
+          }
+        });
+        setEventQueue([]); // Clear the queue
+      }
+    }).catch(error => {
+      console.error('Failed to initialize HumanBehaviorTracker:', error);
+    });
+  }, [apiKey, client, eventQueue, isMounted]);
+
+  // If not in browser, render children without context
+  if (!(isBrowser())) {
+    return <>{children}</>;
+  }
+
+  // If not mounted yet, render children with queuing context
+  if (!isMounted) {
+    return (
+      <HumanBehaviorContext.Provider value={{ humanBehavior: null, queueEvent }}>
+        {children}
+      </HumanBehaviorContext.Provider>
+    );
+  }
+
+  // If not initialized yet, render children with queuing context
+  if (!isInitialized) {
+    return (
+      <HumanBehaviorContext.Provider value={{ humanBehavior: null, queueEvent }}>
+        {children}
+      </HumanBehaviorContext.Provider>
+    );
+  }
+
+  return (
+    <HumanBehaviorContext.Provider value={{ humanBehavior, queueEvent }}>
+      {children}
+    </HumanBehaviorContext.Provider>
+  );
+};
+
+export const useHumanBehavior = (): HumanBehaviorInterface => {
+  const context = useContext(HumanBehaviorContext);
+  
+  // Only throw if the hook is used outside of a provider entirely
+  if (context === null) {
+    throw new Error("useHumanBehavior must be used within a HumanBehaviorProvider");
+  }
+
+  // If we're in the server-side, return a no-op implementation
+  if (typeof window === 'undefined') {
+    console.warn('HumanBehavior is being used before being initialized');
+    return {
+      addEvent: () => {},
+      addUserInfo: async () => {},
+      start: () => {},
+      stop: () => {},
+      viewLogs: () => {},
+    };
+  }
+  
+  // If we have an initialized tracker, return it as the interface
+  if (context.humanBehavior) {
+    return context.humanBehavior;
+  }
+
+  // If we reach here, we're in the initialization period where:
+  // - context.humanBehavior is null
+  // - context.queueEvent is available
+  // - we need to queue all operations until initialization completes
+  return {
+    addEvent: (event: any) => {
+      context.queueEvent(event);
+    },
+    addUserInfo: async (userProperties: Record<string, any>) => {
+      context.queueEvent({
+        type: 'identify',
+        userProperties,
+      });
+    },
+    start: () => {
+      // Start will be called automatically when initialized
+    },
+    stop: () => {
+      // Stop is a no-op when not initialized
+    },
+    viewLogs: () => {
+      console.warn('Logs are not available until HumanBehaviorTracker is initialized');
+    }
+  };
+};