@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/api/manipulation/index.js

@@ -1,41 +0,0 @@
-/**
- * @module api/manipulation
- *
- * # Manipulation API
- *
- * Immutable operations for programmatic workflow modification.
- * All functions return a new AST (never mutate the original).
- *
- * ## Operation Categories
- *
- * | Category    | Functions |
- * |-------------|-----------|
- * | Workflow    | `cloneWorkflow`, `renameWorkflow`, `setWorkflowPorts` |
- * | Node Types  | `addNodeType`, `removeNodeType`, `updateNodeType` |
- * | Nodes       | `addNode`, `removeNode`, `renameNode`, `setNodePosition` |
- * | Connections | `addConnection`, `removeConnection`, `reconnect` |
- * | Ports       | `swapPortOrder`, `swapNodeInstancePortOrder` |
- * | Scopes      | `createScope`, `removeScope`, `addToScope` |
- *
- * ## Validation Options
- *
- * Operations validate by default. Use wrappers for control:
- * - `withValidation(workflow)` - Full validation (default)
- * - `withMinimalValidation(workflow)` - Skip expensive checks
- * - `withoutValidation(workflow)` - No validation (use with caution)
- */
-// Re-export validation utilities
-export { withoutValidation, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeExists, assertNodeNotExists, } from "../helpers.js";
-// Re-export workflow-level operations
-export { cloneWorkflow, setWorkflowDescription, setWorkflowMetadata, setOutputFileType, renameWorkflow, setWorkflowPorts, } from "./workflow.js";
-// Re-export node type operations
-export { addNodeType, removeNodeType, updateNodeType, getNodeType, hasNodeType, listNodeTypes, renameNodeType, replaceNodeTypes, } from "./node-types.js";
-// Re-export node instance operations
-export { addNode, removeNode, renameNode, updateNode, addNodes, removeNodes, setNodeConfig, setNodePosition, setNodeMinimized, setNodeSize, setNodeLabel, } from "./nodes.js";
-// Re-export connection operations
-export { addConnection, removeConnection, removeAllConnections, reconnect, addConnections, replaceConnections, } from "./connections.js";
-// Re-export port operations
-export { swapPortOrder, swapNodeInstancePortOrder, setStartExitPorts, setInstancePortConfigs, } from "./ports.js";
-// Re-export scope operations
-export { createScope, removeScope, addToScope, removeFromScope, moveToScope, } from "./scopes.js";
-//# sourceMappingURL=index.js.map

package/dist/api/manipulation/node-types.js

@@ -1,200 +0,0 @@
-/**
- * Node type operations for workflow manipulation
- */
-import { produce } from "immer";
-import { withoutValidation } from "../helpers.js";
-/**
- * Add a node type definition to the workflow (idempotent).
- * Uses no validation to allow adding even when workflow has other errors.
- *
- * If a node type with the same name already exists, returns the AST unchanged
- * without throwing an error. This handles state desync between server and client,
- * race conditions, double-clicks, and server restarts gracefully.
- *
- * @param ast - Workflow to modify
- * @param nodeType - Node type to add
- * @returns Modified workflow (or unchanged if node type already exists)
- *
- * @example
- * ```typescript
- * const ast = addNodeType(workflow, {
- *   type: 'NodeType',
- *   name: 'double',
- *   functionName: 'double',
- *   inputs: { x: { dataType: 'NUMBER' } },
- *   outputs: { result: { dataType: 'NUMBER' } },
- *   hasSuccessPort: true,
- *   hasFailurePort: true,
- *   executeWhen: 'CONJUNCTION'
- * });
- * ```
- */
-export function addNodeType(ast, nodeType) {
-    const existingIndex = ast.nodeTypes.findIndex((nt) => nt.name === nodeType.name);
-    // If node type already exists, check if we need to update it with new properties
-    // (e.g., importSource for npm types that were parsed without @import annotation)
-    if (existingIndex >= 0) {
-        const existing = ast.nodeTypes[existingIndex];
-        const newImportSource = nodeType.importSource;
-        const existingImportSource = existing.importSource;
-        // If the new type has importSource but the existing one doesn't, update it
-        if (newImportSource && !existingImportSource) {
-            return produce(ast, (draft) => {
-                draft.nodeTypes[existingIndex].importSource = newImportSource;
-            });
-        }
-        // Otherwise, return unchanged (idempotent)
-        return ast;
-    }
-    // Add new node type
-    return produce(ast, (draft) => {
-        draft.nodeTypes.push(nodeType);
-    });
-}
-/**
- * Remove a node type from the workflow.
- * Uses minimal validation (only checks type exists and has no instances)
- * to allow deletion even when the workflow has other validation errors.
- *
- * @param ast - Workflow to modify
- * @param typeName - Name of node type to remove
- * @returns Modified workflow
- * @throws {Error} If node type doesn't exist or instances reference it
- *
- * @example
- * ```typescript
- * const ast = removeNodeType(workflow, 'obsoleteType');
- * ```
- */
-export function removeNodeType(ast, typeName) {
-    // First, verify node type exists
-    const typeIndex = ast.nodeTypes.findIndex((nt) => nt.name === typeName);
-    if (typeIndex === -1) {
-        throw new Error(`Node type "${typeName}" not found`);
-    }
-    // Check if any instances reference this type
-    const functionName = ast.nodeTypes[typeIndex].functionName;
-    const referencingInstances = ast.instances.filter((inst) => inst.nodeType === functionName);
-    if (referencingInstances.length > 0) {
-        throw new Error(`Cannot remove node type "${typeName}": ${referencingInstances.length} instance(s) still reference it (${referencingInstances.map((i) => i.id).join(", ")})`);
-    }
-    return withoutValidation(ast, (draft) => {
-        const idx = draft.nodeTypes.findIndex((nt) => nt.name === typeName);
-        draft.nodeTypes.splice(idx, 1);
-    });
-}
-/**
- * Update an existing node type.
- * Uses no validation to allow updates even when workflow has other errors.
- *
- * @param ast - Workflow to modify
- * @param typeName - Name of node type to update
- * @param updates - Partial node type to merge
- * @returns Modified workflow
- * @throws {Error} If node type doesn't exist
- *
- * @example
- * ```typescript
- * const ast = updateNodeType(workflow, 'processor', {
- *   label: 'Data Processor',
- *   description: 'Processes incoming data'
- * });
- * ```
- */
-export function updateNodeType(ast, typeName, updates) {
-    // Verify node type exists
-    if (!ast.nodeTypes.find((nt) => nt.name === typeName)) {
-        throw new Error(`Node type "${typeName}" not found`);
-    }
-    return withoutValidation(ast, (draft) => {
-        const nodeType = draft.nodeTypes.find((nt) => nt.name === typeName);
-        Object.assign(nodeType, updates);
-    });
-}
-/**
- * Get a node type by name
- *
- * @param ast - Workflow to query
- * @param typeName - Name of node type
- * @returns Node type or undefined
- */
-export function getNodeType(ast, typeName) {
-    return ast.nodeTypes.find((nt) => nt.name === typeName);
-}
-/**
- * Check if node type exists
- *
- * @param ast - Workflow to query
- * @param typeName - Name of node type
- * @returns True if exists
- */
-export function hasNodeType(ast, typeName) {
-    return ast.nodeTypes.some((nt) => nt.name === typeName);
-}
-/**
- * List all node types
- *
- * @param ast - Workflow to query
- * @returns Array of node types
- */
-export function listNodeTypes(ast) {
-    return [...ast.nodeTypes];
-}
-/**
- * Rename a node type and update all instances that reference it.
- * Uses no validation to allow renames even when workflow has other errors.
- *
- * @param ast - Workflow to modify
- * @param oldTypeName - Current name of the node type
- * @param newTypeName - New name for the node type
- * @returns Modified workflow
- * @throws {Error} If node type doesn't exist or new name already exists
- *
- * @example
- * ```typescript
- * const ast = renameNodeType(workflow, 'OldTypeName', 'NewTypeName');
- * ```
- */
-export function renameNodeType(ast, oldTypeName, newTypeName) {
-    // Check if new name already exists
-    if (ast.nodeTypes.some((nt) => nt.name === newTypeName)) {
-        throw new Error(`Node type "${newTypeName}" already exists`);
-    }
-    return withoutValidation(ast, (draft) => {
-        // Find the node type in nodeTypes array
-        const nodeTypeIndex = draft.nodeTypes.findIndex((nt) => nt.name === oldTypeName);
-        // Rename the node type if it exists in nodeTypes array
-        if (nodeTypeIndex >= 0) {
-            draft.nodeTypes[nodeTypeIndex].name = newTypeName;
-        }
-        // Update all instances that reference this node type
-        draft.instances.forEach((instance) => {
-            if (instance.nodeType === oldTypeName) {
-                instance.nodeType = newTypeName;
-            }
-        });
-    });
-}
-/**
- * Replace all node types in workflow.
- * Uses no validation to allow replacement even when workflow has other errors.
- *
- * @param ast - Workflow to modify
- * @param nodeTypes - New array of node types
- * @returns Modified workflow
- *
- * @example
- * ```typescript
- * const ast = replaceNodeTypes(workflow, [
- *   { type: 'NodeType', name: 'type1', ... },
- *   { type: 'NodeType', name: 'type2', ... }
- * ]);
- * ```
- */
-export function replaceNodeTypes(ast, nodeTypes) {
-    // Use produce directly with simplified type to avoid excessive type instantiation
-    return produce(ast, (draft) => {
-        draft.nodeTypes = nodeTypes;
-    });
-}
-//# sourceMappingURL=node-types.js.map

package/dist/api/manipulation/nodes.js

@@ -1,355 +0,0 @@
-/**
- * Node instance operations for workflow manipulation
- */
-import { produce } from "immer";
-import { withoutValidation, assertNodeExists, assertNodeNotExists, } from "../helpers.js";
-/**
- * Add a node instance to the workflow
- *
- * @param ast - Workflow to modify
- * @param node - Node instance to add
- * @returns Modified workflow
- * @throws {Error} If node ID already exists or node type doesn't exist
- *
- * @example
- * ```typescript
- * const ast = addNode(workflow, {
- *   type: 'NodeInstance',
- *   id: 'processor1',
- *   nodeType: 'dataProcessor'
- * });
- * ```
- */
-export function addNode(ast, node) {
-    // Check for duplicate ID
-    assertNodeNotExists(ast, node.id);
-    // Note: We don't check if node type exists here (eventual consistency model).
-    // Diagnostics will catch INVALID_NODE_TYPE if the type doesn't exist.
-    // Use produce directly with simplified type to avoid excessive type instantiation
-    return produce(ast, (draft) => {
-        draft.instances.push(node);
-    });
-}
-/**
- * Remove a node instance from the workflow.
- * Uses minimal validation (only checks node exists) to allow deletion
- * even when the workflow has other validation errors.
- *
- * @param ast - Workflow to modify
- * @param nodeId - ID of node to remove
- * @param options - Remove options
- * @returns Modified workflow
- * @throws {Error} If node doesn't exist
- *
- * @example
- * ```typescript
- * // Remove node and all its connections
- * const ast = removeNode(workflow, 'processor1');
- *
- * // Remove node, keep connections (will fail validation)
- * const ast = removeNode(workflow, 'processor1', { removeConnections: false });
- * ```
- */
-export function removeNode(ast, nodeId, options = {}) {
-    const { removeConnections = true, } = options;
-    // First, verify node exists (fail fast with clear error)
-    assertNodeExists(ast, nodeId);
-    return withoutValidation(ast, (draft) => {
-        // Remove node instance
-        const nodeIndex = draft.instances.findIndex((n) => n.id === nodeId);
-        draft.instances.splice(nodeIndex, 1);
-        // Remove connections if requested
-        if (removeConnections) {
-            draft.connections = draft.connections.filter((conn) => conn.from.node !== nodeId && conn.to.node !== nodeId);
-        }
-        // Remove from scopes
-        if (draft.scopes) {
-            Object.keys(draft.scopes).forEach((scopeName) => {
-                draft.scopes[scopeName] = draft.scopes[scopeName].filter((id) => id !== nodeId);
-            });
-        }
-        // Clean up macros referencing the deleted node
-        if (draft.macros) {
-            draft.macros = draft.macros.filter((macro) => {
-                if (macro.type === 'map') {
-                    return macro.instanceId !== nodeId && macro.childId !== nodeId;
-                }
-                if (macro.type === 'path') {
-                    return !macro.steps.some(s => s.node === nodeId);
-                }
-                if (macro.type === 'fanOut') {
-                    return macro.source.node !== nodeId && !macro.targets.some(t => t.node === nodeId);
-                }
-                if (macro.type === 'fanIn') {
-                    return macro.target.node !== nodeId && !macro.sources.some(s => s.node === nodeId);
-                }
-                return true;
-            });
-            if (draft.macros.length === 0) {
-                delete draft.macros;
-            }
-        }
-    });
-}
-/**
- * Rename a node instance (updates all connections)
- *
- * @param ast - Workflow to modify
- * @param oldId - Current node ID
- * @param newId - New node ID
- * @returns Modified workflow
- * @throws {Error} If old ID doesn't exist or new ID already exists
- *
- * @example
- * ```typescript
- * const ast = renameNode(workflow, 'processor1', 'dataProcessor');
- * // All connections updated automatically
- * ```
- */
-export function renameNode(ast, oldId, newId) {
-    assertNodeExists(ast, oldId);
-    assertNodeNotExists(ast, newId);
-    return withoutValidation(ast, (draft) => {
-        // Update node instance ID
-        const node = draft.instances.find((n) => n.id === oldId);
-        node.id = newId;
-        // Update all connections
-        draft.connections.forEach((conn) => {
-            if (conn.from.node === oldId) {
-                conn.from.node = newId;
-            }
-            if (conn.to.node === oldId) {
-                conn.to.node = newId;
-            }
-        });
-        // Update scopes
-        if (draft.scopes) {
-            Object.keys(draft.scopes).forEach((scopeName) => {
-                draft.scopes[scopeName] = draft.scopes[scopeName].map((id) => id === oldId ? newId : id);
-            });
-        }
-        // Update macro references
-        if (draft.macros) {
-            for (const macro of draft.macros) {
-                if (macro.type === 'map') {
-                    if (macro.instanceId === oldId)
-                        macro.instanceId = newId;
-                    if (macro.childId === oldId)
-                        macro.childId = newId;
-                }
-                else if (macro.type === 'path') {
-                    macro.steps = macro.steps.map(s => s.node === oldId ? { ...s, node: newId } : s);
-                }
-                else if (macro.type === 'fanOut') {
-                    if (macro.source.node === oldId)
-                        macro.source.node = newId;
-                    for (const t of macro.targets) {
-                        if (t.node === oldId)
-                            t.node = newId;
-                    }
-                }
-                else if (macro.type === 'fanIn') {
-                    if (macro.target.node === oldId)
-                        macro.target.node = newId;
-                    for (const s of macro.sources) {
-                        if (s.node === oldId)
-                            s.node = newId;
-                    }
-                }
-            }
-        }
-    });
-}
-/**
- * Update a node instance
- *
- * @param ast - Workflow to modify
- * @param nodeId - ID of node to update
- * @param updates - Partial node instance to merge
- * @returns Modified workflow
- * @throws {Error} If node doesn't exist
- *
- * @example
- * ```typescript
- * const ast = updateNode(workflow, 'processor1', {
- *   config: { x: 100, y: 200, label: 'Main Processor' }
- * });
- * ```
- */
-export function updateNode(ast, nodeId, updates) {
-    assertNodeExists(ast, nodeId);
-    return withoutValidation(ast, (draft) => {
-        const node = draft.instances.find((n) => n.id === nodeId);
-        Object.assign(node, updates);
-    });
-}
-/**
- * Add multiple nodes at once.
- * Uses no validation to allow adding even when workflow has other errors.
- *
- * @param ast - Workflow to modify
- * @param nodes - Array of node instances to add
- * @returns Modified workflow
- */
-export function addNodes(ast, nodes) {
-    // Check for duplicate IDs only (eventual consistency model)
-    nodes.forEach((node) => {
-        assertNodeNotExists(ast, node.id);
-    });
-    // Use produce directly with simplified type to avoid excessive type instantiation
-    return produce(ast, (draft) => {
-        nodes.forEach((node) => {
-            draft.instances.push(node);
-        });
-    });
-}
-/**
- * Remove multiple nodes at once.
- * Uses minimal validation (only checks nodes exist) to allow deletion
- * even when the workflow has other validation errors.
- *
- * @param ast - Workflow to modify
- * @param nodeIds - Array of node IDs to remove
- * @returns Modified workflow
- */
-export function removeNodes(ast, nodeIds) {
-    // First, verify all nodes exist (fail fast with clear error)
-    nodeIds.forEach((nodeId) => {
-        assertNodeExists(ast, nodeId);
-    });
-    return withoutValidation(ast, (draft) => {
-        // Remove all nodes
-        draft.instances = draft.instances.filter((n) => !nodeIds.includes(n.id));
-        // Remove all connections
-        draft.connections = draft.connections.filter((conn) => !nodeIds.includes(conn.from.node) &&
-            !nodeIds.includes(conn.to.node));
-        // Remove from scopes
-        if (draft.scopes) {
-            Object.keys(draft.scopes).forEach((scopeName) => {
-                draft.scopes[scopeName] = draft.scopes[scopeName].filter((id) => !nodeIds.includes(id));
-            });
-        }
-    });
-}
-/**
- * Set node configuration
- *
- * @param ast - Workflow to modify
- * @param nodeId - ID of node to configure
- * @param config - Configuration to set
- * @returns Modified workflow
- */
-export function setNodeConfig(ast, nodeId, config) {
-    return updateNode(ast, nodeId, { config });
-}
-/**
- * Set node position (UI coordinates)
- *
- * @param ast - Workflow to modify
- * @param nodeId - ID of node to position (including virtual nodes "Start" and "Exit")
- * @param x - X coordinate
- * @param y - Y coordinate
- * @returns Modified workflow
- */
-export function setNodePosition(ast, nodeId, x, y) {
-    // Validate before mutation to avoid type instantiation issues inside callback
-    if (nodeId !== "Start" && nodeId !== "Exit") {
-        assertNodeExists(ast, nodeId);
-    }
-    return withoutValidation(ast, (draft) => {
-        // Handle Start/Exit virtual nodes
-        if (nodeId === "Start" || nodeId === "Exit") {
-            const uiField = nodeId === "Start" ? "startNode" : "exitNode";
-            draft.ui = {
-                ...draft.ui,
-                [uiField]: {
-                    ...draft.ui?.[uiField],
-                    x,
-                    y,
-                },
-            };
-            return;
-        }
-        // Regular nodes - find and update
-        const node = draft.instances.find((n) => n.id === nodeId);
-        if (!node)
-            return; // Already validated above
-        if (!node.config) {
-            node.config = {};
-        }
-        node.config.x = x;
-        node.config.y = y;
-    });
-}
-/**
- * Set node minimized state (UI state)
- *
- * @param ast - Workflow to modify
- * @param nodeId - ID of node to minimize/expand
- * @param minimized - Whether the node is minimized
- * @returns Modified workflow
- */
-export function setNodeMinimized(ast, nodeId, minimized) {
-    // Validate before mutation to avoid type instantiation issues inside callback
-    assertNodeExists(ast, nodeId);
-    return withoutValidation(ast, (draft) => {
-        const node = draft.instances.find((n) => n.id === nodeId);
-        if (!node)
-            return; // Already validated above
-        if (!node.config) {
-            node.config = {};
-        }
-        node.config.minimized = minimized;
-    });
-}
-/**
- * Set node label (UI display name)
- *
- * @param ast - Workflow to modify
- * @param nodeId - ID of node to label
- * @param label - Label to set (empty string or undefined clears the label)
- * @returns Modified workflow
- */
-export function setNodeLabel(ast, nodeId, label) {
-    // Validate before mutation to avoid type instantiation issues inside callback
-    assertNodeExists(ast, nodeId);
-    return withoutValidation(ast, (draft) => {
-        const node = draft.instances.find((n) => n.id === nodeId);
-        if (!node)
-            return; // Already validated above
-        if (!node.config) {
-            node.config = {};
-        }
-        // Set or clear the label
-        if (label) {
-            node.config.label = label;
-        }
-        else {
-            delete node.config.label;
-        }
-    });
-}
-/**
- * Set node size (UI state)
- *
- * @param ast - Workflow to modify
- * @param nodeId - ID of node to resize
- * @param width - Node width
- * @param height - Node height
- * @returns Modified workflow
- */
-export function setNodeSize(ast, nodeId, width, height) {
-    // Validate before mutation to avoid type instantiation issues inside callback
-    assertNodeExists(ast, nodeId);
-    return withoutValidation(ast, (draft) => {
-        const node = draft.instances.find((n) => n.id === nodeId);
-        if (!node)
-            return; // Already validated above
-        if (!node.config) {
-            node.config = {};
-        }
-        node.config.width = width;
-        node.config.height = height;
-    });
-}
-//# sourceMappingURL=nodes.js.map