windmill-components 1.394.8 → 1.405.5

package/package/components/graph/graphBuilder.js

@@ -2,335 +2,400 @@ import {} from '@xyflow/svelte';
 import { getDependeeAndDependentComponents } from '../flows/flowExplorer';
 import { dfsByModule } from '../flows/previousResults';
 import { defaultIfEmptyString } from '../../utils';
-export default function graphBuilder(modules, extra, failureModule, eventHandlers, success, useDataflow, selectedId, moving) {
+export default function graphBuilder(modules, extra, failureModule, preprocessorModule, eventHandlers, success, useDataflow, selectedId, moving) {
     const nodes = [];
     const edges = [];
-    if (!modules) {
-        return { nodes, edges };
-    }
-    function addNode(module, offset, type, subModules) {
-        nodes.push({
-            id: module.id,
+    try {
+        if (!modules) {
+            return { nodes, edges };
+        }
+        function addNode(module, offset, type, subModules) {
+            if (nodes.some((n) => n.id === module.id)) {
+                throw new Error(`Duplicated node detected: ${module.id}`);
+            }
+            nodes.push({
+                id: module.id,
+                data: {
+                    value: module.value,
+                    offset: offset,
+                    module: module,
+                    modules: subModules ?? modules,
+                    parentIds: [],
+                    eventHandlers: eventHandlers,
+                    moving: moving,
+                    ...extra
+                },
+                position: { x: -1, y: -1 },
+                type: type
+            });
+            return module.id;
+        }
+        const parents = {};
+        //
+        function detectCycle(nodeId, visited, currentPath) {
+            // If the node hasn't been visited yet
+            if (!visited.has(nodeId)) {
+                visited.add(nodeId);
+                currentPath.add(nodeId);
+                // If the current node has parent nodes
+                if (parents[nodeId]) {
+                    // Check each parent node
+                    // Nodes can have multiple parents: the node that gathers the result for branches or loops for instance
+                    for (const parentNode of parents[nodeId]) {
+                        // If the parentNode hasn't been visited and a cycle is detected in its path
+                        if (!visited.has(parentNode) && detectCycle(parentNode, visited, currentPath)) {
+                            return true; // Cycle detected
+                        }
+                        // If the parentNode is already in the current path, it's a cycle
+                        else if (currentPath.has(parentNode)) {
+                            return true; // Cycle detected
+                        }
+                    }
+                }
+            }
+            // Remove the node from the current path as we're done processing it
+            currentPath.delete(nodeId);
+            // No cycle detected for this path
+            return false;
+        }
+        function addEdge(sourceId, targetId, options) {
+            parents[targetId] = [...(parents[targetId] ?? []), sourceId];
+            const mods = options?.subModules ?? modules;
+            let index = mods?.findIndex((m) => m.id === targetId) ?? -1;
+            const visited = new Set();
+            const recStack = new Set();
+            if (detectCycle(sourceId, visited, recStack)) {
+                throw new Error(`Cycle detected: adding edge from '${sourceId}' to '${targetId}' would create a cycle.`);
+            }
+            edges.push({
+                id: options?.customId || `edge:${sourceId}->${targetId}`,
+                source: sourceId,
+                target: targetId,
+                type: options?.type ?? 'edge',
+                data: {
+                    insertable: extra.insertable,
+                    modules: options?.subModules ?? modules,
+                    sourceId,
+                    targetId,
+                    moving,
+                    eventHandlers,
+                    disableMoveIds: options?.disableMoveIds,
+                    enableTrigger: sourceId === 'Input',
+                    // If the index is -1, it means that the target module is not in the modules array, so we set it to the length of the array
+                    index: index >= 0 ? index : mods?.length ?? 0,
+                    ...extra
+                }
+            });
+        }
+        const inputNode = {
+            id: 'Input',
+            position: { x: -1, y: -1 },
+            type: 'input2',
             data: {
-                value: module.value,
-                offset: offset,
-                module: module,
-                modules: subModules ?? modules,
-                parentIds: [],
                 eventHandlers: eventHandlers,
-                moving: moving,
+                modules: modules,
+                hasPreprocessor: !!preprocessorModule,
                 ...extra
-            },
-            position: { x: -1, y: -1 },
-            type: type
-        });
-        return module.id;
-    }
-    const parents = {};
-    function addEdge(sourceId, targetId, options) {
-        parents[targetId] = [...(parents[targetId] ?? []), sourceId];
-        // Find the index of the target module in the modules array
-        const mods = options?.subModules ?? modules;
-        // Index of the target module in the modules array
-        let index = mods?.findIndex((m) => m.id === targetId) ?? -1;
-        edges.push({
-            id: options?.customId || `edge:${sourceId}->${targetId}`,
-            source: sourceId,
-            target: targetId,
-            type: options?.type ?? 'edge',
+            }
+        };
+        const resultNode = {
+            id: 'result',
             data: {
-                insertable: extra.insertable,
-                modules: options?.subModules ?? modules,
-                sourceId,
-                targetId,
-                moving,
-                eventHandlers,
-                disableMoveIds: options?.disableMoveIds,
-                enableTrigger: sourceId === 'Input',
-                // If the index is -1, it means that the target module is not in the modules array, so we set it to the length of the array
-                index: index >= 0 ? index : mods?.length ?? 0,
+                eventHandlers: eventHandlers,
+                modules: modules,
+                success: success,
                 ...extra
+            },
+            position: { x: -1, y: -1 },
+            type: 'result'
+        };
+        nodes.push(inputNode);
+        nodes.push(resultNode);
+        function processModules(modules, beforeNode, nextNode, currentOffset = 0, disableMoveIds = [], parentIndex) {
+            let previousId = undefined;
+            if (modules.length === 0) {
+                addEdge(beforeNode.id, nextNode.id, {
+                    subModules: modules,
+                    disableMoveIds
+                });
             }
-        });
-    }
-    const inputNode = {
-        id: 'Input',
-        position: { x: -1, y: -1 },
-        type: 'input2',
-        data: {
-            eventHandlers: eventHandlers,
-            modules: modules,
-            ...extra
-        }
-    };
-    const resultNode = {
-        id: 'result',
-        data: {
-            eventHandlers: eventHandlers,
-            modules: modules,
-            success: success,
-            ...extra
-        },
-        position: { x: -1, y: -1 },
-        type: 'result'
-    };
-    nodes.push(inputNode);
-    nodes.push(resultNode);
-    function processModules(modules, beforeNode, nextNode, currentOffset = 0, disableMoveIds = []) {
-        let previousId = undefined;
-        if (modules.length === 0) {
-            addEdge(beforeNode.id, nextNode.id, {
-                subModules: modules,
-                disableMoveIds
-            });
-        }
-        else {
-            modules.forEach((module, index) => {
-                const localDisableMoveIds = [...disableMoveIds, module.id];
-                // Add the edge between the previous node and the current one
-                if (index > 0 && previousId) {
-                    addEdge(previousId, module.id, {
-                        subModules: modules,
-                        disableMoveIds
-                    });
-                }
-                if (module.value.type === 'branchall') {
-                    // Start
-                    addNode(module, currentOffset, 'module', modules);
-                    // "Collect result of each branch" node
-                    const endNode = {
-                        id: `${module.id}-end`,
-                        data: {
-                            offset: currentOffset,
-                            id: module.id,
-                            module: module,
-                            modules: modules,
-                            ...extra
-                        },
-                        position: { x: -1, y: -1 },
-                        type: 'branchAllEnd'
-                    };
-                    nodes.push(endNode);
-                    if (module.value.branches.length === 0) {
-                        // Add a "No branches" node
-                        const startNode = {
-                            id: `${module.id}-branch-0`,
+            else {
+                modules.forEach((module, index) => {
+                    const localDisableMoveIds = [...disableMoveIds, module.id];
+                    // Add the edge between the previous node and the current one
+                    if (index > 0 && previousId) {
+                        addEdge(previousId, module.id, {
+                            subModules: modules,
+                            disableMoveIds
+                        });
+                    }
+                    if (module.value.type === 'branchall') {
+                        // Start
+                        addNode(module, currentOffset, 'module', modules);
+                        // "Collect result of each branch" node
+                        const endNode = {
+                            id: `${module.id}-end`,
                             data: {
                                 offset: currentOffset,
                                 id: module.id,
-                                branchIndex: -1,
+                                module: module,
                                 modules: modules,
-                                eventHandlers: eventHandlers,
                                 ...extra
                             },
                             position: { x: -1, y: -1 },
-                            type: 'noBranch'
+                            type: 'branchAllEnd'
                         };
-                        nodes.push(startNode);
-                        addEdge(module.id, startNode.id, {
-                            type: 'empty'
-                        });
-                        addEdge(startNode.id, endNode.id, {
-                            type: 'empty'
-                        });
-                    }
-                    else {
-                        module.value.branches.forEach((branch, branchIndex) => {
-                            // Start node by branch
+                        nodes.push(endNode);
+                        if (module.value.branches.length === 0) {
+                            // Add a "No branches" node
                             const startNode = {
-                                id: `${module.id}-branch-${branchIndex}`,
+                                id: `${module.id}-branch-0`,
                                 data: {
                                     offset: currentOffset,
-                                    label: defaultIfEmptyString(branch.summary, `Branch ${branchIndex + 1}`),
                                     id: module.id,
-                                    branchIndex: branchIndex,
+                                    branchIndex: -1,
                                     modules: modules,
                                     eventHandlers: eventHandlers,
                                     ...extra
                                 },
                                 position: { x: -1, y: -1 },
-                                type: 'branchAllStart'
+                                type: 'noBranch'
                             };
                             nodes.push(startNode);
                             addEdge(module.id, startNode.id, {
                                 type: 'empty'
                             });
-                            processModules(branch.modules, startNode, endNode, currentOffset, localDisableMoveIds);
-                        });
+                            addEdge(startNode.id, endNode.id, {
+                                type: 'empty'
+                            });
+                        }
+                        else {
+                            module.value.branches.forEach((branch, branchIndex) => {
+                                // Start node by branch
+                                const startNode = {
+                                    id: `${module.id}-branch-${branchIndex}`,
+                                    data: {
+                                        offset: currentOffset,
+                                        label: defaultIfEmptyString(branch.summary, `Branch ${branchIndex + 1}`),
+                                        id: module.id,
+                                        branchIndex: branchIndex,
+                                        modules: modules,
+                                        eventHandlers: eventHandlers,
+                                        ...extra
+                                    },
+                                    position: { x: -1, y: -1 },
+                                    type: 'branchAllStart'
+                                };
+                                nodes.push(startNode);
+                                addEdge(module.id, startNode.id, {
+                                    type: 'empty'
+                                });
+                                processModules(branch.modules, startNode, endNode, currentOffset, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}-${branchIndex}` : `${index}-${branchIndex}`);
+                            });
+                        }
+                        previousId = endNode.id;
                     }
-                    previousId = endNode.id;
-                }
-                else if (module.value.type === 'forloopflow') {
-                    addNode(module, currentOffset, 'module', modules);
-                    const startNode = {
-                        id: `${module.id}-start`,
-                        data: {
-                            offset: currentOffset + 25,
-                            id: module.id,
-                            module: module,
-                            modules: modules,
-                            eventHandlers: eventHandlers,
-                            ...extra
-                        },
-                        position: { x: -1, y: -1 },
-                        type: 'forLoopStart'
-                    };
-                    addEdge(module.id, startNode.id, {
-                        type: 'empty'
-                    });
-                    const endNode = {
-                        id: `${module.id}-end`,
-                        data: {
-                            offset: currentOffset,
-                            id: module.id,
-                            module: module,
-                            modules: modules,
-                            eventHandlers: eventHandlers,
-                            ...extra
-                        },
-                        position: { x: -1, y: -1 },
-                        type: 'forLoopEnd'
-                    };
-                    nodes.push(startNode);
-                    nodes.push(endNode);
-                    processModules(module.value.modules, startNode, endNode, currentOffset + 25, localDisableMoveIds);
-                    previousId = endNode.id;
-                }
-                else if (module.value.type === 'whileloopflow') {
-                    addNode(module, currentOffset, 'module', modules);
-                    const startNode = {
-                        id: `${module.id}-start`,
-                        data: {
-                            offset: currentOffset + 25,
-                            module: module,
-                            modules: modules,
-                            eventHandlers: eventHandlers,
-                            ...extra
-                        },
-                        position: { x: -1, y: -1 },
-                        type: 'whileLoopStart'
-                    };
-                    addEdge(module.id, startNode.id, {
-                        type: 'empty'
-                    });
-                    const endNode = {
-                        id: `${module.id}-end`,
-                        data: { offset: currentOffset, module: module, modules: modules, ...extra },
-                        position: { x: -1, y: -1 },
-                        type: 'whileLoopEnd'
-                    };
-                    nodes.push(startNode);
-                    nodes.push(endNode);
-                    processModules(module.value.modules, startNode, endNode, currentOffset + 25, localDisableMoveIds);
-                    previousId = endNode.id;
-                }
-                else if (module.value.type === 'branchone') {
-                    addNode(module, currentOffset, 'module', modules);
-                    const endNode = {
-                        id: `${module.id}-end`,
-                        data: { offset: currentOffset, eventHandlers: eventHandlers },
-                        position: { x: -1, y: -1 },
-                        type: 'branchOneEnd'
-                    };
-                    nodes.push(endNode);
-                    // Add default branch
-                    const defaultBranch = {
-                        id: `${module.id}-default`,
-                        data: {
-                            offset: currentOffset,
-                            label: 'Default',
-                            id: module.id,
-                            branchIndex: -1,
-                            modules: module.value.default,
-                            eventHandlers: eventHandlers,
-                            branchOne: true,
-                            ...extra
-                        },
-                        position: { x: -1, y: -1 },
-                        type: 'noBranch'
-                    };
-                    nodes.push(defaultBranch);
-                    addEdge(module.id, defaultBranch.id, { type: 'empty' });
-                    processModules(module.value.default, defaultBranch, endNode, currentOffset, localDisableMoveIds);
-                    module.value.branches.forEach((branch, branchIndex) => {
-                        // Start node by branch
+                    else if (module.value.type === 'forloopflow') {
+                        addNode(module, currentOffset, 'module', modules);
                         const startNode = {
-                            id: `${module.id}-branch-${branchIndex}`,
+                            id: `${module.id}-start`,
+                            data: {
+                                offset: currentOffset + 25,
+                                id: module.id,
+                                module: module,
+                                modules: modules,
+                                eventHandlers: eventHandlers,
+                                ...extra
+                            },
+                            position: { x: -1, y: -1 },
+                            type: 'forLoopStart'
+                        };
+                        addEdge(module.id, startNode.id, {
+                            type: 'empty'
+                        });
+                        const endNode = {
+                            id: `${module.id}-end`,
                             data: {
                                 offset: currentOffset,
-                                label: defaultIfEmptyString(branch.summary, 'Branch ' + (branchIndex + 1)),
-                                preLabel: branch.summary ? '' : branch.expr,
                                 id: module.id,
-                                branchIndex: branchIndex,
+                                module: module,
                                 modules: modules,
                                 eventHandlers: eventHandlers,
                                 ...extra
                             },
                             position: { x: -1, y: -1 },
-                            type: 'branchOneStart'
+                            type: 'forLoopEnd'
                         };
                         nodes.push(startNode);
-                        addEdge(module.id, startNode.id, { type: 'empty' });
-                        processModules(branch.modules, startNode, endNode, currentOffset, localDisableMoveIds);
-                    });
-                    previousId = endNode.id;
-                }
-                else {
-                    addNode(module, currentOffset, 'module', modules);
-                    previousId = module.id;
-                }
-                if (index === 0) {
-                    addEdge(beforeNode.id, module.id, {
-                        subModules: modules,
-                        disableMoveIds
-                    });
-                }
-                if (index === modules.length - 1 && previousId) {
-                    addEdge(previousId, nextNode.id, {
-                        subModules: modules,
-                        disableMoveIds
-                    });
+                        nodes.push(endNode);
+                        const selectedIterIndex = extra.flowModuleStates?.[module.id]?.selectedForloopIndex;
+                        processModules(module.value.modules, startNode, endNode, currentOffset + 25, localDisableMoveIds, parentIndex
+                            ? `${parentIndex}-${index}-${selectedIterIndex ?? '?'}`
+                            : `${index}-${selectedIterIndex ?? '?'}`);
+                        previousId = endNode.id;
+                    }
+                    else if (module.value.type === 'whileloopflow') {
+                        addNode(module, currentOffset, 'module', modules);
+                        const startNode = {
+                            id: `${module.id}-start`,
+                            data: {
+                                offset: currentOffset + 25,
+                                module: module,
+                                modules: modules,
+                                eventHandlers: eventHandlers,
+                                ...extra
+                            },
+                            position: { x: -1, y: -1 },
+                            type: 'whileLoopStart'
+                        };
+                        addEdge(module.id, startNode.id, {
+                            type: 'empty'
+                        });
+                        const endNode = {
+                            id: `${module.id}-end`,
+                            data: { offset: currentOffset, module: module, modules: modules, ...extra },
+                            position: { x: -1, y: -1 },
+                            type: 'whileLoopEnd'
+                        };
+                        nodes.push(startNode);
+                        nodes.push(endNode);
+                        const selectedIterIndex = extra.flowModuleStates?.[module.id]?.selectedForloopIndex;
+                        processModules(module.value.modules, startNode, endNode, currentOffset + 25, localDisableMoveIds, parentIndex
+                            ? `${parentIndex}-${index}-${selectedIterIndex ?? '?'}`
+                            : `${index}-${selectedIterIndex ?? '?'}`);
+                        previousId = endNode.id;
+                    }
+                    else if (module.value.type === 'branchone') {
+                        addNode(module, currentOffset, 'module', modules);
+                        const endNode = {
+                            id: `${module.id}-end`,
+                            data: { offset: currentOffset, eventHandlers: eventHandlers },
+                            position: { x: -1, y: -1 },
+                            type: 'branchOneEnd'
+                        };
+                        nodes.push(endNode);
+                        // Add default branch
+                        const defaultBranch = {
+                            id: `${module.id}-default`,
+                            data: {
+                                offset: currentOffset,
+                                label: 'Default',
+                                id: module.id,
+                                branchIndex: -1,
+                                modules: module.value.default,
+                                eventHandlers: eventHandlers,
+                                branchOne: true,
+                                ...extra
+                            },
+                            position: { x: -1, y: -1 },
+                            type: 'noBranch'
+                        };
+                        nodes.push(defaultBranch);
+                        addEdge(module.id, defaultBranch.id, { type: 'empty' });
+                        processModules(module.value.default, defaultBranch, endNode, currentOffset, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}` : index.toString());
+                        module.value.branches.forEach((branch, branchIndex) => {
+                            // Start node by branch
+                            const startNode = {
+                                id: `${module.id}-branch-${branchIndex}`,
+                                data: {
+                                    offset: currentOffset,
+                                    label: defaultIfEmptyString(branch.summary, 'Branch ' + (branchIndex + 1)),
+                                    preLabel: branch.summary ? '' : branch.expr,
+                                    id: module.id,
+                                    branchIndex: branchIndex,
+                                    modules: modules,
+                                    eventHandlers: eventHandlers,
+                                    ...extra
+                                },
+                                position: { x: -1, y: -1 },
+                                type: 'branchOneStart'
+                            };
+                            nodes.push(startNode);
+                            addEdge(module.id, startNode.id, { type: 'empty' });
+                            processModules(branch.modules, startNode, endNode, currentOffset, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}` : index.toString());
+                        });
+                        previousId = endNode.id;
+                    }
+                    else {
+                        addNode(module, currentOffset, 'module', modules);
+                        previousId = module.id;
+                    }
+                    if (index === 0) {
+                        addEdge(beforeNode.id, module.id, {
+                            subModules: modules,
+                            disableMoveIds
+                        });
+                    }
+                    if (index === modules.length - 1 && previousId) {
+                        addEdge(previousId, nextNode.id, {
+                            subModules: modules,
+                            disableMoveIds
+                        });
+                    }
+                });
+                if (failureModule) {
+                    const id = parentIndex ? `failure-${parentIndex}` : 'failure';
+                    const failureState = extra.flowModuleStates?.[id];
+                    if (failureState && failureState.parent_module) {
+                        addNode({
+                            ...failureModule,
+                            id: id
+                        }, 0, 'module');
+                        addEdge(failureState.parent_module, id, { type: 'empty' });
+                    }
                 }
-            });
+            }
         }
-    }
-    processModules(modules, inputNode, resultNode);
-    if (failureModule) {
-        addNode(failureModule, 0, 'module');
-    }
-    Object.keys(parents).forEach((key) => {
-        const node = nodes.find((n) => n.id === key);
-        if (node) {
-            node.data.parentIds = parents[key];
+        processModules(modules, inputNode, resultNode);
+        if (preprocessorModule) {
+            addNode(preprocessorModule, 0, 'module');
+            const id = JSON.parse(JSON.stringify(preprocessorModule.id));
+            addEdge(id, 'Input', { type: 'empty' });
         }
-    });
-    if (useDataflow && selectedId) {
-        let deps = getDependeeAndDependentComponents(selectedId, modules ?? [], failureModule);
-        if (deps) {
-            Object.entries(deps.dependees).forEach((x, i) => {
-                const inputs = x[1];
-                inputs?.forEach((input, index) => {
-                    let pid = x[0];
-                    if (input?.startsWith('flow_input.iter')) {
-                        const parent = dfsByModule(selectedId, modules ?? [])?.pop();
-                        if (parent?.id) {
-                            pid = parent.id;
+        if (failureModule && !extra.flowModuleStates) {
+            addNode(failureModule, 0, 'module');
+        }
+        Object.keys(parents).forEach((key) => {
+            const node = nodes.find((n) => n.id === key);
+            if (node) {
+                node.data.parentIds = parents[key];
+            }
+        });
+        if (useDataflow && selectedId) {
+            let deps = getDependeeAndDependentComponents(selectedId, modules ?? [], failureModule);
+            if (deps) {
+                Object.entries(deps.dependees).forEach((x, i) => {
+                    const inputs = x[1];
+                    inputs?.forEach((input, index) => {
+                        let pid = x[0];
+                        if (input?.startsWith('flow_input.iter')) {
+                            const parent = dfsByModule(selectedId, modules ?? [])?.pop();
+                            if (parent?.id) {
+                                pid = parent.id;
+                            }
                         }
-                    }
-                    addEdge(pid, selectedId, {
-                        customId: `dep-${pid}-${selectedId}-${input}-${index}`,
-                        type: 'dataflowedge'
+                        addEdge(pid, selectedId, {
+                            customId: `dep-${pid}-${selectedId}-${input}-${index}`,
+                            type: 'dataflowedge'
+                        });
                     });
                 });
-            });
-            Object.entries(deps.dependents).forEach((x, i) => {
-                let pid = x[0];
-                addEdge(selectedId, pid, {
-                    customId: `dep-${selectedId}-${pid}-${i}`,
-                    type: 'dataflowedge'
+                Object.entries(deps.dependents).forEach((x, i) => {
+                    let pid = x[0];
+                    addEdge(selectedId, pid, {
+                        customId: `dep-${selectedId}-${pid}-${i}`,
+                        type: 'dataflowedge'
+                    });
                 });
-            });
+            }
         }
+        return { nodes, edges };
+    }
+    catch (e) {
+        return {
+            nodes: [],
+            edges: [],
+            error: e
+        };
     }
-    return { nodes, edges };
 }