@checkflow/sdk 1.0.1 → 1.0.3

package/dist/analytics-tracker.d.ts

@@ -72,6 +72,7 @@ export declare class AnalyticsTracker {
     constructor(apiClient: APIClient, options?: Partial<AnalyticsOptions>);
     startTracking(): Promise<void>;
     stopTracking(): Promise<void>;
+    private saveSessionRecording;
     private createSession;
     private updateSessionEnd;
     private setupEventListeners;

package/dist/api-client.d.ts

@@ -45,15 +45,13 @@ export declare class APIClient {
      */
     uploadScreenshotOnly(screenshotBase64: string, url: string): Promise<APIResponse>;
     /**
-     * Save session recording to backend
-     * Aligns with backend /sdk/recording endpoint
+     * Save session recording to analytics backend
+     * Recordings are now part of analytics sessions (independent from feedbacks)
      */
     saveSessionRecording(recording: {
         events: any[];
         sessionId: string;
-        startUrl: string;
-        endUrl?: string;
-        durationSeconds: number;
+        durationMs?: number;
     }): Promise<APIResponse>;
     /**
      * Report an error to the backend

package/dist/index.esm.js

@@ -236,16 +236,13 @@ class APIClient {
         });
     }
     /**
-     * Save session recording to backend
-     * Aligns with backend /sdk/recording endpoint
+     * Save session recording to analytics backend
+     * Recordings are now part of analytics sessions (independent from feedbacks)
      */
     async saveSessionRecording(recording) {
-        return this.request('POST', '/api/v1/capture/sdk/recording', {
+        return this.request('POST', `/api/v1/analytics/sessions/${recording.sessionId}/recording`, {
             events: recording.events,
-            session_id: recording.sessionId,
-            start_url: recording.startUrl,
-            end_url: recording.endUrl,
-            duration_seconds: recording.durationSeconds,
+            duration_ms: recording.durationMs || 0,
         });
     }
     /**
@@ -2707,6 +2704,10 @@ class SessionRecording {
     start() {
         if (this.isRecording || !this.config.enabled)
             return;
+        console.log(' [SessionRecording] Starting session recording...', {
+            sessionId: this.sessionId,
+            config: this.config
+        });
         this.isRecording = true;
         this.startTime = Date.now();
         this.events = [];
@@ -2715,20 +2716,25 @@ class SessionRecording {
         // Setup event listeners
         if (this.config.recordMouse) {
             this.setupMouseTracking();
+            console.log(' [SessionRecording] Mouse tracking enabled');
         }
         if (this.config.recordScroll) {
             this.setupScrollTracking();
+            console.log(' [SessionRecording] Scroll tracking enabled');
         }
         if (this.config.recordInput) {
             this.setupInputTracking();
+            console.log(' [SessionRecording] Input tracking enabled');
         }
         if (this.config.recordMutations) {
             this.setupMutationObserver();
+            console.log(' [SessionRecording] Mutation observer enabled');
         }
         // Track navigation
         this.setupNavigationTracking();
         // Track resize
         this.setupResizeTracking();
+        console.log(' [SessionRecording] Session recording started successfully');
         // Auto-stop after max duration
         setTimeout(() => {
             if (this.isRecording) {
@@ -2784,13 +2790,29 @@ class SessionRecording {
      * Get recording data for submission
      */
     getRecordingData() {
-        if (this.events.length === 0)
+        console.log('🎥 [SessionRecording] getRecordingData called:', {
+            eventCount: this.events.length,
+            sessionId: this.sessionId,
+            duration: this.getDuration(),
+            isRecording: this.isRecording,
+            startTime: this.startTime
+        });
+        if (this.events.length === 0) {
+            console.warn('🎥 [SessionRecording] No events to return');
             return null;
-        return {
+        }
+        const data = {
             events: [...this.events],
             sessionId: this.sessionId,
             duration: this.getDuration(),
         };
+        console.log('🎥 [SessionRecording] Returning recording data:', {
+            eventCount: data.events.length,
+            duration: data.duration,
+            firstEventType: data.events[0]?.type,
+            lastEventType: data.events[data.events.length - 1]?.type
+        });
+        return data;
     }
     addEvent(type, data) {
         // Sample rate filtering
@@ -3602,6 +3624,8 @@ class AnalyticsTracker {
         try {
             // Flush any remaining interactions
             await this.flushInteractions();
+            // Save session recording if available
+            await this.saveSessionRecording();
             // Update session with end time
             await this.updateSessionEnd();
             // Remove event listeners
@@ -3622,6 +3646,56 @@ class AnalyticsTracker {
             console.error('Error stopping analytics tracking:', error);
         }
     }
+    async saveSessionRecording() {
+        // Get session recording from global CheckFlow instance if available
+        try {
+            console.log('🎬 [AnalyticsTracker] Starting saveSessionRecording for session:', this.sessionId);
+            const checkflowInstance = window.checkflow;
+            console.log('🎬 [AnalyticsTracker] CheckFlow instance found:', !!checkflowInstance);
+            console.log('🎬 [AnalyticsTracker] SessionRecording instance found:', !!checkflowInstance?.sessionRecording);
+            if (!checkflowInstance || !checkflowInstance.sessionRecording) {
+                console.warn('🎬 [AnalyticsTracker] No session recording available - instance missing');
+                this.log('No session recording available');
+                return;
+            }
+            const recordingData = checkflowInstance.sessionRecording.getRecordingData();
+            console.log('🎬 [AnalyticsTracker] Recording data retrieved:', {
+                hasData: !!recordingData,
+                eventCount: recordingData?.events?.length || 0,
+                duration: recordingData?.duration || 0,
+                sessionId: recordingData?.sessionId
+            });
+            if (!recordingData || recordingData.events.length === 0) {
+                console.warn('🎬 [AnalyticsTracker] No recording events to save - events array empty');
+                this.log('No recording events to save');
+                return;
+            }
+            // Save recording to analytics backend
+            console.log('🎬 [AnalyticsTracker] Saving recording to backend...', {
+                sessionId: this.sessionId,
+                eventCount: recordingData.events.length,
+                durationMs: recordingData.duration * 1000
+            });
+            const result = await this.apiClient.saveSessionRecording({
+                events: recordingData.events,
+                sessionId: this.sessionId,
+                durationMs: recordingData.duration * 1000
+            });
+            console.log('🎬 [AnalyticsTracker] Session recording saved successfully:', result);
+            this.log('Session recording saved:', {
+                eventCount: recordingData.events.length,
+                duration: recordingData.duration
+            });
+        }
+        catch (error) {
+            console.error('🎬 [AnalyticsTracker] Failed to save session recording:', error);
+            console.error('🎬 [AnalyticsTracker] Error details:', {
+                message: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+                sessionId: this.sessionId
+            });
+        }
+    }
     // ==================== Private Methods - Session Management ====================
     async createSession() {
         const sessionData = {
@@ -4044,6 +4118,8 @@ class CheckFlow {
         }
         // Store as singleton
         CheckFlow.instance = this;
+        // Expose globally for analytics tracker access
+        window.checkflow = this;
     }
     /**
      * Initialize the SDK