@flowuent-org/diagramming-core 1.0.7 → 1.1.0

package/dist/out-tsc/packages/diagrams/src/lib/utils/AutomationExecutionEngine.js

@@ -0,0 +1,756 @@
+import { __awaiter } from "tslib";
+import { GoogleSheetsService, } from '../services/GoogleSheetsService';
+import { SlackService } from '../services/SlackService';
+import { TwilioWhatsAppService } from '../services/TwilioWhatsAppService';
+export class AutomationExecutionEngine {
+    constructor(nodes, edges, onNodeUpdate, onLog) {
+        this.nodes = nodes;
+        this.edges = edges;
+        this.onNodeUpdate = onNodeUpdate;
+        this.onLog = onLog;
+        this.context = {
+            runId: this.generateRunId(),
+            startTime: new Date(),
+            variables: {},
+            logs: [],
+        };
+    }
+    generateRunId() {
+        return `run_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    storeExecutionResult(nodeId, result, success = true, error, executionTime) {
+        const node = this.nodes.find((n) => n.id === nodeId);
+        if (!node)
+            return;
+        const executionResult = {
+            success,
+            data: result,
+            timestamp: new Date().toISOString(),
+            error,
+            executionTime,
+        };
+        // Update the node's formData with execution result
+        if (node.data.formData) {
+            node.data.formData.executionResult = executionResult;
+        }
+        else {
+            node.data.executionResult = executionResult;
+        }
+        // Notify the parent component about the node update
+        if (this.onNodeUpdate) {
+            // Create new object reference with deep clone of formData so React detects the change
+            const updatedData = Object.assign(Object.assign({}, node.data), (node.data.formData ? { formData: Object.assign({}, node.data.formData) } : {}));
+            this.onNodeUpdate(nodeId, updatedData);
+        }
+    }
+    log(level, nodeId, nodeType, message, data) {
+        const entry = {
+            timestamp: new Date(),
+            nodeId,
+            nodeType,
+            level,
+            message,
+            data,
+        };
+        this.context.logs.push(entry);
+        if (this.onLog) {
+            try {
+                this.onLog(entry);
+            }
+            catch (_a) {
+                // ignore UI callback errors
+            }
+        }
+    }
+    getNextNodes(currentNodeId) {
+        const outgoingEdges = this.edges.filter((edge) => edge.source === currentNodeId);
+        const nextNodeIds = outgoingEdges.map((edge) => edge.target);
+        return this.nodes.filter((node) => nextNodeIds.includes(node.id));
+    }
+    executeStartNode(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = node.data;
+            this.log('info', node.id, 'AutomationStartNode', 'Starting automation workflow');
+            // Set initial context variables
+            this.context.variables.runId = this.context.runId;
+            this.context.variables.startTime = this.context.startTime.toISOString();
+            const result = {
+                runId: this.context.runId,
+                startTime: this.context.startTime.toISOString(),
+            };
+            // Store the execution result in node data
+            this.storeExecutionResult(node.id, result, true);
+            return result;
+        });
+    }
+    executeApiNode(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = node.data;
+            const formData = (data.formData || data);
+            this.log('info', node.id, 'AutomationApiNode', `Making ${formData.method} request to ${formData.url}`);
+            try {
+                const headers = {};
+                if (formData.headers && Array.isArray(formData.headers)) {
+                    formData.headers.forEach((header) => {
+                        if (header.enabled) {
+                            headers[header.key] = header.value;
+                        }
+                    });
+                }
+                const queryParams = new URLSearchParams();
+                if (formData.queryParams && Array.isArray(formData.queryParams)) {
+                    formData.queryParams.forEach((param) => {
+                        if (param.enabled) {
+                            queryParams.append(param.key, param.value);
+                        }
+                    });
+                }
+                const url = queryParams.toString()
+                    ? `${formData.url}?${queryParams.toString()}`
+                    : formData.url;
+                const requestOptions = {
+                    method: formData.method,
+                    headers,
+                    signal: AbortSignal.timeout(formData.timeout || 30000),
+                };
+                if (formData.body &&
+                    (formData.method === 'POST' || formData.method === 'PUT')) {
+                    requestOptions.body = formData.body;
+                }
+                const response = yield fetch(url, requestOptions);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText} - ${url}`);
+                }
+                const responseData = yield response.json();
+                this.log('success', node.id, 'AutomationApiNode', 'API call completed successfully', responseData);
+                // Store the execution result in node data
+                this.storeExecutionResult(node.id, responseData, true);
+                return responseData;
+            }
+            catch (error) {
+                let errorMessage = `API call failed: ${error}`;
+                if (error instanceof TypeError && error.message.includes('fetch')) {
+                    errorMessage = `Network error: Unable to connect to ${formData.url}. This might be due to CORS restrictions or network connectivity issues.`;
+                }
+                this.log('error', node.id, 'AutomationApiNode', errorMessage, error instanceof Error ? error.message : String(error));
+                // Store the error result in node data
+                this.storeExecutionResult(node.id, null, false, errorMessage);
+                throw new Error(errorMessage);
+            }
+        });
+    }
+    executeFormattingNode(node, inputData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = node.data;
+            const formData = (data.formData || data);
+            this.log('info', node.id, 'AutomationFormattingNode', 'Starting data formatting');
+            try {
+                if (formData.formattingType === 'ai-powered' && formData.aiFormatting) {
+                    // AI-powered formatting
+                    this.log('info', node.id, 'AutomationFormattingNode', 'AI thinking...');
+                    const aiResponse = yield this.callAiApi(formData.aiFormatting, inputData);
+                    this.log('success', node.id, 'AutomationFormattingNode', 'AI formatting completed', aiResponse);
+                    // Store the execution result in node data
+                    this.storeExecutionResult(node.id, aiResponse, true);
+                    return aiResponse;
+                }
+                else {
+                    // Basic formatting
+                    const formattedData = this.basicFormatting(inputData, formData);
+                    this.log('success', node.id, 'AutomationFormattingNode', 'Basic formatting completed', formattedData);
+                    // Store the execution result in node data
+                    this.storeExecutionResult(node.id, formattedData, true);
+                    return formattedData;
+                }
+            }
+            catch (error) {
+                this.log('error', node.id, 'AutomationFormattingNode', `Formatting failed: ${error}`, error instanceof Error ? error.message : String(error));
+                // Store the error result in node data
+                this.storeExecutionResult(node.id, null, false, error instanceof Error ? error.message : String(error));
+                throw error;
+            }
+        });
+    }
+    callAiApi(aiConfig, inputData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Validate API key is not a placeholder
+            if (!aiConfig.apiKey ||
+                aiConfig.apiKey.includes('your-openai-api-key-here') ||
+                aiConfig.apiKey.length < 10) {
+                throw new Error('Invalid API key. Please provide a valid API key.');
+            }
+            // Additional validation for Gemini API key format
+            if (aiConfig.apiUrl.includes('generativelanguage.googleapis.com')) {
+                if (!aiConfig.apiKey.startsWith('AIza')) {
+                    throw new Error('Invalid Gemini API key format. Gemini API keys should start with "AIza".');
+                }
+            }
+            const prompt = `${aiConfig.instruction}\n\nInput data: ${JSON.stringify(inputData)}`;
+            // Determine if this is Gemini API or OpenAI API based on URL
+            const isGeminiApi = aiConfig.apiUrl.includes('generativelanguage.googleapis.com');
+            let requestBody;
+            let headers;
+            if (isGeminiApi) {
+                // Gemini API format
+                headers = {
+                    'Content-Type': 'application/json',
+                    'X-goog-api-key': aiConfig.apiKey,
+                };
+                requestBody = {
+                    contents: [
+                        {
+                            parts: [
+                                {
+                                    text: `${aiConfig.systemPrompt || 'You are a data formatting assistant.'}\n\n${prompt}`,
+                                },
+                            ],
+                        },
+                    ],
+                    generationConfig: {
+                        temperature: aiConfig.temperature || 0.1,
+                        maxOutputTokens: aiConfig.maxTokens || 1000,
+                        responseMimeType: 'application/json',
+                    },
+                };
+            }
+            else {
+                // OpenAI API format
+                headers = {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${aiConfig.apiKey}`,
+                };
+                requestBody = {
+                    model: aiConfig.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: aiConfig.systemPrompt || 'You are a data formatting assistant.',
+                        },
+                        {
+                            role: 'user',
+                            content: prompt,
+                        },
+                    ],
+                    temperature: aiConfig.temperature || 0.1,
+                    max_tokens: aiConfig.maxTokens || 1000,
+                };
+            }
+            const response = yield fetch(aiConfig.apiUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const errorText = yield response.text();
+                throw new Error(`AI API call failed: ${response.status} ${response.statusText}. ${errorText}`);
+            }
+            const result = yield response.json();
+            let content;
+            if (isGeminiApi) {
+                // Gemini API response format
+                if (!result.candidates ||
+                    !result.candidates[0] ||
+                    !result.candidates[0].content ||
+                    !result.candidates[0].content.parts) {
+                    throw new Error('Invalid Gemini API response format');
+                }
+                content = result.candidates[0].content.parts[0].text;
+            }
+            else {
+                // OpenAI API response format
+                if (!result.choices || !result.choices[0] || !result.choices[0].message) {
+                    throw new Error('Invalid AI API response format');
+                }
+                content = result.choices[0].message.content;
+            }
+            // Try to parse as JSON, fallback to string if parsing fails
+            try {
+                return JSON.parse(content);
+            }
+            catch (_a) {
+                return content;
+            }
+        });
+    }
+    basicFormatting(inputData, config) {
+        // Basic data transformation logic
+        if (typeof inputData === 'string') {
+            return inputData.trim();
+        }
+        if (Array.isArray(inputData)) {
+            return inputData.map((item) => this.basicFormatting(item, config));
+        }
+        if (typeof inputData === 'object' && inputData !== null) {
+            const formatted = {};
+            Object.keys(inputData).forEach((key) => {
+                formatted[key] = this.basicFormatting(inputData[key], config);
+            });
+            return formatted;
+        }
+        return inputData;
+    }
+    executeSheetsNode(node, inputData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            const data = node.data;
+            const formData = (data.formData || data);
+            this.log('info', node.id, 'AutomationSheetsNode', 'Starting Google Sheets export');
+            try {
+                // Initialize/derive per-output-method statuses container
+                const outputStatuses = data.outputStatuses || {};
+                // Only set Google Sheets status when exportFormat includes sheets
+                if (((_a = formData.exportOptions) === null || _a === void 0 ? void 0 : _a.exportFormat) === 'sheets' ||
+                    ((_b = formData.exportOptions) === null || _b === void 0 ? void 0 : _b.exportFormat) === 'both') {
+                    outputStatuses.googleSheets = 'running';
+                }
+                // Gmail runs only if enabled
+                if ((_c = formData.exportOptions) === null || _c === void 0 ? void 0 : _c.emailSendEnabled) {
+                    outputStatuses.gmail = 'running';
+                }
+                // Slack runs only if enabled
+                if ((_e = (_d = formData.exportOptions) === null || _d === void 0 ? void 0 : _d.slack) === null || _e === void 0 ? void 0 : _e.enabled) {
+                    outputStatuses.slack = 'running';
+                }
+                // WhatsApp runs only if enabled
+                if ((_g = (_f = formData.exportOptions) === null || _f === void 0 ? void 0 : _f.whatsapp) === null || _g === void 0 ? void 0 : _g.enabled) {
+                    outputStatuses.whatsapp = 'running';
+                }
+                data.outputStatuses = outputStatuses;
+                if (this.onNodeUpdate)
+                    this.onNodeUpdate(node.id, data);
+                const sheetsConfig = formData.sheetsConfig;
+                const dataMapping = formData.dataMapping;
+                const exportOptions = formData.exportOptions;
+                const wantsSheets = (exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.exportFormat) === 'sheets' ||
+                    (exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.exportFormat) === 'both';
+                const wantsExcel = (exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.exportFormat) === 'excel' ||
+                    (exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.exportFormat) === 'both';
+                const wantsGmail = Boolean(exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.emailSendEnabled);
+                const sheetsService = new GoogleSheetsService();
+                // Only perform Google auth/validation when Sheets or Gmail is in use
+                if (wantsSheets || wantsGmail) {
+                    this.log('info', node.id, 'AutomationSheetsNode', 'Authenticating with Google (Sheets/Gmail)...');
+                    // If Gmail send is enabled and we're using OAuth client, request both scopes in one consent
+                    try {
+                        const creds = (sheetsConfig === null || sheetsConfig === void 0 ? void 0 : sheetsConfig.credentials) || {};
+                        if (creds.type === 'oauth' && (creds.clientId || creds.oauthToken)) {
+                            const neededScopes = [
+                                'https://www.googleapis.com/auth/spreadsheets',
+                            ];
+                            if (exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.emailSendEnabled) {
+                                neededScopes.push('https://www.googleapis.com/auth/gmail.send');
+                            }
+                            const existing = Array.isArray(creds.scopes) ? creds.scopes : [];
+                            const union = Array.from(new Set([...existing, ...neededScopes]));
+                            creds.scopes = union;
+                            sheetsConfig.credentials = creds;
+                        }
+                    }
+                    catch (_r) {
+                        // Non-fatal; initialization will still proceed with default scopes
+                    }
+                    const validation = sheetsService.validateConfig(sheetsConfig);
+                    if (!validation.valid) {
+                        throw new Error(`Configuration validation failed: ${validation.errors.join(', ')}`);
+                    }
+                }
+                // Prepare data for export (only when exporting to Sheets/Excel)
+                let exportData = [];
+                if (wantsSheets || wantsExcel) {
+                    if (Array.isArray(inputData)) {
+                        exportData = inputData;
+                    }
+                    else if (inputData && typeof inputData === 'object') {
+                        exportData = [inputData];
+                    }
+                    else {
+                        throw new Error('Invalid input data format for export');
+                    }
+                }
+                // Initialize Google Sheets service only when using Sheets or Gmail
+                if (wantsSheets || wantsGmail) {
+                    yield sheetsService.initialize(sheetsConfig);
+                    this.log('success', node.id, 'AutomationSheetsNode', 'Authenticated with Google APIs (Sheets/Gmail)');
+                }
+                // Prepare export options
+                const sheetsExportOptions = {
+                    emailRecipients: exportOptions.emailRecipients,
+                    fileName: exportOptions.fileName,
+                    exportFormat: exportOptions.exportFormat === 'both'
+                        ? 'sheets'
+                        : exportOptions.exportFormat,
+                    includeHeaders: exportOptions.includeHeaders,
+                };
+                let response = null;
+                // Export to Google Sheets
+                if ((exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.exportFormat) === 'sheets' ||
+                    (exportOptions === null || exportOptions === void 0 ? void 0 : exportOptions.exportFormat) === 'both') {
+                    this.log('info', node.id, 'AutomationSheetsNode', 'Writing data to Google Sheets...');
+                    response = yield sheetsService.exportToSheets(exportData, sheetsConfig, dataMapping, sheetsExportOptions);
+                    this.log('success', node.id, 'AutomationSheetsNode', `Successfully exported ${response.rowsAdded} rows to Google Sheets`, response);
+                    // Mark GS connected on success
+                    outputStatuses.googleSheets = 'connected';
+                    data.outputStatuses = outputStatuses;
+                    if (this.onNodeUpdate)
+                        this.onNodeUpdate(node.id, data);
+                }
+                // Export to Excel
+                if (exportOptions.exportFormat === 'excel' ||
+                    exportOptions.exportFormat === 'both') {
+                    this.log('info', node.id, 'AutomationSheetsNode', 'Exporting data to Excel...');
+                    const excelResponse = yield sheetsService.exportToExcel(exportData, dataMapping, sheetsExportOptions);
+                    this.log('success', node.id, 'AutomationSheetsNode', `Successfully exported ${excelResponse.rowsAdded} rows to Excel`, excelResponse);
+                    // If we're doing both, merge the responses
+                    if (exportOptions.exportFormat === 'both') {
+                        response = Object.assign(Object.assign({}, response), { excelExport: excelResponse, combinedSuccess: response.success && excelResponse.success });
+                    }
+                    else {
+                        response = excelResponse;
+                    }
+                }
+                // Optional email send (via mailto fallback or Gmail API if implemented)
+                if (exportOptions.emailSendEnabled) {
+                    const emailRecipients = exportOptions.emailRecipients || [];
+                    if (emailRecipients.length > 0) {
+                        this.log('info', node.id, 'AutomationSheetsNode', `Sending email to ${emailRecipients.length} recipient(s)...`);
+                        const emailSent = yield sheetsService.sendEmail({
+                            from: exportOptions.emailSender,
+                            to: emailRecipients,
+                            subject: exportOptions.emailSubject || 'Automation Output',
+                            message: exportOptions.emailMessage,
+                            spreadsheetUrl: exportOptions.includeSpreadsheetLink &&
+                                (response === null || response === void 0 ? void 0 : response.spreadsheetUrl)
+                                ? response.spreadsheetUrl
+                                : undefined,
+                            // Note: attachExcel via Gmail requires Gmail scope and MIME building;
+                            // mailto cannot attach files. This is a placeholder hook.
+                            attachExcelBlob: undefined,
+                            attachExcelFileName: sheetsExportOptions.fileName,
+                            // Critical: disable UI fallback to ensure fully automated send
+                            disableUiFallback: true,
+                        });
+                        if (emailSent) {
+                            this.log('success', node.id, 'AutomationSheetsNode', `Email sent to ${emailRecipients.length} recipient(s)`);
+                            outputStatuses.gmail = 'connected';
+                        }
+                        else {
+                            this.log('error', node.id, 'AutomationSheetsNode', 'Email send failed (API)');
+                            outputStatuses.gmail = 'failed';
+                        }
+                        data.outputStatuses = outputStatuses;
+                        if (this.onNodeUpdate)
+                            this.onNodeUpdate(node.id, data);
+                    }
+                }
+                // Optional Slack send via webhook
+                if ((_h = exportOptions.slack) === null || _h === void 0 ? void 0 : _h.enabled) {
+                    const slackService = new SlackService();
+                    const validation = slackService.validateConfig(exportOptions.slack);
+                    if (!validation.valid) {
+                        throw new Error(`Slack configuration invalid: ${validation.errors.join(', ')}`);
+                    }
+                    // Build message text with simple token replacements
+                    const template = exportOptions.slack.messageTemplate ||
+                        'Automation update for {{fileName}}';
+                    const contextVars = {
+                        fileName: exportOptions.fileName,
+                        rowsAdded: response === null || response === void 0 ? void 0 : response.rowsAdded,
+                        sheetName: (response === null || response === void 0 ? void 0 : response.sheetName) || ((_j = formData.sheetsConfig) === null || _j === void 0 ? void 0 : _j.sheetName),
+                    };
+                    const messageText = template.replace(/\{\{(\w+)\}\}/g, (_, key) => key in contextVars ? String(contextVars[key]) : '');
+                    // Prefer spreadsheetUrl from Sheets response if available and flag set
+                    const spreadsheetUrl = exportOptions.slack.includeSpreadsheetLink
+                        ? (response === null || response === void 0 ? void 0 : response.spreadsheetUrl) || undefined
+                        : undefined;
+                    const payload = slackService.buildPayload(exportOptions.slack, messageText, inputData, spreadsheetUrl);
+                    try {
+                        this.log('info', node.id, 'AutomationSheetsNode', `Sending Slack message to #${exportOptions.slack.channel}...`);
+                        yield slackService.sendMessage({
+                            webhookUrl: exportOptions.slack.webhookUrl,
+                            payload,
+                        });
+                        this.log('success', node.id, 'AutomationSheetsNode', `Slack message sent to #${exportOptions.slack.channel}`);
+                        outputStatuses.slack = 'connected';
+                        data.outputStatuses = outputStatuses;
+                        if (this.onNodeUpdate)
+                            this.onNodeUpdate(node.id, data);
+                    }
+                    catch (slackErr) {
+                        const msg = slackErr instanceof Error ? slackErr.message : String(slackErr);
+                        this.log('error', node.id, 'AutomationSheetsNode', `Slack send failed: ${msg}`);
+                        // Do not fail the whole workflow due to Slack CORS; mark Slack as failed but continue
+                        outputStatuses.slack = 'failed';
+                        data.outputStatuses = outputStatuses;
+                        if (this.onNodeUpdate)
+                            this.onNodeUpdate(node.id, data);
+                    }
+                }
+                // Optional WhatsApp send
+                if ((_k = exportOptions.whatsapp) === null || _k === void 0 ? void 0 : _k.enabled) {
+                    try {
+                        this.log('info', node.id, 'AutomationSheetsNode', `Sending WhatsApp message to ${exportOptions.whatsapp.phoneNumber}...`);
+                        // Build WhatsApp message with template replacements
+                        const template = exportOptions.whatsapp.messageTemplate ||
+                            'Automation Result: {{fileName}} completed successfully. Rows processed: {{rowsAdded}}.';
+                        const contextVars = {
+                            fileName: exportOptions.fileName,
+                            rowsAdded: response === null || response === void 0 ? void 0 : response.rowsAdded,
+                            sheetName: (response === null || response === void 0 ? void 0 : response.sheetName) || ((_l = formData.sheetsConfig) === null || _l === void 0 ? void 0 : _l.sheetName),
+                            timestamp: new Date().toLocaleString(),
+                        };
+                        const messageText = template.replace(/\{\{(\w+)\}\}/g, (_, key) => key in contextVars ? String(contextVars[key]) : '');
+                        // Create WhatsApp message with execution data
+                        const whatsappMessage = `
+Automation Result:
+------------------
+${messageText}
+
+Execution Details:
+- Run ID: ${this.context.runId}
+- Start Time: ${this.context.startTime.toLocaleString()}
+- Status: Completed Successfully
+- Data: ${JSON.stringify(inputData, null, 2)}
+          `;
+                        // Check if Twilio is configured
+                        if ((_m = exportOptions.whatsapp.twilio) === null || _m === void 0 ? void 0 : _m.enabled) {
+                            // Use Twilio WhatsApp API
+                            const twilioService = new TwilioWhatsAppService({
+                                accountSid: exportOptions.whatsapp.twilio.accountSid,
+                                authToken: exportOptions.whatsapp.twilio.authToken,
+                                fromNumber: exportOptions.whatsapp.twilio.fromNumber,
+                                isSandbox: exportOptions.whatsapp.twilio.isSandbox,
+                            });
+                            // Validate Twilio configuration
+                            const validation = twilioService.validateConfig();
+                            if (!validation.valid) {
+                                throw new Error(`Twilio configuration invalid: ${validation.errors.join(', ')}`);
+                            }
+                            // Send message via Twilio
+                            const twilioResult = yield twilioService.sendMessage({
+                                to: exportOptions.whatsapp.phoneNumber,
+                                message: whatsappMessage.trim(),
+                                templateSid: exportOptions.whatsapp.twilio.templateSid,
+                                templateVariables: exportOptions.whatsapp.twilio.templateVariables,
+                            });
+                            if (twilioResult.success) {
+                                this.log('success', node.id, 'AutomationSheetsNode', `WhatsApp message sent via Twilio (SID: ${twilioResult.messageSid})`);
+                                outputStatuses.whatsapp = 'connected';
+                            }
+                            else {
+                                throw new Error(`Twilio send failed: ${twilioResult.error}`);
+                            }
+                        }
+                        else {
+                            // Fallback to WhatsApp Web (existing behavior)
+                            const encodedMsg = encodeURIComponent(whatsappMessage.trim());
+                            const whatsappUrl = `https://wa.me/${exportOptions.whatsapp.phoneNumber}?text=${encodedMsg}`;
+                            // Open WhatsApp in a new tab
+                            window.open(whatsappUrl, '_blank');
+                            this.log('success', node.id, 'AutomationSheetsNode', `WhatsApp message opened for ${exportOptions.whatsapp.phoneNumber}`);
+                            outputStatuses.whatsapp = 'connected';
+                        }
+                        data.outputStatuses = outputStatuses;
+                        if (this.onNodeUpdate)
+                            this.onNodeUpdate(node.id, data);
+                    }
+                    catch (whatsappErr) {
+                        const msg = whatsappErr instanceof Error
+                            ? whatsappErr.message
+                            : String(whatsappErr);
+                        this.log('error', node.id, 'AutomationSheetsNode', `WhatsApp send failed: ${msg}`);
+                        outputStatuses.whatsapp = 'failed';
+                        data.outputStatuses = outputStatuses;
+                        if (this.onNodeUpdate)
+                            this.onNodeUpdate(node.id, data);
+                    }
+                }
+                // Store the execution result in node data
+                this.storeExecutionResult(node.id, response, true);
+                return response;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                this.log('error', node.id, 'AutomationSheetsNode', `Google Sheets export failed: ${errorMessage}`);
+                // Mark failing outputs
+                const dataRef = node.data;
+                dataRef.outputStatuses = dataRef.outputStatuses || {};
+                // If config missing -> not-set should be turned failed on workflow failure
+                const sheetsCfg = ((_o = dataRef.formData) === null || _o === void 0 ? void 0 : _o.sheetsConfig) || dataRef.sheetsConfig || {};
+                const creds = sheetsCfg.credentials || {};
+                const gsHasRequired = Boolean((sheetsCfg.spreadsheetId || creds.clientId) &&
+                    sheetsCfg.sheetName &&
+                    creds.type);
+                dataRef.outputStatuses.googleSheets = gsHasRequired ? 'failed' : 'failed';
+                const ex = ((_p = dataRef.formData) === null || _p === void 0 ? void 0 : _p.exportOptions) || dataRef.exportOptions || {};
+                const gmHasRequired = Boolean(ex.emailSendEnabled &&
+                    ex.emailSender &&
+                    (((_q = ex.emailRecipients) === null || _q === void 0 ? void 0 : _q.length) || 0) > 0 &&
+                    ex.emailSubject &&
+                    ex.emailMessage);
+                if (ex.emailSendEnabled) {
+                    dataRef.outputStatuses.gmail = gmHasRequired ? 'failed' : 'failed';
+                }
+                const sl = ex.slack || {};
+                const slackHasRequired = Boolean(sl.enabled && sl.webhookUrl && sl.channel);
+                if (sl.enabled) {
+                    dataRef.outputStatuses.slack = slackHasRequired ? 'failed' : 'failed';
+                }
+                const wa = ex.whatsapp || {};
+                const whatsappHasRequired = Boolean(wa.enabled && wa.phoneNumber);
+                if (wa.enabled) {
+                    dataRef.outputStatuses.whatsapp = whatsappHasRequired
+                        ? 'failed'
+                        : 'failed';
+                }
+                if (this.onNodeUpdate)
+                    this.onNodeUpdate(node.id, dataRef);
+                // Store the execution result in node data
+                this.storeExecutionResult(node.id, null, false, errorMessage);
+                throw error;
+            }
+        });
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => current === null || current === void 0 ? void 0 : current[key], obj);
+    }
+    formatValueForSheets(value, dataType) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        switch (dataType) {
+            case 'string':
+                return String(value);
+            case 'number':
+                return Number(value);
+            case 'date':
+                return new Date(value).toISOString();
+            case 'boolean':
+                return Boolean(value);
+            default:
+                return String(value);
+        }
+    }
+    executeEndNode(node, inputData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = node.data;
+            const formData = (data.formData || data);
+            this.log('info', node.id, 'AutomationEndNode', 'Workflow completed successfully');
+            // Handle different output types
+            switch (formData.outputType) {
+                case 'display':
+                    this.log('info', node.id, 'AutomationEndNode', 'Output displayed in UI', inputData);
+                    break;
+                case 'store':
+                    this.log('info', node.id, 'AutomationEndNode', 'Data stored to destination', inputData);
+                    break;
+                case 'send':
+                    this.log('info', node.id, 'AutomationEndNode', 'Data sent to destination', inputData);
+                    break;
+            }
+            // Store the execution result in node data
+            this.storeExecutionResult(node.id, inputData, true);
+            return inputData;
+        });
+    }
+    executeNode(node, inputData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodeType = node.type;
+            switch (nodeType) {
+                case 'AutomationStartNode':
+                    return yield this.executeStartNode(node);
+                case 'AutomationApiNode':
+                    return yield this.executeApiNode(node);
+                case 'AutomationFormattingNode':
+                    return yield this.executeFormattingNode(node, inputData || null);
+                case 'AutomationSheetsNode':
+                    return yield this.executeSheetsNode(node, inputData || null);
+                case 'AutomationEndNode':
+                    return yield this.executeEndNode(node, inputData || null);
+                default:
+                    throw new Error(`Unknown node type: ${nodeType}`);
+            }
+        });
+    }
+    executeWorkflow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Find start node
+                const startNode = this.nodes.find((node) => node.type === 'AutomationStartNode');
+                if (!startNode) {
+                    throw new Error('No start node found in workflow');
+                }
+                this.log('info', 'workflow', 'engine', 'Starting workflow execution');
+                // Execute nodes in sequence
+                let currentNode = startNode;
+                let currentData = null;
+                const visitedNodes = new Set();
+                while (currentNode) {
+                    if (visitedNodes.has(currentNode.id)) {
+                        throw new Error(`Circular dependency detected: node ${currentNode.id} already visited`);
+                    }
+                    visitedNodes.add(currentNode.id);
+                    // Announce node execution start
+                    this.log('info', currentNode.id, String(currentNode.type || 'node'), 'Executing node...');
+                    // Update node status to running
+                    currentNode.data.status = 'Running';
+                    if (this.onNodeUpdate) {
+                        // Create new object reference so React detects the change
+                        this.onNodeUpdate(currentNode.id, Object.assign({}, currentNode.data));
+                    }
+                    try {
+                        currentData = yield this.executeNode(currentNode, currentData);
+                        currentNode.data.status = 'Completed';
+                        currentNode.data.lastRun =
+                            new Date().toISOString();
+                        if (this.onNodeUpdate) {
+                            // Create new object reference so React detects the change
+                            this.onNodeUpdate(currentNode.id, Object.assign({}, currentNode.data));
+                        }
+                    }
+                    catch (error) {
+                        currentNode.data.status = 'Error';
+                        currentNode.data.lastRun =
+                            new Date().toISOString();
+                        if (this.onNodeUpdate) {
+                            // Create new object reference so React detects the change
+                            this.onNodeUpdate(currentNode.id, Object.assign({}, currentNode.data));
+                        }
+                        throw error;
+                    }
+                    // Find next node
+                    const nextNodes = this.getNextNodes(currentNode.id);
+                    if (nextNodes.length > 0) {
+                        const next = nextNodes[0];
+                        this.log('info', next.id, String(next.type || 'node'), 'Moving to next node');
+                        currentNode = next;
+                    }
+                    else {
+                        this.log('info', 'workflow', 'engine', 'No next node. Ending.');
+                        currentNode = null;
+                    }
+                }
+                this.log('success', 'workflow', 'engine', 'Workflow execution completed successfully');
+                return {
+                    success: true,
+                    context: this.context,
+                    finalOutput: currentData,
+                };
+            }
+            catch (error) {
+                this.log('error', 'workflow', 'engine', `Workflow execution failed: ${error}`);
+                return {
+                    success: false,
+                    context: this.context,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+    }
+    getLogs() {
+        return this.context.logs;
+    }
+    getContext() {
+        return this.context;
+    }
+}
+//# sourceMappingURL=AutomationExecutionEngine.js.map