snow-flow 1.2.3 → 1.3.0

package/dist/utils/flow-structure-builder.js

@@ -0,0 +1,677 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Flow Structure Builder - ServiceNow Flow Record Utilities
+ * Converts flow JSON to proper ServiceNow records with correct sys_ids and logic chains
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_TYPE_IDS = void 0;
+exports.generateSysId = generateSysId;
+exports.generateFlowComponents = generateFlowComponents;
+exports.createActionInstances = createActionInstances;
+exports.buildLogicChain = buildLogicChain;
+exports.generateFlowXML = generateFlowXML;
+exports.validateFlowComponents = validateFlowComponents;
+exports.convertToFlowDefinition = convertToFlowDefinition;
+exports.createTestFlowComponents = createTestFlowComponents;
+exports.extractSysIds = extractSysIds;
+exports.generateFlowUpdate = generateFlowUpdate;
+const uuid_1 = require("uuid");
+/**
+ * Known ServiceNow action type sys_ids for proper flow creation
+ */
+exports.ACTION_TYPE_IDS = {
+    // Core Flow Actions
+    notification: '716281160b100300d97d8bf637673ac7',
+    approval: 'e3a61c920b200300d97d8bf637673a30',
+    script: '43c8cf0e0b200300d97d8bf637673ab4',
+    condition: 'a6e0f8890b200300d97d8bf637673a4a',
+    create_record: '7b8cf0e20b200300d97d8bf637673a50',
+    update_record: '8c9d0f230b200300d97d8bf637673a60',
+    ask_for_approval: 'e3a61c920b200300d97d8bf637673a30',
+    send_email: '716281160b100300d97d8bf637673ac7',
+    // Integration Actions
+    rest_step: 'f4b5c6d70b200300d97d8bf637673a80',
+    web_service: 'a5b6c7d80b200300d97d8bf637673a90',
+    // Utility Actions
+    wait: '9e0f1a2b0b200300d97d8bf637673aa0',
+    log: '0f1a2b3c0b200300d97d8bf637673ab0',
+    set_variable: '1a2b3c4d0b200300d97d8bf637673ac0',
+    // Default fallback
+    default: '43c8cf0e0b200300d97d8bf637673ab4' // script action
+};
+/**
+ * Generate a ServiceNow-compatible sys_id
+ */
+function generateSysId() {
+    return (0, uuid_1.v4)().replace(/-/g, '');
+}
+/**
+ * Generate ServiceNow flow components from flow definition
+ * Converts flow JSON to proper ServiceNow records with all required components
+ */
+function generateFlowComponents(flowDefinition, flowSysId) {
+    const flowId = flowSysId || generateSysId();
+    console.log('🏗️ Generating ServiceNow flow components...');
+    console.log(`📋 Flow: ${flowDefinition.name}`);
+    console.log(`🆔 Flow sys_id: ${flowId}`);
+    // 1. Create main flow record
+    const flowRecord = {
+        sys_id: flowId,
+        name: flowDefinition.name,
+        description: flowDefinition.description,
+        internal_name: sanitizeInternalName(flowDefinition.name),
+        type: 'flow',
+        status: 'published',
+        active: true,
+        run_as: 'system',
+        sys_class_name: 'sys_hub_flow',
+        table: flowDefinition.table,
+        category: 'custom',
+        flow_definition: JSON.stringify({
+            name: flowDefinition.name,
+            description: flowDefinition.description,
+            trigger: flowDefinition.trigger,
+            activities: flowDefinition.activities,
+            variables: flowDefinition.variables,
+            connections: flowDefinition.connections
+        })
+    };
+    // 2. Create trigger instance
+    const triggerInstance = createTriggerInstance(flowId, flowDefinition.trigger);
+    // 3. Create action instances for each activity
+    const actionInstances = createActionInstances(flowDefinition.activities, flowId);
+    // 4. Build logic chain (connections between components)
+    const logicChain = buildLogicChain(flowDefinition.activities, triggerInstance, actionInstances);
+    // 5. Create flow variables
+    const variables = createFlowVariables(flowDefinition.variables, flowId);
+    // 6. Create connections for visual flow representation
+    const connections = createFlowConnections(flowDefinition.connections, logicChain);
+    console.log(`✅ Generated components:`);
+    console.log(`  • Flow record: ${flowRecord.sys_id}`);
+    console.log(`  • Trigger: ${triggerInstance.sys_id}`);
+    console.log(`  • Actions: ${actionInstances.length}`);
+    console.log(`  • Logic chain: ${logicChain.length} entries`);
+    console.log(`  • Variables: ${variables.length}`);
+    console.log(`  • Connections: ${connections.length}`);
+    return {
+        flowRecord,
+        triggerInstance,
+        actionInstances,
+        logicChain,
+        variables,
+        connections
+    };
+}
+/**
+ * Create trigger instance record
+ */
+function createTriggerInstance(flowId, trigger) {
+    const triggerSysId = generateSysId();
+    return {
+        sys_id: triggerSysId,
+        flow: flowId,
+        name: `${trigger.type}_trigger`,
+        type: trigger.type,
+        table: trigger.table,
+        condition: trigger.condition || '',
+        active: true,
+        order: 0,
+        sys_class_name: 'sys_hub_trigger_instance',
+        // Additional fields for proper trigger configuration
+        trigger_type: trigger.type,
+        trigger_table: trigger.table,
+        filter: trigger.condition || '',
+        when: getTriggerWhen(trigger.type)
+    };
+}
+/**
+ * Create action instances for all activities
+ */
+function createActionInstances(activities, flowSysId) {
+    console.log(`🔧 Creating ${activities.length} action instances...`);
+    return activities.map((activity, index) => {
+        const actionSysId = generateSysId();
+        const actionTypeId = getActionTypeId(activity.type);
+        console.log(`  • ${activity.name} (${activity.type}) → ${actionSysId}`);
+        return {
+            sys_id: actionSysId,
+            flow: flowSysId,
+            name: activity.name,
+            label: activity.name,
+            action_type: actionTypeId,
+            order: (index + 1) * 100, // ServiceNow uses 100-based ordering
+            active: true,
+            sys_class_name: 'sys_hub_action_instance',
+            // Activity-specific configuration
+            inputs: JSON.stringify(activity.inputs || {}),
+            outputs: JSON.stringify(activity.outputs || {}),
+            condition: activity.condition || '',
+            // Reference fields
+            artifact_reference: activity.artifact_reference || '',
+            subflow_reference: activity.subflow_reference || '',
+            // Position for Flow Designer visual representation
+            x: 100 + (index * 200), // Horizontal spacing
+            y: 200, // Vertical position
+            // Additional ServiceNow fields
+            description: `${activity.type} action: ${activity.name}`,
+            configuration: JSON.stringify(buildActionConfiguration(activity))
+        };
+    });
+}
+/**
+ * Build logic chain connecting trigger → actions → end
+ * Creates sys_hub_flow_logic records for proper flow execution
+ */
+function buildLogicChain(activities, triggerInstance, actionInstances) {
+    console.log('🔗 Building logic chain...');
+    const logicChain = [];
+    // 1. Connect trigger to first action (or end if no actions)
+    if (actionInstances.length > 0) {
+        logicChain.push(createLogicEntry(triggerInstance.sys_id, actionInstances[0].sys_id, triggerInstance.flow, 'trigger_to_first_action', 0));
+        console.log(`  • Trigger → ${actionInstances[0].name}`);
+    }
+    else {
+        // Direct trigger to end
+        logicChain.push(createLogicEntry(triggerInstance.sys_id, 'END', triggerInstance.flow, 'trigger_to_end', 0));
+        console.log(`  • Trigger → END (no actions)`);
+    }
+    // 2. Connect actions in sequence
+    for (let i = 0; i < actionInstances.length - 1; i++) {
+        const currentAction = actionInstances[i];
+        const nextAction = actionInstances[i + 1];
+        logicChain.push(createLogicEntry(currentAction.sys_id, nextAction.sys_id, triggerInstance.flow, `action_${i}_to_action_${i + 1}`, i + 1));
+        console.log(`  • ${currentAction.name} → ${nextAction.name}`);
+    }
+    // 3. Connect last action to end
+    if (actionInstances.length > 0) {
+        const lastAction = actionInstances[actionInstances.length - 1];
+        logicChain.push(createLogicEntry(lastAction.sys_id, 'END', triggerInstance.flow, 'last_action_to_end', actionInstances.length));
+        console.log(`  • ${lastAction.name} → END`);
+    }
+    console.log(`✅ Built logic chain with ${logicChain.length} connections`);
+    return logicChain;
+}
+/**
+ * Create a single logic entry (sys_hub_flow_logic record)
+ */
+function createLogicEntry(fromSysId, toSysId, flowId, name, order) {
+    return {
+        sys_id: generateSysId(),
+        flow: flowId,
+        name: name,
+        from_element: fromSysId,
+        to_element: toSysId === 'END' ? '' : toSysId,
+        order: order * 100,
+        active: true,
+        sys_class_name: 'sys_hub_flow_logic',
+        // Visual positioning for Flow Designer
+        from_x: 100 + (order * 200),
+        from_y: 200,
+        to_x: toSysId === 'END' ? 100 + ((order + 1) * 200) : 100 + ((order + 1) * 200),
+        to_y: 200,
+        // Connection properties
+        condition: '',
+        label: '',
+        connection_type: 'sequence'
+    };
+}
+/**
+ * Create flow variables from variable definitions
+ */
+function createFlowVariables(variables, flowId) {
+    return variables.map((variable, index) => ({
+        sys_id: generateSysId(),
+        flow: flowId,
+        name: variable.name || variable.id,
+        label: variable.label || variable.name || variable.id,
+        type: variable.type || 'string',
+        input: variable.input || false,
+        output: variable.output || false,
+        default_value: variable.default_value || '',
+        description: variable.description || '',
+        order: index * 100,
+        sys_class_name: 'sys_hub_flow_variable'
+    }));
+}
+/**
+ * Create visual connections for Flow Designer
+ */
+function createFlowConnections(connections, logicChain) {
+    // The logic chain already handles the actual execution flow
+    // This creates additional visual connections if specified
+    return connections.map((connection, index) => ({
+        sys_id: generateSysId(),
+        name: connection.name || `connection_${index}`,
+        from: connection.from,
+        to: connection.to,
+        condition: connection.condition || 'always',
+        label: connection.label || '',
+        sys_class_name: 'sys_hub_flow_connection'
+    }));
+}
+/**
+ * Get the correct action type sys_id for an activity type
+ */
+function getActionTypeId(activityType) {
+    const normalizedType = activityType.toLowerCase().replace(/[^a-z_]/g, '_');
+    // Direct mapping
+    if (exports.ACTION_TYPE_IDS[normalizedType]) {
+        return exports.ACTION_TYPE_IDS[normalizedType];
+    }
+    // Fuzzy matching for common variations
+    if (normalizedType.includes('email') || normalizedType.includes('mail')) {
+        return exports.ACTION_TYPE_IDS.notification;
+    }
+    if (normalizedType.includes('approval') || normalizedType.includes('approve')) {
+        return exports.ACTION_TYPE_IDS.approval;
+    }
+    if (normalizedType.includes('script') || normalizedType.includes('code')) {
+        return exports.ACTION_TYPE_IDS.script;
+    }
+    if (normalizedType.includes('condition') || normalizedType.includes('if')) {
+        return exports.ACTION_TYPE_IDS.condition;
+    }
+    if (normalizedType.includes('create') && normalizedType.includes('record')) {
+        return exports.ACTION_TYPE_IDS.create_record;
+    }
+    if (normalizedType.includes('update') && normalizedType.includes('record')) {
+        return exports.ACTION_TYPE_IDS.update_record;
+    }
+    if (normalizedType.includes('rest') || normalizedType.includes('api')) {
+        return exports.ACTION_TYPE_IDS.rest_step;
+    }
+    if (normalizedType.includes('wait') || normalizedType.includes('delay')) {
+        return exports.ACTION_TYPE_IDS.wait;
+    }
+    if (normalizedType.includes('log')) {
+        return exports.ACTION_TYPE_IDS.log;
+    }
+    // Default to script action
+    console.warn(`⚠️ Unknown action type "${activityType}", using script action as fallback`);
+    return exports.ACTION_TYPE_IDS.default;
+}
+/**
+ * Get trigger when condition based on trigger type
+ */
+function getTriggerWhen(triggerType) {
+    switch (triggerType.toLowerCase()) {
+        case 'record_created':
+        case 'created':
+            return 'after';
+        case 'record_updated':
+        case 'updated':
+            return 'after';
+        case 'record_deleted':
+        case 'deleted':
+            return 'after';
+        case 'before_insert':
+            return 'before';
+        case 'before_update':
+            return 'before';
+        case 'before_delete':
+            return 'before';
+        case 'scheduled':
+            return 'scheduled';
+        case 'manual':
+        default:
+            return 'manual';
+    }
+}
+/**
+ * Build action-specific configuration
+ */
+function buildActionConfiguration(activity) {
+    const config = {
+        action_type: activity.type,
+        name: activity.name
+    };
+    // Add type-specific configuration
+    switch (activity.type.toLowerCase()) {
+        case 'notification':
+        case 'send_email':
+            config.recipient = activity.inputs?.recipient || '';
+            config.subject = activity.inputs?.subject || '';
+            config.message = activity.inputs?.message || activity.inputs?.body || '';
+            break;
+        case 'approval':
+        case 'ask_for_approval':
+            config.approver = activity.inputs?.approver || '';
+            config.approval_message = activity.inputs?.message || '';
+            config.due_date = activity.inputs?.due_date || '';
+            break;
+        case 'script':
+            config.script = activity.inputs?.script || '';
+            break;
+        case 'condition':
+            config.condition = activity.condition || activity.inputs?.condition || '';
+            break;
+        case 'create_record':
+            config.table = activity.inputs?.table || '';
+            config.fields = activity.inputs?.fields || {};
+            break;
+        case 'update_record':
+            config.table = activity.inputs?.table || '';
+            config.sys_id = activity.inputs?.sys_id || '';
+            config.fields = activity.inputs?.fields || {};
+            break;
+        default:
+            // Include all inputs as configuration
+            config.inputs = activity.inputs || {};
+    }
+    return config;
+}
+/**
+ * Sanitize flow name for ServiceNow internal_name field
+ */
+function sanitizeInternalName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9_\s]/g, '') // Remove special characters except underscores and spaces
+        .replace(/\s+/g, '_') // Replace spaces with underscores
+        .replace(/_+/g, '_') // Replace multiple underscores with single
+        .replace(/^_|_$/g, '') // Remove leading/trailing underscores
+        .substring(0, 80); // Limit length to 80 characters
+}
+/**
+ * Convert flow definition to ServiceNow Update XML format
+ * Enhanced with modern flow structure support and better validation
+ */
+function generateFlowXML(components, options = {}) {
+    const { includeMetadata = true, validateBeforeExport = true, compactFormat = false } = options;
+    // Validate components before generating XML
+    if (validateBeforeExport) {
+        const validation = validateFlowComponents(components);
+        if (!validation.isValid) {
+            throw new Error(`Flow validation failed: ${validation.errors.join(', ')}`);
+        }
+    }
+    const xml = [];
+    const indent = compactFormat ? '' : '  ';
+    const newline = compactFormat ? '' : '\n';
+    xml.push('<?xml version="1.0" encoding="UTF-8"?>');
+    // Add metadata if requested
+    if (includeMetadata) {
+        xml.push(`<!-- Generated by Snow-Flow at ${new Date().toISOString()} -->`);
+        xml.push(`<!-- Flow: ${components.flowRecord.name || 'Unknown'} -->`);
+        xml.push(`<!-- Actions: ${components.actionInstances.length} -->`);
+        xml.push(`<!-- Variables: ${components.variables.length} -->`);
+    }
+    xml.push('<unload unload_date="' + new Date().toISOString() + '">');
+    // Flow record with enhanced fields
+    xml.push(`${indent}<sys_hub_flow action="INSERT_OR_UPDATE">`);
+    Object.entries(components.flowRecord).forEach(([key, value]) => {
+        // Ensure critical fields are properly set
+        let processedValue = value;
+        if (key === 'active' && typeof value !== 'boolean') {
+            processedValue = value === 'true' || value === true;
+        }
+        if (key === 'validated' && typeof value !== 'boolean') {
+            processedValue = value === 'true' || value === true;
+        }
+        xml.push(`${indent}${indent}<${key}>${escapeXML(String(processedValue))}</${key}>`);
+    });
+    xml.push(`${indent}</sys_hub_flow>`);
+    // Enhanced trigger instance with validation
+    if (components.triggerInstance && Object.keys(components.triggerInstance).length > 0) {
+        xml.push(`${indent}<sys_hub_trigger_instance action="INSERT_OR_UPDATE">`);
+        Object.entries(components.triggerInstance).forEach(([key, value]) => {
+            xml.push(`${indent}${indent}<${key}>${escapeXML(String(value))}</${key}>`);
+        });
+        xml.push(`${indent}</sys_hub_trigger_instance>`);
+    }
+    // Action instances with proper ordering
+    components.actionInstances
+        .sort((a, b) => (a.order || 0) - (b.order || 0)) // Ensure proper order
+        .forEach(action => {
+        xml.push(`${indent}<sys_hub_action_instance action="INSERT_OR_UPDATE">`);
+        Object.entries(action).forEach(([key, value]) => {
+            xml.push(`${indent}${indent}<${key}>${escapeXML(String(value))}</${key}>`);
+        });
+        xml.push(`${indent}</sys_hub_action_instance>`);
+    });
+    // Logic chain with connection validation
+    components.logicChain
+        .sort((a, b) => (a.order || 0) - (b.order || 0)) // Ensure proper flow
+        .forEach(logic => {
+        xml.push(`${indent}<sys_hub_flow_logic action="INSERT_OR_UPDATE">`);
+        Object.entries(logic).forEach(([key, value]) => {
+            xml.push(`${indent}${indent}<${key}>${escapeXML(String(value))}</${key}>`);
+        });
+        xml.push(`${indent}</sys_hub_flow_logic>`);
+    });
+    // Variables with type validation
+    components.variables.forEach(variable => {
+        xml.push(`${indent}<sys_hub_flow_variable action="INSERT_OR_UPDATE">`);
+        Object.entries(variable).forEach(([key, value]) => {
+            xml.push(`${indent}${indent}<${key}>${escapeXML(String(value))}</${key}>`);
+        });
+        xml.push(`${indent}</sys_hub_flow_variable>`);
+    });
+    // Include connections if available (for modern flows)
+    if (components.connections && components.connections.length > 0) {
+        components.connections.forEach(connection => {
+            xml.push(`${indent}<sys_hub_flow_connection action="INSERT_OR_UPDATE">`);
+            Object.entries(connection).forEach(([key, value]) => {
+                xml.push(`${indent}${indent}<${key}>${escapeXML(String(value))}</${key}>`);
+            });
+            xml.push(`${indent}</sys_hub_flow_connection>`);
+        });
+    }
+    xml.push('</unload>');
+    return xml.join(newline + (compactFormat ? '' : newline));
+}
+/**
+ * Escape XML special characters
+ */
+function escapeXML(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * Validate flow components before deployment
+ */
+function validateFlowComponents(components) {
+    const errors = [];
+    const warnings = [];
+    // Validate flow record
+    if (!components.flowRecord.name) {
+        errors.push('Flow record missing required name field');
+    }
+    if (!components.flowRecord.sys_id) {
+        errors.push('Flow record missing sys_id');
+    }
+    // Validate trigger
+    if (!components.triggerInstance.sys_id) {
+        errors.push('Trigger instance missing sys_id');
+    }
+    if (!components.triggerInstance.flow) {
+        errors.push('Trigger instance not linked to flow');
+    }
+    // Validate actions
+    components.actionInstances.forEach((action, index) => {
+        if (!action.sys_id) {
+            errors.push(`Action ${index} missing sys_id`);
+        }
+        if (!action.flow) {
+            errors.push(`Action ${index} not linked to flow`);
+        }
+        if (!action.action_type) {
+            errors.push(`Action ${index} missing action_type`);
+        }
+    });
+    // Validate logic chain
+    if (components.logicChain.length === 0 && components.actionInstances.length > 0) {
+        warnings.push('No logic chain defined for flow with actions');
+    }
+    // Check for orphaned components
+    const flowId = components.flowRecord.sys_id;
+    const orphanedActions = components.actionInstances.filter(a => a.flow !== flowId);
+    if (orphanedActions.length > 0) {
+        errors.push(`${orphanedActions.length} actions not properly linked to flow`);
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings
+    };
+}
+/**
+ * Convert legacy flow format to FlowDefinition
+ * Handles various input formats from existing flow creation systems
+ */
+function convertToFlowDefinition(flow) {
+    // Extract activities from various possible sources
+    const activities = flow.activities || flow.actions || flow.steps || [];
+    // Normalize trigger format
+    const trigger = {
+        type: flow.trigger_type || flow.trigger?.type || 'manual',
+        table: flow.trigger?.table || flow.table || 'incident',
+        condition: flow.trigger?.condition || flow.condition || flow.trigger_condition || ''
+    };
+    // Normalize activities format
+    const normalizedActivities = activities.map((activity, index) => ({
+        id: activity.id || `activity_${index}`,
+        name: activity.name || activity.label || `Activity ${index + 1}`,
+        type: activity.type || activity.action_type || 'script',
+        inputs: activity.inputs || activity.config || {},
+        outputs: activity.outputs || {},
+        condition: activity.condition || '',
+        artifact_reference: activity.artifact_reference || activity.artifact,
+        subflow_reference: activity.subflow_reference || activity.subflow
+    }));
+    // Extract variables from various sources
+    let variables = flow.variables || [];
+    // Add inputs as variables
+    if (flow.inputs && Array.isArray(flow.inputs)) {
+        const inputVars = flow.inputs.map((input, index) => ({
+            id: input.id || input.name || `input_${index}`,
+            name: input.name || input.id || `input_${index}`,
+            type: input.type || 'string',
+            input: true,
+            output: false,
+            default_value: input.default_value || input.defaultValue || '',
+            description: input.description || ''
+        }));
+        variables = variables.concat(inputVars);
+    }
+    // Add outputs as variables
+    if (flow.outputs && Array.isArray(flow.outputs)) {
+        const outputVars = flow.outputs.map((output, index) => ({
+            id: output.id || output.name || `output_${index}`,
+            name: output.name || output.id || `output_${index}`,
+            type: output.type || 'string',
+            input: false,
+            output: true,
+            default_value: output.default_value || output.defaultValue || '',
+            description: output.description || ''
+        }));
+        variables = variables.concat(outputVars);
+    }
+    return {
+        name: flow.name || 'Untitled Flow',
+        description: flow.description || flow.name || 'Generated flow',
+        table: trigger.table,
+        trigger,
+        activities: normalizedActivities,
+        variables,
+        connections: flow.connections || [],
+        error_handling: flow.error_handling || []
+    };
+}
+/**
+ * Create flow components for testing/validation purposes
+ * Generates minimal valid flow structure for testing
+ */
+function createTestFlowComponents(name = 'Test Flow') {
+    const testFlow = {
+        name,
+        description: `Test flow: ${name}`,
+        table: 'incident',
+        trigger: {
+            type: 'manual',
+            table: 'incident',
+            condition: ''
+        },
+        activities: [
+            {
+                id: 'log_action',
+                name: 'Log Message',
+                type: 'script',
+                inputs: {
+                    script: `gs.info('Test flow ${name} executed successfully');`
+                },
+                outputs: {
+                    result: 'string'
+                }
+            }
+        ],
+        variables: [
+            {
+                id: 'test_var',
+                name: 'Test Variable',
+                type: 'string',
+                input: true,
+                output: false,
+                default_value: 'test_value'
+            }
+        ],
+        connections: [],
+        error_handling: []
+    };
+    return generateFlowComponents(testFlow);
+}
+/**
+ * Utility to extract sys_ids from existing ServiceNow records for update operations
+ */
+function extractSysIds(existingFlow) {
+    const sysIds = {};
+    if (existingFlow.sys_id) {
+        sysIds.flow = existingFlow.sys_id;
+    }
+    if (existingFlow.trigger_instance?.sys_id) {
+        sysIds.trigger = existingFlow.trigger_instance.sys_id;
+    }
+    if (existingFlow.action_instances && Array.isArray(existingFlow.action_instances)) {
+        existingFlow.action_instances.forEach((action, index) => {
+            if (action.sys_id) {
+                sysIds[`action_${index}`] = action.sys_id;
+            }
+        });
+    }
+    return sysIds;
+}
+/**
+ * Generate flow update payload for modifying existing flows
+ */
+function generateFlowUpdate(flowDefinition, existingSysIds) {
+    const components = generateFlowComponents(flowDefinition, existingSysIds.flow);
+    // Replace generated sys_ids with existing ones where available
+    if (existingSysIds.trigger) {
+        components.triggerInstance.sys_id = existingSysIds.trigger;
+    }
+    components.actionInstances.forEach((action, index) => {
+        const existingId = existingSysIds[`action_${index}`];
+        if (existingId) {
+            action.sys_id = existingId;
+        }
+    });
+    return components;
+}
+exports.default = {
+    generateFlowComponents,
+    createActionInstances,
+    buildLogicChain,
+    generateSysId,
+    validateFlowComponents,
+    generateFlowXML,
+    convertToFlowDefinition,
+    createTestFlowComponents,
+    extractSysIds,
+    generateFlowUpdate,
+    ACTION_TYPE_IDS: exports.ACTION_TYPE_IDS
+};