@sailfish-ai/recorder 1.7.8 → 1.7.11

package/dist/eventStore.js

@@ -0,0 +1,42 @@
+import { openDB } from 'idb';
+const DB_NAME = 'leapsEventDB';
+const STORE_NAME = 'recordingEvents';
+const dbPromise = openDB(DB_NAME, 1, {
+    upgrade(db) {
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+            db.createObjectStore(STORE_NAME, { keyPath: 'id', autoIncrement: true });
+        }
+    },
+});
+export async function saveEventToIDB(event) {
+    const db = await dbPromise;
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    await tx.store.add({ timestamp: Date.now(), data: event });
+    await tx.done;
+}
+export async function saveEventsToIDB(events) {
+    const db = await dbPromise;
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    for (const event of events) {
+        await tx.store.add({ timestamp: Date.now(), data: event });
+    }
+    await tx.done;
+}
+export async function getAllIndexedEvents() {
+    const db = await dbPromise;
+    return await db.getAll(STORE_NAME);
+}
+export async function deleteEventById(id) {
+    const db = await dbPromise;
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    await tx.store.delete(id);
+    await tx.done;
+}
+export async function deleteEventsByIds(ids) {
+    const db = await dbPromise;
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    for (const id of ids) {
+        await tx.store.delete(id);
+    }
+    await tx.done;
+}

package/dist/index.js

@@ -1,11 +1,10 @@
 // import { NetworkRecordOptions } from "@sailfish-rrweb/rrweb-plugin-network-record";
 import { v4 as uuidv4 } from "uuid";
 import { gatherAndCacheDeviceInfo } from "./deviceInfo";
-import { cacheEvents, sendRecordingEvents } from "./eventCache";
 import { fetchCaptureSettings, sendDomainsToNotPropagateHeaderTo, startRecordingSession, } from "./graphql";
 import { sendMapUuidIfAvailable } from "./mapUuid";
 import { initializeDomContentEvents, initializeConsolePlugin, initializeRecording, getUrlAndStoredUuids, } from "./recording";
-import { sendMessage } from "./websocket";
+import { sendEvent, sendMessage } from "./websocket";
 import { NetworkRequestEventId, xSf3RidHeader } from "./constants";
 // Default list of domains to ignore
 const DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT = [
@@ -322,9 +321,10 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
                 const success = response.ok;
                 const error = success ? '' : `Request Error: ${response.statusText}`;
                 // Emit 'networkRequestFinished' event
-                cacheEvents({
+                const eventData = {
                     type: NetworkRequestEventId,
                     timestamp: endTime,
+                    sessionId,
                     data: {
                         request_id: networkUUID,
                         session_id: sessionId,
@@ -337,7 +337,8 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
                         url,
                     },
                     ...urlAndStoredUuids,
-                });
+                };
+                sendEvent(eventData);
                 return response;
             }
             catch (error) {
@@ -346,9 +347,10 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
                 const responseCode = error.response?.status || 500;
                 const errorMessage = error.message || "Fetch request failed";
                 // Emit 'networkRequestFinished' event with error
-                cacheEvents({
+                const eventData = {
                     type: NetworkRequestEventId,
                     timestamp: endTime,
+                    sessionId,
                     data: {
                         request_id: networkUUID,
                         session_id: sessionId,
@@ -361,7 +363,8 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
                         url,
                     },
                     ...urlAndStoredUuids
-                });
+                };
+                sendEvent(eventData);
                 throw error;
             }
         }
@@ -393,9 +396,9 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
 }
 // Main Recording Function
 export async function startRecording({ apiKey, backendApi = "https://api-service.sailfishqa.com", domainsToPropagateHeaderTo = [], domainsToNotPropagateHeaderTo = [], serviceVersion = "", serviceIdentifier = "", }) {
-    initializeDomContentEvents();
-    initializeConsolePlugin(DEFAULT_CONSOLE_RECORDING_SETTINGS);
     let sessionId = getOrSetSessionId();
+    initializeDomContentEvents(sessionId);
+    initializeConsolePlugin(DEFAULT_CONSOLE_RECORDING_SETTINGS, sessionId);
     storeCredentialsAndConnection({ apiKey, backendApi });
     trackDomainChanges();
     // Non-blocking GraphQL request to send the domains if provided
@@ -417,7 +420,6 @@ export async function startRecording({ apiKey, backendApi = "https://api-service
             backendApi, apiKey, sessionId);
             // Send parameters once before starting interval
             sendMapUuidIfAvailable(serviceIdentifier, serviceVersion);
-            setInterval(() => sendRecordingEvents(websocket), 10000);
         }
         else {
             console.error("Failed to start recording session:", sessionResponse.errors || sessionResponse);
@@ -436,7 +438,7 @@ export const initRecorder = async (options) => {
     return startRecording(options);
 };
 // Re-export from other modules
-export * from "./eventCache";
+export * from "./utils";
 export * from "./graphql";
 export * from "./recording";
 export * from "./sendSailfishMessages";

package/dist/notifyEventStore.js

@@ -0,0 +1,26 @@
+import { openDB } from 'idb';
+const DB_NAME = 'leapsNotifyDB';
+const STORE_NAME = 'notifyMessages';
+const dbPromise = openDB(DB_NAME, 1, {
+    upgrade(db) {
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+            db.createObjectStore(STORE_NAME, { keyPath: 'id', autoIncrement: true });
+        }
+    },
+});
+export async function saveNotifyMessageToIDB(message) {
+    const db = await dbPromise;
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    await tx.store.add({ value: message });
+    await tx.done;
+}
+export async function getAllNotifyMessages() {
+    const db = await dbPromise;
+    return await db.getAll(STORE_NAME);
+}
+export async function deleteNotifyMessageById(id) {
+    const db = await dbPromise;
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    await tx.store.delete(id);
+    await tx.done;
+}

package/dist/recording.js

@@ -3,8 +3,7 @@ import { getRecordConsolePlugin, } from "@sailfish-rrweb/rrweb-plugin-console-re
 // import { NetworkRecordOptions } from "@sailfish-rrweb/rrweb-plugin-network-record";
 import { EventType } from "@sailfish-rrweb/types";
 import { ZendeskAPI } from "react-zendesk";
-import { cacheEvents, sendRecordingEvents } from "./eventCache";
-import { initializeWebSocket } from "./websocket";
+import { initializeWebSocket, sendEvent } from "./websocket";
 import { DomContentEventId, DomContentSource, Loading, Complete } from "./constants";
 const MASK_CLASS = "sailfishSanitize";
 const ZENDESK_ELEMENT_ID = "zendesk_chat";
@@ -40,13 +39,14 @@ export const getUrlAndStoredUuids = () => ({
     prev_page_visit_uuid: sessionStorage.getItem("prevPageVisitUUID"),
     href: location.origin + location.pathname,
 });
-export function initializeDomContentEvents() {
+export function initializeDomContentEvents(sessionId) {
     document.addEventListener("readystatechange", () => {
         const timestamp = Date.now();
         const newEvent = {
             type: DomContentEventId,
             data: { source: 0, info: "" },
             timestamp,
+            sessionId,
             ...getUrlAndStoredUuids(),
         };
         switch (document.readyState) {
@@ -58,43 +58,51 @@ export function initializeDomContentEvents() {
                 break;
         }
         if (newEvent.data.info)
-            cacheEvents(newEvent);
+            sendEvent(newEvent);
     });
     document.addEventListener("DOMContentLoaded", () => {
-        cacheEvents({
+        sendEvent({
             type: DomContentEventId,
             data: { source: DomContentSource.contentLoaded },
             timestamp: Date.now(),
+            sessionId,
             ...getUrlAndStoredUuids(),
         });
     });
     window.addEventListener("beforeunload", () => {
-        cacheEvents({
+        sendEvent({
             type: DomContentEventId,
             data: { source: DomContentSource.beforeunload },
             timestamp: Date.now(),
+            sessionId,
             ...getUrlAndStoredUuids(),
         });
     });
     window.addEventListener("unload", () => {
-        cacheEvents({
+        sendEvent({
             type: DomContentEventId,
             data: { source: DomContentSource.unload },
             timestamp: Date.now(),
+            sessionId,
             ...getUrlAndStoredUuids(),
         });
     });
 }
-export function initializeConsolePlugin(consoleRecordSettings) {
+export function initializeConsolePlugin(consoleRecordSettings, sessionId) {
     const { name, observer } = getRecordConsolePlugin(consoleRecordSettings);
-    observer((payload) => cacheEvents({
-        type: EventType.Plugin,
-        timestamp: Date.now(),
-        data: {
-            plugin: name,
-            payload,
-        },
-    }), window, consoleRecordSettings);
+    observer((payload) => {
+        const eventData = {
+            type: EventType.Plugin,
+            timestamp: Date.now(),
+            data: {
+                plugin: name,
+                payload,
+            },
+            sessionId: sessionId,
+            ...getUrlAndStoredUuids(),
+        };
+        sendEvent(eventData);
+    }, window, consoleRecordSettings);
 }
 export async function initializeRecording(captureSettings, // TODO - Sibyl post-launch - replace type
 // networkRecordSettings: NetworkRecordOptions,
@@ -106,7 +114,7 @@ backendApi, apiKey, sessionId) {
                 Object.assign(event, getUrlAndStoredUuids());
                 // Attach sessionId to each event
                 event.sessionId = sessionId;
-                cacheEvents(event);
+                sendEvent(event);
             },
             maskInputOptions: { text: true }, // Fix the incorrect property name
             maskInputFn,
@@ -140,7 +148,6 @@ backendApi, apiKey, sessionId) {
         ZendeskAPI("messenger:on", "open", handleWidgetOpen);
         ZendeskAPI("messenger:on", "close", handleWidgetClose);
         ZendeskAPI("messenger:on", "unreadMessages", handleUnreadMessages);
-        setInterval(() => sendRecordingEvents(webSocket), 10000);
     }
     catch (error) {
         console.error("Error importing plugins!", error);