releasebird-javascript-sdk 1.0.87 → 1.0.89

package/src/RbirdAutomationManager.js

@@ -0,0 +1,416 @@
+import RbirdSessionManager from "./RbirdSessionManager";
+import { RbirdBannerManager } from "./RbirdBannerManager";
+import { RbirdFormManager } from "./RbirdFormManager";
+import { RbirdSurveyManager } from "./RbirdSurveyManager";
+
+/**
+ * Manages automations and their execution in the SDK.
+ * Automations are event-driven workflows that can trigger actions
+ * like showing banners, forms, surveys, or sending chat messages.
+ */
+export class RbirdAutomationManager {
+    static instance = null;
+    automations = [];
+    apiKey = null;
+    firstSeenTimestamp = null;
+    executedAutomations = new Set(); // Track which automations have been executed
+
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new RbirdAutomationManager();
+        }
+        return this.instance;
+    }
+
+    /**
+     * Initialize the automation manager
+     * @param {string} apiKey - The API key for the project
+     */
+    async init(apiKey) {
+        this.apiKey = apiKey;
+        this.firstSeenTimestamp = this.getFirstSeenTimestamp();
+
+        // Load automations from backend
+        await this.loadAutomations();
+
+        // Register event handlers
+        this.registerEventHandlers();
+
+        // Check for first_seen triggers immediately
+        this.checkFirstSeenTriggers();
+    }
+
+    /**
+     * Get or set the first_seen timestamp
+     */
+    getFirstSeenTimestamp() {
+        const stored = localStorage.getItem('rbird_first_seen');
+        if (stored) {
+            return parseInt(stored, 10);
+        }
+        const now = Date.now();
+        localStorage.setItem('rbird_first_seen', now.toString());
+        return now;
+    }
+
+    /**
+     * Load active automations from the backend
+     */
+    async loadAutomations() {
+        try {
+            const sessionManager = RbirdSessionManager.getInstance();
+            const baseUrl = sessionManager.apiUrl || 'https://api.releasebird.com';
+
+            const response = await fetch(`${baseUrl}/papi/ewidget/automations`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'apiKey': this.apiKey,
+                    'languageCode': navigator.language?.split('-')[0] || 'en',
+                },
+            });
+
+            if (response.ok) {
+                this.automations = await response.json();
+                console.log('[Rbird] Loaded automations:', this.automations.length);
+            }
+        } catch (error) {
+            console.error('[Rbird] Error loading automations:', error);
+        }
+    }
+
+    /**
+     * Register event handlers for automation triggers
+     */
+    registerEventHandlers() {
+        // Listen for page visits
+        window.addEventListener('popstate', () => this.handleEvent('page_visit'));
+
+        // Listen for identify events
+        document.addEventListener('rbird:identify', (e) => {
+            this.handleEvent('user_identified', e.detail);
+        });
+
+        // Listen for form submissions
+        document.addEventListener('rbird:form_submitted', (e) => {
+            this.handleEvent('form_submitted', e.detail);
+        });
+
+        // Listen for survey completions
+        document.addEventListener('rbird:survey_completed', (e) => {
+            this.handleEvent('survey_completed', e.detail);
+        });
+
+        // Listen for custom events
+        document.addEventListener('rbird:track', (e) => {
+            this.handleEvent(e.detail?.eventName, e.detail?.data);
+        });
+    }
+
+    /**
+     * Check for first_seen triggers on initialization
+     */
+    checkFirstSeenTriggers() {
+        const timeSinceFirstSeen = (Date.now() - this.firstSeenTimestamp) / 1000; // in seconds
+
+        this.automations.forEach((automation) => {
+            const triggerNode = this.findTriggerNode(automation);
+            if (triggerNode && triggerNode.data?.eventType === 'first_seen') {
+                this.evaluateAndExecute(automation, triggerNode, { timeSinceFirstSeen });
+            }
+        });
+    }
+
+    /**
+     * Handle an event and check for matching automations
+     * @param {string} eventType - The type of event
+     * @param {Object} eventData - Additional event data
+     */
+    handleEvent(eventType, eventData = {}) {
+        this.automations.forEach((automation) => {
+            const triggerNode = this.findTriggerNode(automation);
+            if (triggerNode && triggerNode.data?.eventType === eventType) {
+                this.evaluateAndExecute(automation, triggerNode, eventData);
+            }
+        });
+    }
+
+    /**
+     * Find the trigger node in an automation
+     * @param {Object} automation - The automation object
+     * @returns {Object|null} The trigger node or null
+     */
+    findTriggerNode(automation) {
+        return automation.nodes?.find((node) => node.type === 'trigger');
+    }
+
+    /**
+     * Evaluate trigger conditions and execute the automation
+     * @param {Object} automation - The automation object
+     * @param {Object} triggerNode - The trigger node
+     * @param {Object} context - The event context
+     */
+    evaluateAndExecute(automation, triggerNode, context) {
+        // Check if automation was already executed (for once-only automations)
+        if (this.executedAutomations.has(automation.id)) {
+            return;
+        }
+
+        // Evaluate trigger conditions
+        if (!this.evaluateTriggerConditions(triggerNode, context)) {
+            return;
+        }
+
+        // Mark as executed
+        this.executedAutomations.add(automation.id);
+
+        // Execute the workflow starting from the trigger node
+        this.executeWorkflow(automation, triggerNode.id, context);
+    }
+
+    /**
+     * Evaluate trigger conditions
+     * @param {Object} triggerNode - The trigger node
+     * @param {Object} context - The event context
+     * @returns {boolean} Whether conditions are met
+     */
+    evaluateTriggerConditions(triggerNode, context) {
+        const conditions = triggerNode.data?.conditions || [];
+
+        for (const condition of conditions) {
+            const value = this.getContextValue(condition.property, context);
+
+            switch (condition.operator) {
+                case 'less_than':
+                    if (!(parseFloat(value) < parseFloat(condition.value))) return false;
+                    break;
+                case 'greater_than':
+                    if (!(parseFloat(value) > parseFloat(condition.value))) return false;
+                    break;
+                case 'equals':
+                    if (value !== condition.value) return false;
+                    break;
+                case 'contains':
+                    if (!String(value).includes(condition.value)) return false;
+                    break;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Get a value from the context
+     * @param {string} property - The property path
+     * @param {Object} context - The context object
+     * @returns {any} The value
+     */
+    getContextValue(property, context) {
+        if (property === 'time_since_first_seen' || property === 'timeSinceFirstSeen') {
+            return context.timeSinceFirstSeen || (Date.now() - this.firstSeenTimestamp) / 1000;
+        }
+
+        // Navigate nested properties like "user.language"
+        const parts = property.split('.');
+        let value = context;
+        for (const part of parts) {
+            value = value?.[part];
+        }
+        return value;
+    }
+
+    /**
+     * Execute a workflow from a starting node
+     * @param {Object} automation - The automation object
+     * @param {string} startNodeId - The ID of the starting node
+     * @param {Object} context - The execution context
+     */
+    executeWorkflow(automation, startNodeId, context) {
+        // Find next nodes to execute
+        const nextEdges = automation.edges?.filter((edge) => edge.source === startNodeId) || [];
+
+        for (const edge of nextEdges) {
+            const targetNode = automation.nodes?.find((node) => node.id === edge.target);
+            if (!targetNode) continue;
+
+            if (targetNode.type === 'condition') {
+                // Evaluate condition and follow appropriate path
+                const conditionResult = this.evaluateCondition(targetNode, context);
+                const handleToFollow = conditionResult ? 'true' : 'false';
+
+                // Find edges from this condition with matching handle
+                const conditionEdges = automation.edges?.filter(
+                    (e) => e.source === targetNode.id && e.sourceHandle === handleToFollow
+                ) || [];
+
+                for (const condEdge of conditionEdges) {
+                    this.executeWorkflow(automation, condEdge.source, context);
+                }
+            } else if (targetNode.type === 'action') {
+                // Execute the action
+                this.executeAction(targetNode, context);
+
+                // Continue to next nodes if any
+                this.executeWorkflow(automation, targetNode.id, context);
+            }
+        }
+    }
+
+    /**
+     * Evaluate a condition node
+     * @param {Object} conditionNode - The condition node
+     * @param {Object} context - The execution context
+     * @returns {boolean} The result of the condition
+     */
+    evaluateCondition(conditionNode, context) {
+        const { property, operator, value } = conditionNode.data || {};
+
+        let actualValue;
+
+        // Get the value to compare
+        if (property?.startsWith('user.')) {
+            const userProp = property.replace('user.', '');
+            actualValue = RbirdSessionManager.getInstance().getUser()?.[userProp];
+        } else if (property?.startsWith('page.')) {
+            const pageProp = property.replace('page.', '');
+            if (pageProp === 'url') {
+                actualValue = window.location.href;
+            } else if (pageProp === 'path') {
+                actualValue = window.location.pathname;
+            }
+        } else {
+            actualValue = context[property];
+        }
+
+        switch (operator) {
+            case 'equals':
+                return actualValue === value;
+            case 'not_equals':
+                return actualValue !== value;
+            case 'contains':
+                return String(actualValue).includes(value);
+            case 'starts_with':
+                return String(actualValue).startsWith(value);
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Execute an action node
+     * @param {Object} actionNode - The action node
+     * @param {Object} context - The execution context
+     */
+    executeAction(actionNode, context) {
+        const { actionType, config } = actionNode.data || {};
+
+        console.log('[Rbird] Executing action:', actionType, config);
+
+        switch (actionType) {
+            case 'send_chat':
+                this.executeSendChat(config?.message, context);
+                break;
+            case 'show_banner':
+                this.executeShowBanner(config?.bannerId);
+                break;
+            case 'show_form':
+                this.executeShowForm(config?.formId);
+                break;
+            case 'show_survey':
+                this.executeShowSurvey(config?.surveyId);
+                break;
+            case 'webhook':
+                this.executeWebhook(config?.webhookUrl, config?.webhookMethod || 'POST', context);
+                break;
+        }
+    }
+
+    /**
+     * Execute send_chat action
+     */
+    executeSendChat(message, context) {
+        if (!message) return;
+
+        // Replace placeholders in message
+        const processedMessage = this.processMessage(message, context);
+
+        // Dispatch event for the chat widget to handle
+        document.dispatchEvent(new CustomEvent('rbird:automation_chat', {
+            detail: { message: processedMessage }
+        }));
+
+        console.log('[Rbird] Chat message triggered:', processedMessage);
+    }
+
+    /**
+     * Execute show_banner action
+     */
+    executeShowBanner(bannerId) {
+        if (!bannerId) return;
+        RbirdBannerManager.getInstance().showBanner(bannerId);
+    }
+
+    /**
+     * Execute show_form action
+     */
+    executeShowForm(formId) {
+        if (!formId) return;
+        RbirdFormManager.getInstance().showForm(formId, {});
+    }
+
+    /**
+     * Execute show_survey action
+     */
+    executeShowSurvey(surveyId) {
+        if (!surveyId) return;
+        RbirdSurveyManager.getInstance().showSurvey(surveyId, {});
+    }
+
+    /**
+     * Execute webhook action
+     */
+    async executeWebhook(url, method, context) {
+        if (!url) return;
+
+        try {
+            const options = {
+                method: method,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            };
+
+            if (method === 'POST') {
+                options.body = JSON.stringify(context);
+            }
+
+            await fetch(url, options);
+            console.log('[Rbird] Webhook executed:', url);
+        } catch (error) {
+            console.error('[Rbird] Webhook error:', error);
+        }
+    }
+
+    /**
+     * Process message placeholders
+     */
+    processMessage(message, context) {
+        return message
+            .replace(/\{\{user\.name\}\}/g, RbirdSessionManager.getInstance().getUser()?.name || '')
+            .replace(/\{\{user\.email\}\}/g, RbirdSessionManager.getInstance().getUser()?.email || '')
+            .replace(/\{\{page\.url\}\}/g, window.location.href);
+    }
+
+    /**
+     * Track a custom event
+     * @param {string} eventName - The name of the event
+     * @param {Object} data - Additional event data
+     */
+    track(eventName, data = {}) {
+        document.dispatchEvent(new CustomEvent('rbird:track', {
+            detail: { eventName, data }
+        }));
+    }
+}
+
+export default RbirdAutomationManager;

package/src/RbirdFormManager.js

@@ -351,10 +351,15 @@ export class RbirdFormManager {
             }
         };
 
+        // Determine user info - use identified user data or fallback to visitor with anonymous ID
+        const userEmail = state?.identify?.properties?.email || state?.identify?.email || null;
+        const userName = state?.identify?.properties?.name || state?.identify?.name ||
+            (sessionManager.anonymousIdentifier ? `Visitor (${sessionManager.anonymousIdentifier.substring(0, 8)})` : 'Visitor');
+
         http.send(JSON.stringify({
             data: data,
-            userEmail: state?.identify?.email || null,
-            userName: state?.identify?.name || null
+            userEmail: userEmail,
+            userName: userName
         }));
     }