windmill-components 1.677.1 → 1.695.0

package/package/components/flows/flowDeleteUtils.test.js

@@ -0,0 +1,131 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('../aiProviderStorage', () => ({
+    loadStoredConfig: () => undefined
+}));
+vi.mock('./flowInfers', () => ({
+    AI_AGENT_SCHEMA: { properties: {} }
+}));
+import { GroupDisplayState } from '../graph/groupEditor.svelte';
+import { createDeletePlan, removeDeletePlanTools, resolveDeleteTargets } from './flowDeleteUtils';
+function makeRawModule(id, expr) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'rawscript',
+            content: '',
+            language: 'python3',
+            input_transforms: expr
+                ? {
+                    user_input: {
+                        type: 'javascript',
+                        expr
+                    }
+                }
+                : {}
+        }
+    };
+}
+function makeAiAgent(id, tools) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
+function makeFlowModuleTool(module) {
+    return {
+        id: module.id,
+        summary: module.summary,
+        value: {
+            tool_type: 'flowmodule',
+            ...module.value
+        }
+    };
+}
+describe('resolveDeleteTargets', () => {
+    it('resolves structure nodes, preprocessor, and ai tools while pruning nested descendants', () => {
+        const rootAgent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const tree = [{ id: 'root_agent', kind: 'leaf', branches: [] }];
+        const { targets, missingIds } = resolveDeleteTargets(tree, [rootAgent], ['preprocessor', 'root_agent', 'create_ticket', 'missing_tool'], true);
+        expect(targets.map((target) => target.kind)).toEqual(['preprocessor', 'structure_node']);
+        expect(targets[1].stateIds).toEqual([
+            'root_agent',
+            'lookup_user',
+            'support_agent',
+            'create_ticket'
+        ]);
+        expect(missingIds).toEqual(['missing_tool']);
+    });
+});
+describe('createDeletePlan', () => {
+    it('collects subtree dependents and routes structure deletes through the proxy helper', () => {
+        const agent = makeAiAgent('agent_step', [makeFlowModuleTool(makeRawModule('lookup_user'))]);
+        const dependent = makeRawModule('dependent_step', 'results.lookup_user?.value');
+        const flow = {
+            summary: 'Flow',
+            value: {
+                modules: [agent, dependent]
+            }
+        };
+        const tree = [
+            { id: 'agent_step', kind: 'leaf', branches: [] },
+            { id: 'dependent_step', kind: 'leaf', branches: [] }
+        ];
+        const commit = vi.fn();
+        const prepareDelete = vi.fn(() => ({
+            affectedGroups: [],
+            duplicateGroups: [],
+            commit
+        }));
+        const proxy = {
+            prepareDelete
+        };
+        const plan = createDeletePlan({
+            ids: ['agent_step'],
+            flow,
+            tree,
+            proxy,
+            displayState: new GroupDisplayState(() => [])
+        });
+        expect(prepareDelete).toHaveBeenCalledWith(['agent_step'], expect.any(Object));
+        expect(plan?.plannedStateIds).toEqual(['agent_step', 'lookup_user']);
+        expect(plan?.structureDelete?.affectedGroups).toEqual([]);
+        expect(plan?.dependents).toEqual({
+            dependent_step: ['results.lookup_user?.value']
+        });
+        expect(plan?.selection).toEqual({ kind: 'select', id: 'dependent_step' });
+    });
+});
+describe('removeDeletePlanTools', () => {
+    it('removes nested tools before their parents and returns every removed id', () => {
+        const rootAgent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const tree = [];
+        const { targets } = resolveDeleteTargets(tree, [rootAgent], ['support_agent', 'create_ticket'], false);
+        expect(removeDeletePlanTools(targets, [rootAgent])).toEqual(['support_agent', 'create_ticket']);
+        expect(rootAgent.value.tools).toEqual([]);
+    });
+    it('re-resolves live owners before removing planned tool targets', () => {
+        const rootAgent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const tree = [];
+        const { targets } = resolveDeleteTargets(tree, [rootAgent], ['support_agent'], false);
+        rootAgent.value.tools.unshift(makeFlowModuleTool(makeRawModule('new_lookup')));
+        expect(removeDeletePlanTools(targets, [rootAgent])).toEqual(['support_agent', 'create_ticket']);
+        expect(rootAgent.value.tools.map((tool) => tool.id)).toEqual([
+            'new_lookup',
+            'lookup_user'
+        ]);
+    });
+});

package/package/components/flows/flowDiff.d.ts

@@ -1,4 +1,6 @@
 import type { FlowModule, FlowValue } from '../../gen';
+import { type ModuleParentLocation } from './flowTree';
+export { findModuleInFlow, findModuleParent, type ModuleParentLocation } from './flowTree';
 /** Prefix added to module IDs when the original module coexists with a replacement */
 export declare const DUPLICATE_MODULE_PREFIX = "old__";
 /** Prefix added to new module IDs when restoring original during type change rejection */
@@ -52,45 +54,6 @@ export declare function computeFlowModuleDiff(beforeFlow: FlowValue, afterFlow:
  * Index within the container is not considered (modules can be reordered).
  */
 export declare function locationsEqual(a: ModuleParentLocation | null, b: ModuleParentLocation | null): boolean;
-/**
- * Represents the parent location of a module
- */
-export type ModuleParentLocation = {
-    type: 'root';
-    index: number;
-} | {
-    type: 'forloop' | 'whileloop';
-    parentId: string;
-    index: number;
-} | {
-    type: 'branchone-default';
-    parentId: string;
-    index: number;
-} | {
-    type: 'branchone-branch';
-    parentId: string;
-    branchIndex: number;
-    index: number;
-} | {
-    type: 'branchall-branch';
-    parentId: string;
-    branchIndex: number;
-    index: number;
-} | {
-    type: 'aiagent';
-    parentId: string;
-    index: number;
-} | {
-    type: 'failure';
-    index: -1;
-} | {
-    type: 'preprocessor';
-    index: -1;
-};
-/**
- * Finds the parent location of a module in a flow
- */
-export declare function findModuleParent(flow: FlowValue, moduleId: string): ModuleParentLocation | null;
 /**
  * Builds the complete flow diff result with action maps and merged flow.
  * The merged flow contains all modules from afterFlow plus removed modules from
@@ -115,14 +78,6 @@ export declare function buildFlowTimeline(beforeFlow: FlowValue, afterFlow: Flow
  * @param moduleId - The ID of the module being inserted
  */
 export declare function insertModuleIntoFlow(targetFlow: FlowValue, moduleToInsert: FlowModule, sourceFlow: FlowValue, moduleId: string): void;
-/**
- * Finds a module by ID anywhere in a flow (including nested modules, failure, and preprocessor)
- *
- * @param flow - The flow to search in
- * @param moduleId - The ID of the module to find
- * @returns The module if found, null otherwise
- */
-export declare function findModuleInFlow(flow: FlowValue, moduleId: string): FlowModule | null;
 /**
  * Checks if the input schema has changed between two flow versions.
  * The input schema always exists (even if empty), so we only check for modifications.

package/package/components/flows/flowDiff.js

@@ -1,5 +1,6 @@
-import { dfs } from './dfs';
 import { deepEqual } from 'fast-equals';
+import { collectAllFlowModuleIds, collectFlowNodes, ensureModuleArrayByLocation, findModuleParent, getModuleArrayByLocation } from './flowTree';
+export { findModuleInFlow, findModuleParent } from './flowTree';
 /** Prefix added to module IDs when the original module coexists with a replacement */
 export const DUPLICATE_MODULE_PREFIX = 'old__';
 /** Prefix added to new module IDs when restoring original during type change rejection */
@@ -103,21 +104,11 @@ export function computeFlowModuleDiff(beforeFlow, afterFlow, options = { markAsP
  */
 function getAllModulesMap(flow) {
     const moduleMap = new Map();
-    // Get all regular modules
-    const allModules = dfs(flow.modules ?? [], (m) => m);
-    for (const module of allModules) {
+    for (const { module } of collectFlowNodes(flow)) {
         if (module?.id) {
             moduleMap.set(module.id, module);
         }
     }
-    // Add failure module if it exists
-    if (flow.failure_module?.id) {
-        moduleMap.set(flow.failure_module.id, flow.failure_module);
-    }
-    // Add preprocessor module if it exists
-    if (flow.preprocessor_module?.id) {
-        moduleMap.set(flow.preprocessor_module.id, flow.preprocessor_module);
-    }
     return moduleMap;
 }
 /**
@@ -125,28 +116,14 @@ function getAllModulesMap(flow) {
  */
 function getAllModulesWithLocation(flow) {
     const result = new Map();
-    const allModules = dfs(flow.modules ?? [], (m) => m);
-    for (const module of allModules) {
-        if (module?.id) {
-            const location = findModuleParent(flow, module.id);
-            if (location) {
-                result.set(module.id, { module, location });
-            }
+    for (const entry of collectFlowNodes(flow)) {
+        if (entry.module?.id) {
+            result.set(entry.module.id, {
+                module: entry.module,
+                location: entry.location
+            });
         }
     }
-    // Add special modules
-    if (flow.failure_module?.id) {
-        result.set(flow.failure_module.id, {
-            module: flow.failure_module,
-            location: { type: 'failure', index: -1 }
-        });
-    }
-    if (flow.preprocessor_module?.id) {
-        result.set(flow.preprocessor_module.id, {
-            module: flow.preprocessor_module,
-            location: { type: 'preprocessor', index: -1 }
-        });
-    }
     return result;
 }
 /**
@@ -177,95 +154,6 @@ export function locationsEqual(a, b) {
             return false;
     }
 }
-/**
- * Finds the parent location of a module in a flow
- */
-export function findModuleParent(flow, moduleId) {
-    // Check special modules
-    if (flow.failure_module?.id === moduleId) {
-        return { type: 'failure', index: -1 };
-    }
-    if (flow.preprocessor_module?.id === moduleId) {
-        return { type: 'preprocessor', index: -1 };
-    }
-    // Check root level
-    const rootIndex = flow.modules?.findIndex((m) => m.id === moduleId);
-    if (rootIndex !== undefined && rootIndex >= 0) {
-        return { type: 'root', index: rootIndex };
-    }
-    // Recursively search nested modules
-    function searchInModules(modules) {
-        for (const module of modules) {
-            // Check forloopflow
-            if (module.value.type === 'forloopflow') {
-                const index = module.value.modules.findIndex((m) => m.id === moduleId);
-                if (index >= 0) {
-                    return { type: 'forloop', parentId: module.id, index };
-                }
-                const nested = searchInModules(module.value.modules);
-                if (nested)
-                    return nested;
-            }
-            // Check whileloopflow
-            if (module.value.type === 'whileloopflow') {
-                const index = module.value.modules.findIndex((m) => m.id === moduleId);
-                if (index >= 0) {
-                    return { type: 'whileloop', parentId: module.id, index };
-                }
-                const nested = searchInModules(module.value.modules);
-                if (nested)
-                    return nested;
-            }
-            // Check branchone
-            if (module.value.type === 'branchone') {
-                // Check default branch
-                const defaultIndex = module.value.default.findIndex((m) => m.id === moduleId);
-                if (defaultIndex >= 0) {
-                    return { type: 'branchone-default', parentId: module.id, index: defaultIndex };
-                }
-                const nestedDefault = searchInModules(module.value.default);
-                if (nestedDefault)
-                    return nestedDefault;
-                // Check other branches
-                for (let branchIndex = 0; branchIndex < module.value.branches.length; branchIndex++) {
-                    const branch = module.value.branches[branchIndex];
-                    const index = branch.modules.findIndex((m) => m.id === moduleId);
-                    if (index >= 0) {
-                        return { type: 'branchone-branch', parentId: module.id, branchIndex, index };
-                    }
-                    const nested = searchInModules(branch.modules);
-                    if (nested)
-                        return nested;
-                }
-            }
-            // Check branchall
-            if (module.value.type === 'branchall') {
-                for (let branchIndex = 0; branchIndex < module.value.branches.length; branchIndex++) {
-                    const branch = module.value.branches[branchIndex];
-                    const index = branch.modules.findIndex((m) => m.id === moduleId);
-                    if (index >= 0) {
-                        return { type: 'branchall-branch', parentId: module.id, branchIndex, index };
-                    }
-                    const nested = searchInModules(branch.modules);
-                    if (nested)
-                        return nested;
-                }
-            }
-            // Check aiagent
-            if (module.value.type === 'aiagent' && module.value.tools) {
-                const index = module.value.tools.findIndex((m) => m.id === moduleId);
-                if (index >= 0) {
-                    return { type: 'aiagent', parentId: module.id, index };
-                }
-                const nested = searchInModules(module.value.tools);
-                if (nested)
-                    return nested;
-            }
-        }
-        return null;
-    }
-    return searchInModules(flow.modules ?? []);
-}
 /**
  * Deep clones a module to avoid mutation
  */
@@ -333,48 +221,8 @@ function prependModuleId(module, prefix) {
     }
     return newModule;
 }
-/**
- * Collects all module IDs from a flow structure recursively
- */
 function getAllModuleIds(flow) {
-    const ids = new Set();
-    function collectFromModules(modules) {
-        for (const module of modules) {
-            if (module.id) {
-                ids.add(module.id);
-            }
-            // Recursively collect from nested modules
-            if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
-                collectFromModules(module.value.modules);
-            }
-            else if (module.value.type === 'branchone') {
-                collectFromModules(module.value.default);
-                for (const branch of module.value.branches) {
-                    collectFromModules(branch.modules);
-                }
-            }
-            else if (module.value.type === 'branchall') {
-                for (const branch of module.value.branches) {
-                    collectFromModules(branch.modules);
-                }
-            }
-            else if (module.value.type === 'aiagent' && module.value.tools) {
-                collectFromModules(module.value.tools);
-            }
-        }
-    }
-    // Collect from root modules
-    if (flow.modules) {
-        collectFromModules(flow.modules);
-    }
-    // Collect from special modules
-    if (flow.failure_module?.id) {
-        ids.add(flow.failure_module.id);
-    }
-    if (flow.preprocessor_module?.id) {
-        ids.add(flow.preprocessor_module.id);
-    }
-    return ids;
+    return new Set(collectAllFlowModuleIds(flow));
 }
 /**
  * Scans the merged flow for duplicate IDs and prefixes duplicates with 'old__'.
@@ -503,24 +351,7 @@ function reconstructMergedFlow(afterFlow, beforeFlow, beforeActions) {
         }
         // Track the newly added module ID
         mergedIds.add(clonedModule.id);
-        // Insert based on parent location
-        if (parentLocation.type === 'failure') {
-            merged.failure_module = clonedModule;
-        }
-        else if (parentLocation.type === 'preprocessor') {
-            merged.preprocessor_module = clonedModule;
-        }
-        else if (parentLocation.type === 'root') {
-            // Find the best position to insert in root modules
-            const insertIndex = findBestInsertPosition(merged.modules ?? [], beforeFlow.modules ?? [], parentLocation.index, removedId);
-            if (!merged.modules)
-                merged.modules = [];
-            merged.modules.splice(insertIndex, 0, clonedModule);
-        }
-        else {
-            // Find the parent module in merged flow and insert into it
-            insertIntoNestedParent(merged, parentLocation, clonedModule, beforeFlow);
-        }
+        insertModuleIntoFlow(merged, clonedModule, beforeFlow, removedId);
     }
     // Post-process: fix any duplicate IDs that may have been created
     // This handles the case where a module moved from one location to another
@@ -554,101 +385,6 @@ function findBestInsertPosition(targetModules, beforeModules, originalIndex, rem
 /**
  * Inserts a removed module into its nested parent in the merged flow
  */
-function insertIntoNestedParent(merged, parentLocation, moduleToInsert, beforeFlow) {
-    if (parentLocation.type === 'root' ||
-        parentLocation.type === 'failure' ||
-        parentLocation.type === 'preprocessor') {
-        return;
-    }
-    // Find the parent module in merged flow
-    const parentModule = findModuleById(merged, parentLocation.parentId);
-    if (!parentModule) {
-        console.warn('Parent module not found', parentLocation);
-        return;
-    }
-    // Get the before parent to know original ordering
-    const beforeParent = findModuleById(beforeFlow, parentLocation.parentId);
-    if (!beforeParent) {
-        console.warn('Before parent module not found', parentLocation);
-        return;
-    }
-    // Insert based on type
-    if (parentLocation.type === 'forloop' && parentModule.value.type === 'forloopflow') {
-        const beforeModules = beforeParent.value.modules ?? [];
-        const insertIndex = findBestInsertPosition(parentModule.value.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-        parentModule.value.modules.splice(insertIndex, 0, moduleToInsert);
-    }
-    else if (parentLocation.type === 'whileloop' && parentModule.value.type === 'whileloopflow') {
-        const beforeModules = beforeParent.value.modules ?? [];
-        const insertIndex = findBestInsertPosition(parentModule.value.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-        parentModule.value.modules.splice(insertIndex, 0, moduleToInsert);
-    }
-    else if (parentLocation.type === 'branchone-default' &&
-        parentModule.value.type === 'branchone') {
-        const beforeModules = beforeParent.value.default ?? [];
-        const insertIndex = findBestInsertPosition(parentModule.value.default, beforeModules, parentLocation.index, moduleToInsert.id);
-        parentModule.value.default.splice(insertIndex, 0, moduleToInsert);
-    }
-    else if (parentLocation.type === 'branchone-branch' &&
-        parentModule.value.type === 'branchone') {
-        let branch = parentModule.value.branches[parentLocation.branchIndex];
-        const beforeBranch = beforeParent.value.branches?.[parentLocation.branchIndex];
-        // If the branch doesn't exist (entire branch was removed), recreate it from beforeFlow
-        if (!branch && beforeBranch) {
-            // Ensure we have enough branch slots
-            while (parentModule.value.branches.length <= parentLocation.branchIndex) {
-                parentModule.value.branches.push({ expr: '', modules: [] });
-            }
-            // Restore the branch with its original expr but empty modules (we'll add them)
-            parentModule.value.branches[parentLocation.branchIndex] = {
-                ...beforeBranch,
-                modules: []
-            };
-            branch = parentModule.value.branches[parentLocation.branchIndex];
-        }
-        if (branch) {
-            const beforeModules = beforeBranch?.modules ?? [];
-            const insertIndex = findBestInsertPosition(branch.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-            branch.modules.splice(insertIndex, 0, moduleToInsert);
-        }
-    }
-    else if (parentLocation.type === 'branchall-branch' &&
-        parentModule.value.type === 'branchall') {
-        let branch = parentModule.value.branches[parentLocation.branchIndex];
-        const beforeBranch = beforeParent.value.branches?.[parentLocation.branchIndex];
-        // If the branch doesn't exist (entire branch was removed), recreate it from beforeFlow
-        if (!branch && beforeBranch) {
-            // Ensure we have enough branch slots
-            while (parentModule.value.branches.length <= parentLocation.branchIndex) {
-                parentModule.value.branches.push({ modules: [] });
-            }
-            // Restore the branch with empty modules (we'll add them)
-            parentModule.value.branches[parentLocation.branchIndex] = {
-                ...beforeBranch,
-                modules: []
-            };
-            branch = parentModule.value.branches[parentLocation.branchIndex];
-        }
-        if (branch) {
-            const beforeModules = beforeBranch?.modules ?? [];
-            const insertIndex = findBestInsertPosition(branch.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-            branch.modules.splice(insertIndex, 0, moduleToInsert);
-        }
-    }
-    else if (parentLocation.type === 'aiagent' && parentModule.value.type === 'aiagent') {
-        const tools = parentModule.value.tools ?? [];
-        const beforeTools = beforeParent.value.tools ?? [];
-        const insertIndex = findBestInsertPosition(tools, beforeTools, parentLocation.index, moduleToInsert.id);
-        tools.splice(insertIndex, 0, moduleToInsert);
-    }
-}
-/**
- * Finds a module by ID anywhere in the flow
- */
-function findModuleById(flow, moduleId) {
-    const moduleMap = getAllModulesMap(flow);
-    return moduleMap.get(moduleId) ?? null;
-}
 /**
  * Adjusts the after actions based on display mode and adds entries for prefixed IDs
  */
@@ -732,26 +468,13 @@ export function insertModuleIntoFlow(targetFlow, moduleToInsert, sourceFlow, mod
         targetFlow.preprocessor_module = moduleToInsert;
         return;
     }
-    // Handle root level modules
-    if (parentLocation.type === 'root') {
-        const insertIndex = findBestInsertPosition(targetFlow.modules ?? [], sourceFlow.modules ?? [], parentLocation.index, moduleId);
-        if (!targetFlow.modules)
-            targetFlow.modules = [];
-        targetFlow.modules.splice(insertIndex, 0, moduleToInsert);
+    const targetModules = ensureModuleArrayByLocation(targetFlow, parentLocation, sourceFlow);
+    const sourceModules = getModuleArrayByLocation(sourceFlow, parentLocation);
+    if (!targetModules || !sourceModules) {
         return;
     }
-    // Handle nested modules
-    insertIntoNestedParent(targetFlow, parentLocation, moduleToInsert, sourceFlow);
-}
-/**
- * Finds a module by ID anywhere in a flow (including nested modules, failure, and preprocessor)
- *
- * @param flow - The flow to search in
- * @param moduleId - The ID of the module to find
- * @returns The module if found, null otherwise
- */
-export function findModuleInFlow(flow, moduleId) {
-    return findModuleById(flow, moduleId);
+    const insertIndex = findBestInsertPosition(targetModules, sourceModules, parentLocation.index, moduleId);
+    targetModules.splice(insertIndex, 0, moduleToInsert);
 }
 /**
  * Checks if the input schema has changed between two flow versions.

package/package/components/flows/flowDiff.testUtils.d.ts

@@ -30,6 +30,14 @@ export declare function createBranchOneModule(id: string, defaultModules: FlowMo
 export declare function createBranchAllModule(id: string, branches: {
     modules: FlowModule[];
 }[]): FlowModule;
+/**
+ * Wraps a FlowModule as an AI agent flowmodule tool.
+ */
+export declare function createFlowModuleTool(module: FlowModule): FlowModule;
+/**
+ * Creates an AI agent module with the provided tools.
+ */
+export declare function createAiAgentModule(id: string, tools: FlowModule[]): FlowModule;
 /**
  * Creates a FlowValue with the given modules
  */

package/package/components/flows/flowDiff.testUtils.js

@@ -79,6 +79,32 @@ export function createBranchAllModule(id, branches) {
         }
     };
 }
+/**
+ * Wraps a FlowModule as an AI agent flowmodule tool.
+ */
+export function createFlowModuleTool(module) {
+    return {
+        id: module.id,
+        summary: module.summary,
+        value: {
+            tool_type: 'flowmodule',
+            ...module.value
+        }
+    };
+}
+/**
+ * Creates an AI agent module with the provided tools.
+ */
+export function createAiAgentModule(id, tools) {
+    return {
+        id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
 // ============================================================================
 // Flow Creation Helpers
 // ============================================================================