@invect/core 0.0.1

package/dist/services/graph.service.js

@@ -0,0 +1,375 @@
+import { ValidationError } from "../types/common/errors.types.js";
+import { NodeExecutionStatus } from "../types/base.js";
+import { BaseLogger } from "../utils/logger.js";
+//#region src/services/graph.service.ts
+/**
+* Graph Service for flow topology analysis and dependency management
+* Provides utilities for topological sorting, cycle detection, and dependency resolution
+*/
+var GraphService = class GraphService {
+	static logger = new BaseLogger({ level: "debug" });
+	constructor(logger, nodeExecutionService) {
+		this.logger = logger;
+		this.nodeExecutionService = nodeExecutionService;
+		GraphService.logger = logger || new BaseLogger({ level: "debug" });
+	}
+	/**
+	* Perform topological sort on flow nodes to determine execution order
+	*/
+	static topologicalSort(nodes, edges) {
+		const nodeIds = nodes.map((n) => n.id);
+		const adjList = /* @__PURE__ */ new Map();
+		const inDegree = /* @__PURE__ */ new Map();
+		for (const nodeId of nodeIds) {
+			adjList.set(nodeId, []);
+			inDegree.set(nodeId, 0);
+		}
+		for (const edge of edges) {
+			const from = edge.source;
+			const to = edge.target;
+			if (adjList.has(from) && adjList.has(to)) {
+				const fromList = adjList.get(from);
+				if (fromList) fromList.push(to);
+				const currentInDegree = inDegree.get(to);
+				if (currentInDegree !== void 0) inDegree.set(to, currentInDegree + 1);
+			}
+		}
+		const queue = [];
+		const result = [];
+		for (const [nodeId, degree] of inDegree) if (degree === 0) queue.push(nodeId);
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (!current) break;
+			result.push(current);
+			const neighbors = adjList.get(current) || [];
+			for (const neighbor of neighbors) {
+				const currentInDegree = inDegree.get(neighbor);
+				if (currentInDegree !== void 0) {
+					const newInDegree = currentInDegree - 1;
+					inDegree.set(neighbor, newInDegree);
+					if (newInDegree === 0) queue.push(neighbor);
+				}
+			}
+		}
+		if (result.length !== nodeIds.length) throw new Error("Flow contains cycles and cannot be executed");
+		return result;
+	}
+	/**
+	* Mark downstream nodes as skipped (smart skipping)
+	* Used primarily for conditional flows (if-else nodes) to skip non-executed branches
+	* Only skips nodes if ALL their incoming edges come from skipped nodes
+	*/
+	markDownstreamNodesAsSkipped(nodeId, edges, skippedNodes, isFromIfElse = false) {
+		this.logger.debug("Marking downstream nodes as skipped", {
+			startNodeId: nodeId,
+			edgeCount: edges.length,
+			currentSkippedCount: skippedNodes.size,
+			isFromIfElse
+		});
+		const queue = [];
+		if (isFromIfElse) {
+			if (!skippedNodes.has(nodeId)) {
+				skippedNodes.add(nodeId);
+				this.logger.debug(`Marking node ${nodeId} as SKIPPED (from if-else branch)`);
+				GraphService.getOutgoingEdges(nodeId, edges).forEach((edge) => {
+					if (!skippedNodes.has(edge.target)) queue.push(edge.target);
+				});
+			}
+		} else GraphService.getOutgoingEdges(nodeId, edges).forEach((edge) => {
+			if (!skippedNodes.has(edge.target)) queue.push(edge.target);
+		});
+		while (queue.length > 0) {
+			const currentNodeId = queue.shift();
+			if (!currentNodeId) break;
+			if (this.shouldNodeBeSkipped(currentNodeId, edges, skippedNodes)) {
+				if (!skippedNodes.has(currentNodeId)) {
+					skippedNodes.add(currentNodeId);
+					this.logger.debug(`Marking node ${currentNodeId} as SKIPPED (all dependencies skipped)`);
+					GraphService.getOutgoingEdges(currentNodeId, edges).forEach((edge) => {
+						if (!skippedNodes.has(edge.target)) queue.push(edge.target);
+					});
+				}
+			} else this.logger.debug(`Node ${currentNodeId} NOT skipped (has non-skipped dependencies)`);
+		}
+		this.logger.debug("Completed marking downstream nodes as skipped", {
+			startNodeId: nodeId,
+			totalSkippedCount: skippedNodes.size,
+			isFromIfElse
+		});
+	}
+	/**
+	* Check if a node should be skipped based on its dependencies
+	* A node should only be skipped if ALL its incoming edges come from skipped nodes
+	*/
+	shouldNodeBeSkipped(nodeId, edges, skippedNodes) {
+		const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);
+		if (incomingEdges.length === 0) return false;
+		const allDependenciesSkipped = incomingEdges.every((edge) => skippedNodes.has(edge.source));
+		this.logger.debug(`Checking skip condition for node ${nodeId}`, {
+			nodeId,
+			incomingEdgeCount: incomingEdges.length,
+			skippedSources: incomingEdges.filter((edge) => skippedNodes.has(edge.source)).map((edge) => edge.source),
+			nonSkippedSources: incomingEdges.filter((edge) => !skippedNodes.has(edge.source)).map((edge) => edge.source),
+			allDependenciesSkipped
+		});
+		return allDependenciesSkipped;
+	}
+	/**
+	* Checks if a node is ready to execute based on dependency completion
+	*/
+	async isNodeReadyToExecute(nodeId, flowContext, executionId) {
+		this.logger.debug("Checking if node is ready to execute", {
+			nodeId,
+			executionId
+		});
+		if (!nodeId) throw new ValidationError("Node ID is required", "nodeId");
+		const { edges, nodeExecutionResults, skippedNodeIds, allNodeOutputs } = flowContext;
+		const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);
+		if (incomingEdges.length === 0) {
+			this.logger.debug("Node has no dependencies, ready to execute", { nodeId });
+			return true;
+		}
+		for (const edge of incomingEdges) {
+			const sourceNodeId = edge.source;
+			if (skippedNodeIds.has(sourceNodeId)) {
+				this.logger.debug("Dependency node is skipped, continuing", {
+					nodeId,
+					dependencyNodeId: sourceNodeId
+				});
+				continue;
+			}
+			if (nodeExecutionResults.has(sourceNodeId)) {
+				if (nodeExecutionResults.get(sourceNodeId)?.state === NodeExecutionStatus.PENDING) {
+					if (executionId) try {
+						const dependencyTrace = await this.nodeExecutionService.getNodeExecutionById(executionId);
+						if (dependencyTrace && dependencyTrace.status === NodeExecutionStatus.RUNNING) {
+							this.logger.debug("Dependency batch job still running", {
+								nodeId,
+								dependencyNodeId: sourceNodeId
+							});
+							return false;
+						}
+					} catch (error) {
+						this.logger.warn("Failed to check dependency trace status", {
+							nodeId,
+							dependencyNodeId: sourceNodeId,
+							error
+						});
+						return false;
+					}
+				}
+				continue;
+			}
+			if (executionId) try {
+				const dependencyTrace = await this.nodeExecutionService.getNodeExecutionById(executionId);
+				if (dependencyTrace) switch (dependencyTrace.status) {
+					case NodeExecutionStatus.RUNNING:
+						this.logger.debug("Dependency still running", {
+							nodeId,
+							dependencyNodeId: sourceNodeId
+						});
+						return false;
+					case NodeExecutionStatus.SUCCESS:
+						if (dependencyTrace.outputs) allNodeOutputs.set(sourceNodeId, dependencyTrace.outputs);
+						continue;
+					case NodeExecutionStatus.FAILED:
+						this.logger.debug("Dependency failed, node not ready", {
+							nodeId,
+							dependencyNodeId: sourceNodeId
+						});
+						return false;
+				}
+			} catch (error) {
+				this.logger.warn("Failed to check dependency status", {
+					nodeId,
+					dependencyNodeId: sourceNodeId,
+					error
+				});
+				return false;
+			}
+			this.logger.debug("Dependency not ready", {
+				nodeId,
+				dependencyNodeId: sourceNodeId
+			});
+			return false;
+		}
+		this.logger.debug("Node is ready to execute", { nodeId });
+		return true;
+	}
+	/**
+	* Checks if there are circular dependencies in the flow
+	*/
+	static hasCycleDetection(nodes, edges) {
+		if (!nodes || nodes.length === 0) return { hasCycle: false };
+		const adjList = {};
+		for (const node of nodes) adjList[node.id] = [];
+		for (const edge of edges) if (adjList[edge.source]) adjList[edge.source].push(edge.target);
+		const visited = /* @__PURE__ */ new Set();
+		const recursionStack = /* @__PURE__ */ new Set();
+		const dfs = (nodeId, path) => {
+			visited.add(nodeId);
+			recursionStack.add(nodeId);
+			path.push(nodeId);
+			const neighbors = adjList[nodeId] || [];
+			for (const neighbor of neighbors) if (!visited.has(neighbor)) {
+				const result = dfs(neighbor, [...path]);
+				if (result.hasCycle) return result;
+			} else if (recursionStack.has(neighbor)) {
+				const cycleStart = path.indexOf(neighbor);
+				return {
+					hasCycle: true,
+					cyclePath: [...path.slice(cycleStart), neighbor]
+				};
+			}
+			recursionStack.delete(nodeId);
+			return { hasCycle: false };
+		};
+		for (const node of nodes) if (!visited.has(node.id)) {
+			const result = dfs(node.id, []);
+			if (result.hasCycle) return result;
+		}
+		return { hasCycle: false };
+	}
+	/**
+	* Finds all nodes that are not connected to any output node
+	*/
+	static findDisconnectedNodes(nodes, edges, outputNodeType) {
+		GraphService.logger.debug("Finding disconnected nodes", {
+			nodeCount: nodes.length,
+			edgeCount: edges.length,
+			outputNodeType
+		});
+		if (!nodes || nodes.length === 0) return [];
+		const outputNodes = nodes.filter((node) => node.type === outputNodeType);
+		if (outputNodes.length === 0) {
+			const allNodeIds = nodes.map((n) => n.id);
+			GraphService.logger.warn("No output nodes found, all nodes are disconnected", { disconnectedNodes: allNodeIds });
+			return allNodeIds;
+		}
+		const connectedNodes = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [...outputNodes.map((n) => n.id)];
+		while (queue.length > 0) {
+			const nodeId = queue.shift();
+			if (!nodeId) break;
+			if (visited.has(nodeId)) continue;
+			visited.add(nodeId);
+			connectedNodes.add(nodeId);
+			const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);
+			for (const edge of incomingEdges) if (!visited.has(edge.source)) queue.push(edge.source);
+		}
+		const disconnectedNodes = nodes.filter((node) => node.type !== outputNodeType && !connectedNodes.has(node.id)).map((node) => node.id);
+		GraphService.logger.debug("Disconnected nodes found", {
+			disconnectedNodes,
+			connectedNodeCount: connectedNodes.size
+		});
+		return disconnectedNodes;
+	}
+	/**
+	* Gets incoming edges for a specific node
+	*/
+	static getIncomingEdges(nodeId, edges) {
+		return edges.filter((edge) => edge.target === nodeId);
+	}
+	/**
+	* Gets outgoing edges for a specific node
+	*/
+	static getOutgoingEdges(nodeId, edges) {
+		return edges.filter((edge) => edge.source === nodeId);
+	}
+	/**
+	* Checks if a node type requires structured input (for validation)
+	*/
+	nodeRequiresStructuredInput(nodeType) {
+		return ["ifElseNode", "jqNode"].includes(nodeType);
+	}
+	/**
+	* Checks if any remaining nodes have running dependencies
+	*/
+	async checkForRunningDependencies(remainingNodeIds, edges, runningDependencyCheckFn) {
+		this.logger.debug("Checking for running dependencies", { remainingNodeCount: remainingNodeIds.length });
+		for (const nodeId of remainingNodeIds) {
+			const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);
+			for (const edge of incomingEdges) try {
+				if (await runningDependencyCheckFn(edge.source)) {
+					this.logger.debug("Found running dependency", {
+						nodeId,
+						dependencyNodeId: edge.source
+					});
+					return true;
+				}
+			} catch (error) {
+				this.logger.warn("Failed to check running dependency", {
+					nodeId,
+					dependencyNodeId: edge.source,
+					error
+				});
+			}
+		}
+		this.logger.debug("No running dependencies found");
+		return false;
+	}
+	/**
+	* Gets all terminal nodes (nodes with no outgoing edges)
+	*/
+	getTerminalNodes(nodes, edges) {
+		return nodes.filter((n) => !edges.some((e) => e.source === n.id));
+	}
+	/**
+	* Gets immediate dependents of a node
+	*/
+	getNodeDependents(nodeId, edges) {
+		return GraphService.getOutgoingEdges(nodeId, edges).map((edge) => edge.target);
+	}
+	/**
+	* Gets all downstream nodes (all nodes reachable from this node)
+	*/
+	getDownstreamNodes(nodeId, edges) {
+		const visited = /* @__PURE__ */ new Set();
+		const downstream = [];
+		const dfs = (currentNodeId) => {
+			const dependents = this.getNodeDependents(currentNodeId, edges);
+			for (const dependent of dependents) if (!visited.has(dependent)) {
+				visited.add(dependent);
+				downstream.push(dependent);
+				dfs(dependent);
+			}
+		};
+		dfs(nodeId);
+		return downstream;
+	}
+	/**
+	* Gets immediate dependencies of a node (nodes that feed into this node)
+	*/
+	getNodeDependencies(nodeId, edges) {
+		return GraphService.getIncomingEdges(nodeId, edges).map((edge) => edge.source);
+	}
+	/**
+	* Gets all upstream nodes (all nodes that this node depends on, directly or indirectly)
+	* Returns nodes in topological order (dependencies first)
+	*/
+	getUpstreamNodes(nodeId, nodes, edges) {
+		const visited = /* @__PURE__ */ new Set();
+		const upstream = [];
+		const dfs = (currentNodeId) => {
+			const dependencies = this.getNodeDependencies(currentNodeId, edges);
+			for (const dependency of dependencies) if (!visited.has(dependency)) {
+				visited.add(dependency);
+				dfs(dependency);
+				upstream.push(dependency);
+			}
+		};
+		dfs(nodeId);
+		return upstream;
+	}
+	/**
+	* Gets all upstream nodes plus the target node, in topological execution order
+	*/
+	getExecutionPathToNode(targetNodeId, nodes, edges) {
+		return [...this.getUpstreamNodes(targetNodeId, nodes, edges), targetNodeId];
+	}
+};
+//#endregion
+export { GraphService };
+
+//# sourceMappingURL=graph.service.js.map

package/dist/services/graph.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.service.js","names":[],"sources":["../../src/services/graph.service.ts"],"sourcesContent":["import { FlowRunContext } from 'src/types-fresh';\nimport { NodeExecutionStatus } from 'src/types/base';\nimport { ValidationError } from 'src/types/common/errors.types';\nimport { Logger } from 'src/types/schemas';\nimport { NodeExecutionService } from './node-executions/node-execution.service';\nimport { BaseLogger } from 'src/utils/logger';\nimport { FlowEdge, FlowNodeDefinitions } from './flow-versions/schemas-fresh';\n\n/**\n * Graph Service for flow topology analysis and dependency management\n * Provides utilities for topological sorting, cycle detection, and dependency resolution\n */\nexport class GraphService {\n  static logger: Logger = new BaseLogger({ level: 'debug' });\n\n  constructor(\n    private readonly logger: Logger,\n    private readonly nodeExecutionService: NodeExecutionService,\n  ) {\n    GraphService.logger = logger || new BaseLogger({ level: 'debug' });\n  }\n\n  /**\n   * Perform topological sort on flow nodes to determine execution order\n   */\n  static topologicalSort(\n    nodes: readonly FlowNodeDefinitions[],\n    edges: readonly FlowEdge[],\n  ): string[] {\n    const nodeIds = nodes.map((n) => n.id);\n    const adjList = new Map<string, string[]>();\n    const inDegree = new Map<string, number>();\n\n    // Initialize adjacency list and in-degree count\n    for (const nodeId of nodeIds) {\n      adjList.set(nodeId, []);\n      inDegree.set(nodeId, 0);\n    }\n\n    // Build adjacency list and calculate in-degrees\n    for (const edge of edges) {\n      const from = edge.source;\n      const to = edge.target;\n\n      if (adjList.has(from) && adjList.has(to)) {\n        const fromList = adjList.get(from);\n        if (fromList) {\n          fromList.push(to);\n        }\n        const currentInDegree = inDegree.get(to);\n        if (currentInDegree !== undefined) {\n          inDegree.set(to, currentInDegree + 1);\n        }\n      }\n    }\n\n    // Kahn's algorithm for topological sorting\n    const queue: string[] = [];\n    const result: string[] = [];\n\n    // Find all nodes with no incoming edges\n    for (const [nodeId, degree] of inDegree) {\n      if (degree === 0) {\n        queue.push(nodeId);\n      }\n    }\n\n    while (queue.length > 0) {\n      const current = queue.shift();\n      if (!current) {\n        break;\n      }\n\n      result.push(current);\n\n      // Remove this node from the graph\n      const neighbors = adjList.get(current) || [];\n      for (const neighbor of neighbors) {\n        const currentInDegree = inDegree.get(neighbor);\n        if (currentInDegree !== undefined) {\n          const newInDegree = currentInDegree - 1;\n          inDegree.set(neighbor, newInDegree);\n          if (newInDegree === 0) {\n            queue.push(neighbor);\n          }\n        }\n      }\n    }\n\n    // Check for cycles\n    if (result.length !== nodeIds.length) {\n      throw new Error('Flow contains cycles and cannot be executed');\n    }\n\n    return result;\n  }\n\n  /**\n   * Mark downstream nodes as skipped (smart skipping)\n   * Used primarily for conditional flows (if-else nodes) to skip non-executed branches\n   * Only skips nodes if ALL their incoming edges come from skipped nodes\n   */\n  markDownstreamNodesAsSkipped(\n    nodeId: string,\n    edges: readonly FlowEdge[],\n    skippedNodes: Set<string>,\n    isFromIfElse: boolean | undefined = false,\n  ): void {\n    this.logger.debug('Marking downstream nodes as skipped', {\n      startNodeId: nodeId,\n      edgeCount: edges.length,\n      currentSkippedCount: skippedNodes.size,\n      isFromIfElse,\n    });\n\n    const queue: string[] = [];\n\n    if (isFromIfElse) {\n      // When called from if-else node, mark the starting node itself as skipped\n      // (the starting node is the first node on the non-executed branch)\n      if (!skippedNodes.has(nodeId)) {\n        skippedNodes.add(nodeId);\n        this.logger.debug(`Marking node ${nodeId} as SKIPPED (from if-else branch)`);\n\n        // Add its downstream nodes to queue for further processing\n        const outgoingEdges = GraphService.getOutgoingEdges(nodeId, edges);\n        outgoingEdges.forEach((edge) => {\n          if (!skippedNodes.has(edge.target)) {\n            queue.push(edge.target);\n          }\n        });\n      }\n    } else {\n      // Otherwise, start with the immediate downstream nodes\n      const outgoingEdges = GraphService.getOutgoingEdges(nodeId, edges);\n      outgoingEdges.forEach((edge) => {\n        if (!skippedNodes.has(edge.target)) {\n          queue.push(edge.target);\n        }\n      });\n    }\n\n    // Smart breadth-first traversal with dependency checking\n    while (queue.length > 0) {\n      const currentNodeId = queue.shift();\n      if (!currentNodeId) {\n        break;\n      }\n\n      // Only skip if ALL incoming edges come from skipped nodes\n      if (this.shouldNodeBeSkipped(currentNodeId, edges, skippedNodes)) {\n        if (!skippedNodes.has(currentNodeId)) {\n          skippedNodes.add(currentNodeId);\n          this.logger.debug(`Marking node ${currentNodeId} as SKIPPED (all dependencies skipped)`);\n\n          // Add downstream nodes to queue only if this node was actually skipped\n          const outgoingEdges = GraphService.getOutgoingEdges(currentNodeId, edges);\n          outgoingEdges.forEach((edge) => {\n            if (!skippedNodes.has(edge.target)) {\n              queue.push(edge.target);\n            }\n          });\n        }\n      } else {\n        this.logger.debug(`Node ${currentNodeId} NOT skipped (has non-skipped dependencies)`);\n      }\n    }\n\n    this.logger.debug('Completed marking downstream nodes as skipped', {\n      startNodeId: nodeId,\n      totalSkippedCount: skippedNodes.size,\n      isFromIfElse,\n    });\n  }\n\n  /**\n   * Check if a node should be skipped based on its dependencies\n   * A node should only be skipped if ALL its incoming edges come from skipped nodes\n   */\n  private shouldNodeBeSkipped(\n    nodeId: string,\n    edges: readonly FlowEdge[],\n    skippedNodes: Set<string>,\n  ): boolean {\n    const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);\n\n    // If node has no incoming edges, it should not be skipped (it's a root node)\n    if (incomingEdges.length === 0) {\n      return false;\n    }\n\n    // Check if ALL incoming edges come from skipped nodes\n    const allDependenciesSkipped = incomingEdges.every((edge) => skippedNodes.has(edge.source));\n\n    this.logger.debug(`Checking skip condition for node ${nodeId}`, {\n      nodeId,\n      incomingEdgeCount: incomingEdges.length,\n      skippedSources: incomingEdges\n        .filter((edge) => skippedNodes.has(edge.source))\n        .map((edge) => edge.source),\n      nonSkippedSources: incomingEdges\n        .filter((edge) => !skippedNodes.has(edge.source))\n        .map((edge) => edge.source),\n      allDependenciesSkipped,\n    });\n\n    return allDependenciesSkipped;\n  }\n\n  /**\n   * Checks if a node is ready to execute based on dependency completion\n   */\n  async isNodeReadyToExecute(\n    nodeId: string,\n    flowContext: FlowRunContext,\n    executionId?: string,\n  ): Promise<boolean> {\n    this.logger.debug('Checking if node is ready to execute', { nodeId, executionId });\n\n    if (!nodeId) {\n      throw new ValidationError('Node ID is required', 'nodeId');\n    }\n\n    const { edges, nodeExecutionResults, skippedNodeIds, allNodeOutputs } = flowContext;\n\n    // Get incoming edges for this node\n    const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);\n\n    if (incomingEdges.length === 0) {\n      // TODO: maybe should skip if this is not an input node?\n      this.logger.debug('Node has no dependencies, ready to execute', { nodeId });\n      return true; // No dependencies\n    }\n\n    // Check if all dependency nodes have completed\n    for (const edge of incomingEdges) {\n      const sourceNodeId = edge.source;\n\n      // If the source node is skipped, that's okay\n      if (skippedNodeIds.has(sourceNodeId)) {\n        this.logger.debug('Dependency node is skipped, continuing', {\n          nodeId,\n          dependencyNodeId: sourceNodeId,\n        });\n        continue;\n      }\n\n      // If we have the output, check if it's a batch output or actual output\n      if (nodeExecutionResults.has(sourceNodeId)) {\n        const executionResult = nodeExecutionResults.get(sourceNodeId);\n\n        // Check if this is a batch submission\n        if (executionResult?.state === NodeExecutionStatus.PENDING) {\n          // This is a batch job that hasn't completed yet\n          // Check the database for the actual status\n          if (executionId) {\n            try {\n              const dependencyTrace =\n                await this.nodeExecutionService.getNodeExecutionById(executionId);\n\n              if (dependencyTrace && dependencyTrace.status === NodeExecutionStatus.RUNNING) {\n                this.logger.debug('Dependency batch job still running', {\n                  nodeId,\n                  dependencyNodeId: sourceNodeId,\n                });\n                return false;\n              }\n            } catch (error) {\n              this.logger.warn('Failed to check dependency trace status', {\n                nodeId,\n                dependencyNodeId: sourceNodeId,\n                error,\n              });\n              return false;\n            }\n          }\n          // If no trace or trace shows completion, fall through to continue\n        }\n\n        // Normal output - dependency is ready\n        continue;\n      }\n\n      // If we have executionId and database service, check database for dependency status\n      if (executionId) {\n        try {\n          const dependencyTrace = await this.nodeExecutionService.getNodeExecutionById(executionId);\n\n          if (dependencyTrace) {\n            switch (dependencyTrace.status) {\n              case NodeExecutionStatus.RUNNING:\n                this.logger.debug('Dependency still running', {\n                  nodeId,\n                  dependencyNodeId: sourceNodeId,\n                });\n                return false;\n              case NodeExecutionStatus.SUCCESS:\n                // Add output to nodeOutputs if we have it\n                if (dependencyTrace.outputs) {\n                  allNodeOutputs.set(sourceNodeId, dependencyTrace.outputs);\n                }\n                continue;\n              case NodeExecutionStatus.FAILED:\n                this.logger.debug('Dependency failed, node not ready', {\n                  nodeId,\n                  dependencyNodeId: sourceNodeId,\n                });\n                return false;\n            }\n          }\n        } catch (error) {\n          this.logger.warn('Failed to check dependency status', {\n            nodeId,\n            dependencyNodeId: sourceNodeId,\n            error,\n          });\n          return false;\n        }\n      }\n\n      // Dependency not ready\n      this.logger.debug('Dependency not ready', {\n        nodeId,\n        dependencyNodeId: sourceNodeId,\n      });\n      return false;\n    }\n\n    this.logger.debug('Node is ready to execute', { nodeId });\n    return true;\n  }\n\n  /**\n   * Checks if there are circular dependencies in the flow\n   */\n  static hasCycleDetection(\n    nodes: readonly FlowNodeDefinitions[],\n    edges: readonly FlowEdge[],\n  ): { hasCycle: boolean; cyclePath?: string[] } {\n    if (!nodes || nodes.length === 0) {\n      return { hasCycle: false };\n    }\n\n    const adjList: Record<string, string[]> = {};\n\n    // Initialize adjacency list\n    for (const node of nodes) {\n      adjList[node.id] = [];\n    }\n\n    // Build adjacency list\n    for (const edge of edges) {\n      if (adjList[edge.source]) {\n        adjList[edge.source].push(edge.target);\n      }\n    }\n\n    const visited = new Set<string>();\n    const recursionStack = new Set<string>();\n\n    const dfs = (nodeId: string, path: string[]): { hasCycle: boolean; cyclePath?: string[] } => {\n      visited.add(nodeId);\n      recursionStack.add(nodeId);\n      path.push(nodeId);\n\n      const neighbors = adjList[nodeId] || [];\n      for (const neighbor of neighbors) {\n        if (!visited.has(neighbor)) {\n          const result = dfs(neighbor, [...path]);\n          if (result.hasCycle) {\n            return result;\n          }\n        } else if (recursionStack.has(neighbor)) {\n          // Found a cycle\n          const cycleStart = path.indexOf(neighbor);\n          const cyclePath = [...path.slice(cycleStart), neighbor];\n\n          return {\n            hasCycle: true,\n            cyclePath,\n          };\n        }\n      }\n\n      recursionStack.delete(nodeId);\n      return { hasCycle: false };\n    };\n\n    // Check each unvisited node\n    for (const node of nodes) {\n      if (!visited.has(node.id)) {\n        const result = dfs(node.id, []);\n        if (result.hasCycle) {\n          return result;\n        }\n      }\n    }\n\n    return { hasCycle: false };\n  }\n\n  /**\n   * Finds all nodes that are not connected to any output node\n   */\n  static findDisconnectedNodes(\n    nodes: readonly FlowNodeDefinitions[],\n    edges: readonly FlowEdge[],\n    outputNodeType: string,\n  ): string[] {\n    GraphService.logger.debug('Finding disconnected nodes', {\n      nodeCount: nodes.length,\n      edgeCount: edges.length,\n      outputNodeType,\n    });\n\n    if (!nodes || nodes.length === 0) {\n      return [];\n    }\n\n    // Find all output nodes\n    const outputNodes = nodes.filter((node) => node.type === outputNodeType);\n\n    if (outputNodes.length === 0) {\n      const allNodeIds = nodes.map((n) => n.id);\n      GraphService.logger.warn('No output nodes found, all nodes are disconnected', {\n        disconnectedNodes: allNodeIds,\n      });\n      return allNodeIds; // All nodes are disconnected if no output nodes\n    }\n\n    // Find all nodes that can reach an output node\n    const connectedNodes = new Set<string>();\n\n    // Start from output nodes and work backwards\n    const visited = new Set<string>();\n    const queue = [...outputNodes.map((n) => n.id)];\n\n    while (queue.length > 0) {\n      const nodeId = queue.shift();\n      if (!nodeId) {\n        break;\n      }\n\n      if (visited.has(nodeId)) {\n        continue;\n      }\n\n      visited.add(nodeId);\n      connectedNodes.add(nodeId);\n\n      // Find all edges that lead to this node\n      const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);\n      for (const edge of incomingEdges) {\n        if (!visited.has(edge.source)) {\n          queue.push(edge.source);\n        }\n      }\n    }\n\n    // Return nodes that are not connected to any output\n    const disconnectedNodes = nodes\n      .filter((node) => node.type !== outputNodeType && !connectedNodes.has(node.id))\n      .map((node) => node.id);\n\n    GraphService.logger.debug('Disconnected nodes found', {\n      disconnectedNodes,\n      connectedNodeCount: connectedNodes.size,\n    });\n\n    return disconnectedNodes;\n  }\n\n  /**\n   * Gets incoming edges for a specific node\n   */\n  static getIncomingEdges(nodeId: string, edges: readonly FlowEdge[]): FlowEdge[] {\n    return edges.filter((edge) => edge.target === nodeId);\n  }\n\n  /**\n   * Gets outgoing edges for a specific node\n   */\n  static getOutgoingEdges(nodeId: string, edges: readonly FlowEdge[]): FlowEdge[] {\n    return edges.filter((edge) => edge.source === nodeId);\n  }\n\n  /**\n   * Checks if a node type requires structured input (for validation)\n   */\n  nodeRequiresStructuredInput(nodeType: string): boolean {\n    // Node types that require structured JSON input\n    const structuredInputTypes = ['ifElseNode', 'jqNode'];\n    return structuredInputTypes.includes(nodeType);\n  }\n\n  /**\n   * Checks if any remaining nodes have running dependencies\n   */\n  async checkForRunningDependencies(\n    remainingNodeIds: string[],\n    edges: FlowEdge[],\n    runningDependencyCheckFn: (nodeId: string) => Promise<boolean>,\n  ): Promise<boolean> {\n    this.logger.debug('Checking for running dependencies', {\n      remainingNodeCount: remainingNodeIds.length,\n    });\n\n    // Check if any of the remaining nodes have dependencies that are still running\n    for (const nodeId of remainingNodeIds) {\n      const incomingEdges = GraphService.getIncomingEdges(nodeId, edges);\n\n      for (const edge of incomingEdges) {\n        try {\n          const isRunning = await runningDependencyCheckFn(edge.source);\n          if (isRunning) {\n            this.logger.debug('Found running dependency', {\n              nodeId,\n              dependencyNodeId: edge.source,\n            });\n            return true; // Found a running dependency\n          }\n        } catch (error) {\n          this.logger.warn('Failed to check running dependency', {\n            nodeId,\n            dependencyNodeId: edge.source,\n            error,\n          });\n        }\n      }\n    }\n\n    this.logger.debug('No running dependencies found');\n    return false;\n  }\n\n  /**\n   * Gets all terminal nodes (nodes with no outgoing edges)\n   */\n  getTerminalNodes(\n    nodes: readonly FlowNodeDefinitions[],\n    edges: readonly FlowEdge[],\n  ): FlowNodeDefinitions[] {\n    return nodes.filter((n) => !edges.some((e) => e.source === n.id));\n  }\n\n  /**\n   * Gets immediate dependents of a node\n   */\n  getNodeDependents(nodeId: string, edges: readonly FlowEdge[]): string[] {\n    return GraphService.getOutgoingEdges(nodeId, edges).map((edge) => edge.target);\n  }\n\n  /**\n   * Gets all downstream nodes (all nodes reachable from this node)\n   */\n  getDownstreamNodes(nodeId: string, edges: readonly FlowEdge[]): string[] {\n    const visited = new Set<string>();\n    const downstream: string[] = [];\n\n    const dfs = (currentNodeId: string) => {\n      const dependents = this.getNodeDependents(currentNodeId, edges);\n\n      for (const dependent of dependents) {\n        if (!visited.has(dependent)) {\n          visited.add(dependent);\n          downstream.push(dependent);\n          dfs(dependent); // Recursively find downstream nodes\n        }\n      }\n    };\n\n    dfs(nodeId);\n    return downstream;\n  }\n\n  /**\n   * Gets immediate dependencies of a node (nodes that feed into this node)\n   */\n  getNodeDependencies(nodeId: string, edges: readonly FlowEdge[]): string[] {\n    return GraphService.getIncomingEdges(nodeId, edges).map((edge) => edge.source);\n  }\n\n  /**\n   * Gets all upstream nodes (all nodes that this node depends on, directly or indirectly)\n   * Returns nodes in topological order (dependencies first)\n   */\n  getUpstreamNodes(\n    nodeId: string,\n    nodes: readonly FlowNodeDefinitions[],\n    edges: readonly FlowEdge[],\n  ): string[] {\n    const visited = new Set<string>();\n    const upstream: string[] = [];\n\n    const dfs = (currentNodeId: string) => {\n      const dependencies = this.getNodeDependencies(currentNodeId, edges);\n\n      for (const dependency of dependencies) {\n        if (!visited.has(dependency)) {\n          visited.add(dependency);\n          dfs(dependency); // Recursively find upstream nodes first\n          upstream.push(dependency); // Add after dependencies (topological order)\n        }\n      }\n    };\n\n    dfs(nodeId);\n    return upstream;\n  }\n\n  /**\n   * Gets all upstream nodes plus the target node, in topological execution order\n   */\n  getExecutionPathToNode(\n    targetNodeId: string,\n    nodes: readonly FlowNodeDefinitions[],\n    edges: readonly FlowEdge[],\n  ): string[] {\n    const upstreamNodes = this.getUpstreamNodes(targetNodeId, nodes, edges);\n    return [...upstreamNodes, targetNodeId];\n  }\n}\n"],"mappings":"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"}

package/dist/services/node-data.service.cjs

@@ -0,0 +1,232 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_errors_types = require("../types/common/errors.types.cjs");
+const require_ai_types = require("./ai/ai-types.cjs");
+require("./ai/base-client.cjs");
+let json_logic_js = require("json-logic-js");
+json_logic_js = require_runtime.__toESM(json_logic_js);
+//#region src/services/node-data.service.ts
+/**
+* Node Data Service implementation
+* Provides testing and validation utilities for different node types
+*/
+var NodeDataService = class {
+	initialized = false;
+	cachedListModels = null;
+	cachedProviderModels = /* @__PURE__ */ new Map();
+	lastFetchTime = 0;
+	CACHE_DURATION = 3600 * 1e3;
+	constructor(config, logger, databaseService, aiClient, templateService) {
+		this.config = config;
+		this.logger = logger;
+		this.databaseService = databaseService;
+		this.aiClient = aiClient;
+		this.templateService = templateService;
+	}
+	/**
+	* Initialize the service
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.logger.debug("NodeDataService already initialized");
+			return;
+		}
+		this.logger.info("Initializing NodeDataService");
+		try {
+			if (!this.databaseService) throw new require_errors_types.DatabaseError("Database service is required for NodeDataService");
+			this.initialized = true;
+			this.logger.info("NodeDataService initialized successfully");
+		} catch (error) {
+			this.logger.error("Failed to initialize NodeDataService", error);
+			throw error;
+		}
+	}
+	/**
+	* Close the service
+	*/
+	async close() {
+		if (!this.initialized) {
+			this.logger.debug("NodeDataService not initialized, nothing to close");
+			return;
+		}
+		this.logger.info("Closing NodeDataService");
+		this.initialized = false;
+		this.cachedListModels = null;
+		this.logger.info("NodeDataService closed successfully");
+	}
+	/**
+	* Execute a database query using credential-based connection config
+	*/
+	async runSqlQuery({ query, connectionConfig }) {
+		this.ensureInitialized();
+		try {
+			const dbType = connectionConfig.type === "postgres" ? "postgresql" : connectionConfig.type;
+			const dbConfig = {
+				id: `credential-${connectionConfig.type}`,
+				type: dbType,
+				connectionString: connectionConfig.connectionString
+			};
+			const result = await this.databaseService.executeQuery(query, dbConfig);
+			const columns = result.length > 0 ? Object.keys(result[0]) : [];
+			const rowCount = result.length;
+			this.logger.debug("Query executed successfully", {
+				rowCount,
+				columnCount: columns.length,
+				databaseType: connectionConfig.type
+			});
+			return {
+				success: true,
+				data: result,
+				columns,
+				rowCount,
+				query
+			};
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.logger.error("Database query failed", {
+				error: errorMessage,
+				query
+			});
+			return {
+				success: false,
+				error: errorMessage,
+				query
+			};
+		}
+	}
+	/**
+	* Get available databases
+	*/
+	getAvailableDatabases() {
+		this.ensureInitialized();
+		if (!this.config.queryDatabases || this.config.queryDatabases.length === 0) return [this.config.baseDatabaseConfig];
+		return this.config.queryDatabases;
+	}
+	async runTemplateReplacement(template, variables) {
+		this.ensureInitialized();
+		try {
+			if (this.templateService) {
+				const result = this.templateService.render(template, variables);
+				this.logger.debug("Template processed successfully", { templateLength: template.length });
+				if (result === null || result === void 0) return "";
+				if (typeof result === "object") return JSON.stringify(result);
+				return String(result);
+			}
+			this.logger.warn("TemplateService not available, returning template unprocessed");
+			return template;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.logger.error("Template processing failed", {
+				error: errorMessage,
+				template
+			});
+			throw new Error(`Template processing failed: ${errorMessage}`);
+		}
+	}
+	/**
+	* Helper method to safely parse JSON
+	*/
+	tryParseJSON(text) {
+		try {
+			return JSON.parse(text);
+		} catch {
+			return;
+		}
+	}
+	testJsonLogic(conditionLogic, evaluationData) {
+		this.ensureInitialized();
+		try {
+			const result = json_logic_js.default.apply(conditionLogic, evaluationData);
+			return Boolean(result);
+		} catch (error) {
+			this.logger.error("JSON Logic evaluation failed", {
+				error: error instanceof Error ? error.message : String(error),
+				conditionLogic,
+				evaluationData
+			});
+			return false;
+		}
+	}
+	/**
+	* Get available models
+	*/
+	async getAvailableModels() {
+		this.ensureInitialized();
+		const now = Date.now();
+		if (this.cachedListModels && now - this.lastFetchTime < this.CACHE_DURATION) return this.cachedListModels;
+		try {
+			const configuredProviders = this.getConfiguredProviders();
+			const aggregatedModels = [];
+			let defaultModel;
+			if (configuredProviders.length === 0) this.logger.warn("No AI providers configured. Returning empty model list");
+			for (const provider of configuredProviders) try {
+				const providerResult = await this.getModelsForProvider(provider);
+				aggregatedModels.push(...providerResult.models);
+				if (!defaultModel) defaultModel = providerResult.defaultModel;
+			} catch (error) {
+				this.logger.warn(`Failed to fetch models for provider ${provider}`, error);
+			}
+			if (!defaultModel) defaultModel = aggregatedModels[0]?.id || "No model available";
+			const result = {
+				models: aggregatedModels,
+				defaultModel
+			};
+			this.cachedListModels = result;
+			this.lastFetchTime = now;
+			this.logger.debug("Retrieved available models", { count: result.models.length });
+			return result;
+		} catch (error) {
+			this.logger.error("Failed to get available models", error);
+			return this.cachedListModels || {
+				models: [],
+				defaultModel: "No model available"
+			};
+		}
+	}
+	async getModelsForProvider(provider) {
+		this.ensureInitialized();
+		const cached = this.cachedProviderModels.get(provider);
+		const now = Date.now();
+		if (cached && now - cached.fetchedAt < this.CACHE_DURATION) return {
+			models: cached.models,
+			defaultModel: cached.defaultModel
+		};
+		const providerResult = await this.aiClient.listModelsForProvider(provider);
+		const filteredModels = this.filterChatCompletionModels(provider, providerResult.models);
+		this.cachedProviderModels.set(provider, {
+			models: filteredModels,
+			defaultModel: providerResult.defaultModel,
+			fetchedAt: now
+		});
+		return {
+			models: filteredModels,
+			defaultModel: providerResult.defaultModel
+		};
+	}
+	filterChatCompletionModels(provider, models) {
+		if (models.length === 0) return models;
+		if (provider === require_ai_types.BatchProvider.OPENAI) return models.filter((model) => {
+			const id = model.id.toLowerCase();
+			if (!id.startsWith("gpt")) return false;
+			return !/(audio|embedding|search|tts|vision)/.test(id);
+		});
+		if (provider === require_ai_types.BatchProvider.ANTHROPIC) return models.filter((model) => model.id.toLowerCase().startsWith("claude"));
+		return models;
+	}
+	getConfiguredProviders() {
+		return [
+			require_ai_types.BatchProvider.OPENAI,
+			require_ai_types.BatchProvider.ANTHROPIC,
+			require_ai_types.BatchProvider.OPENROUTER
+		];
+	}
+	/**
+	* Ensure the service is initialized
+	*/
+	ensureInitialized() {
+		if (!this.initialized) throw new require_errors_types.ValidationError("NodeDataService not initialized. Call initialize() first.");
+	}
+};
+//#endregion
+exports.NodeDataService = NodeDataService;
+
+//# sourceMappingURL=node-data.service.cjs.map