flowcraft 1.0.0-beta.1

package/src/utils/graph.test.ts

@@ -0,0 +1,144 @@
+import type { NodeTypeMap, TypedWorkflowGraph } from '../builder/graph.types'
+import { describe, expect, it } from 'vitest'
+import { analyzeGraph, checkForCycles, createNodeRule } from './graph'
+
+describe('testGraphAnalysis', () => {
+	describe('analyzeGraph', () => {
+		it('should correctly analyze a simple linear graph', () => {
+			const graph: TypedWorkflowGraph<{ start: Record<string, never>, end: Record<string, never> }> = {
+				nodes: [{ id: 'a', type: 'start', data: {} }, { id: 'b', type: 'end', data: {} }],
+				edges: [{ source: 'a', target: 'b' }],
+			}
+			const analysis = analyzeGraph(graph)
+			expect(analysis.allNodeIds).toEqual(['a', 'b'])
+			expect(analysis.startNodeIds).toEqual(['a'])
+			expect(analysis.nodes.get('a')?.outDegree).toBe(1)
+			expect(analysis.nodes.get('a')?.inDegree).toBe(0)
+			expect(analysis.nodes.get('b')?.outDegree).toBe(0)
+			expect(analysis.nodes.get('b')?.inDegree).toBe(1)
+			expect(analysis.cycles).toEqual([])
+		})
+
+		it('should identify multiple start nodes', () => {
+			const graph: TypedWorkflowGraph<any> = {
+				nodes: [{ id: 'a', type: 'input', data: {} }, { id: 'b', type: 'input', data: {} }, { id: 'c', type: 'process', data: {} }],
+				edges: [{ source: 'a', target: 'c' }, { source: 'b', target: 'c' }],
+			}
+			const analysis = analyzeGraph(graph)
+			expect(analysis.startNodeIds).toEqual(expect.arrayContaining(['a', 'b']))
+			expect(analysis.nodes.get('c')?.inDegree).toBe(2)
+		})
+
+		it('should correctly identify a simple cycle', () => {
+			const graph: TypedWorkflowGraph<any> = {
+				nodes: [{ id: 'a', type: 'process', data: {} }, { id: 'b', type: 'process', data: {} }],
+				edges: [{ source: 'a', target: 'b' }, { source: 'b', target: 'a' }],
+			}
+			const analysis = analyzeGraph(graph)
+			expect(analysis.cycles.length).toBeGreaterThan(0)
+			expect(analysis.cycles).toContainEqual(['a', 'b', 'a'])
+		})
+
+		it('should handle an empty graph', () => {
+			const graph: TypedWorkflowGraph<any> = { nodes: [], edges: [] }
+			const analysis = analyzeGraph(graph)
+			expect(analysis.allNodeIds).toEqual([])
+			expect(analysis.startNodeIds).toEqual([])
+			expect(analysis.nodes.size).toBe(0)
+		})
+	})
+
+	describe('createNodeRule and Validator checks', () => {
+		const graph: TypedWorkflowGraph<any> = {
+			nodes: [
+				{ id: 'start', type: 'start', data: {} },
+				{ id: 'process', type: 'process', data: {} },
+				{ id: 'output', type: 'output', data: {} },
+				{ id: 'orphan', type: 'orphan', data: {} },
+			],
+			edges: [
+				{ source: 'start', target: 'process' },
+				{ source: 'process', target: 'output' },
+				{ source: 'output', target: 'orphan' }, // Invalid edge
+			],
+		}
+		const analysis = analyzeGraph(graph)
+
+		it('should create a rule that finds nodes with invalid out-degrees', () => {
+			const rule = createNodeRule(
+				'Output must be terminal',
+				node => node.type === 'output',
+				node => ({
+					valid: node.outDegree === 0,
+					message: `Output node '${node.id}' cannot have outgoing connections.`,
+				}),
+			)
+			const errors = rule(analysis, graph)
+			expect(errors).toHaveLength(1)
+			expect(errors[0].nodeId).toBe('output')
+			expect(errors[0].message).toContain('cannot have outgoing connections')
+		})
+	})
+
+	describe('checkForCycles validator', () => {
+		it('should return a validation error for each detected cycle', () => {
+			const graph: TypedWorkflowGraph<any> = {
+				nodes: [{ id: 'a', type: 'step', data: {} }, { id: 'b', type: 'step', data: {} }, { id: 'c', type: 'step', data: {} }],
+				edges: [
+					{ source: 'a', target: 'b' },
+					{ source: 'b', target: 'c' },
+					{ source: 'c', target: 'a' },
+				],
+			}
+			const analysis = analyzeGraph(graph)
+			const errors = checkForCycles(analysis, graph)
+			expect(errors).toHaveLength(1)
+			expect(errors[0].type).toBe('CycleDetected')
+			expect(errors[0].message).toContain('a -> b -> c -> a')
+		})
+	})
+
+	describe('type-Safe Validation with NodeTypeMap', () => {
+		// 1. Define a custom, type-safe map for our test nodes.
+		interface TestNodeTypeMap extends NodeTypeMap {
+			'api-call': { url: string, retries: number }
+			'data-transform': { mode: 'uppercase' | 'lowercase' }
+		}
+
+		// 2. Create a graph that uses this specific type map.
+		const typedGraph: TypedWorkflowGraph<TestNodeTypeMap> = {
+			nodes: [
+				{ id: 'fetch-user', type: 'api-call', data: { url: '/users/1', retries: 3 } }, // Valid
+				{ id: 'fetch-products', type: 'api-call', data: { url: '/products', retries: 0 } }, // Invalid retries
+				{ id: 'format-name', type: 'data-transform', data: { mode: 'uppercase' } },
+			],
+			edges: [],
+		}
+
+		it('should allow type-safe access to the data property in a rule', () => {
+			// 3. Create a type-safe rule that inspects the `data` property.
+			const rule = createNodeRule<TestNodeTypeMap>(
+				'API calls must have retries',
+				// The `node` is correctly typed here as a union of our specific node types
+				node => node.type === 'api-call',
+				// The `node` here is narrowed to just the 'api-call' type!
+				(node) => {
+					// `node.data.retries` is fully typed as `number` and autocompletes.
+					const valid = node.data.retries > 0
+					return {
+						valid,
+						message: `API call node '${node.id}' must have at least 1 retry.`,
+					}
+				},
+			)
+
+			const analysis = analyzeGraph(typedGraph)
+			const errors = rule(analysis, typedGraph)
+
+			// 4. Assert that only the invalid node was caught.
+			expect(errors).toHaveLength(1)
+			expect(errors[0].nodeId).toBe('fetch-products')
+			expect(errors[0].message).toContain('must have at least 1 retry')
+		})
+	})
+})

package/src/utils/graph.ts

@@ -0,0 +1,182 @@
+import type { GraphNode, NodeTypeMap, TypedGraphNode, TypedWorkflowGraph, WorkflowGraph } from '../builder/graph.types'
+
+/** The rich metadata object returned by the analyzeGraph function. */
+export interface GraphAnalysis<T extends NodeTypeMap = any> {
+	/** A map of all nodes, keyed by ID, augmented with their connection degrees. */
+	nodes: Map<string, TypedGraphNode<T> & { inDegree: number, outDegree: number }>
+	/** An array of all node IDs in the graph. */
+	allNodeIds: string[]
+	/** An array of node IDs that have no incoming edges. */
+	startNodeIds: string[]
+	/** A list of cycles found in the graph. Each cycle is an array of node IDs. */
+	cycles: string[][]
+}
+
+/** A standard structure for reporting a single validation error. */
+export interface ValidationError {
+	/** The ID of the node where the error occurred, if applicable. */
+	nodeId?: string
+	/** A category for the error, e.g., 'CycleDetected', 'ConnectionRuleViolation'. */
+	type: string
+	/** A human-readable message explaining the validation failure. */
+	message: string
+}
+
+/**
+ * A function that takes a graph analysis and the original graph,
+ * and returns an array of validation errors.
+ */
+export type Validator<T extends NodeTypeMap = any> = (
+	analysis: GraphAnalysis<T>,
+	graph: TypedWorkflowGraph<T>
+) => ValidationError[]
+
+/**
+ * A helper function that creates a type guard for filtering nodes by their type.
+ * This simplifies writing type-safe validation rules by removing the need for
+ * verbose, explicit type guard syntax.
+ *
+ * @param type The literal string of the node type to check for.
+ * @returns A type guard function that narrows the node to its specific type.
+ */
+export function isNodeType<T extends NodeTypeMap, K extends keyof T>(type: K) {
+	return (node: TypedGraphNode<T>): node is TypedGraphNode<T> & { type: K } => {
+		return node.type === type
+	}
+}
+
+/**
+ * Analyzes a declarative workflow graph definition to extract structural metadata.
+ * This is a lightweight, static utility that does not instantiate any nodes.
+ *
+ * @param graph The WorkflowGraph object containing nodes and edges.
+ * @returns A GraphAnalysis object containing nodes with degree counts, start nodes, and any cycles.
+ */
+// (Typesafe Overload) Analyzes a declarative workflow graph, preserving strong types.
+export function analyzeGraph<T extends NodeTypeMap>(graph: TypedWorkflowGraph<T>): GraphAnalysis<T>
+// (Untyped Overload) Analyzes a declarative workflow graph with basic types.
+export function analyzeGraph(graph: WorkflowGraph): GraphAnalysis
+// (Implementation) Analyzes a declarative workflow graph to extract structural metadata.
+export function analyzeGraph<T extends NodeTypeMap>(graph: TypedWorkflowGraph<T> | WorkflowGraph): GraphAnalysis<T> {
+	const typedGraph = graph as TypedWorkflowGraph<T> // Cast for internal consistency
+	const analysis: GraphAnalysis<T> = {
+		nodes: new Map(),
+		allNodeIds: [],
+		startNodeIds: [],
+		cycles: [],
+	}
+
+	if (!typedGraph || !typedGraph.nodes || !typedGraph.nodes.length)
+		return analysis
+
+	const allNodeIds = typedGraph.nodes.map(node => node.id)
+	analysis.allNodeIds = allNodeIds
+
+	const adj: Map<string, string[]> = new Map()
+	typedGraph.nodes.forEach((node) => {
+		analysis.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 })
+		adj.set(node.id, [])
+	})
+
+	typedGraph.edges.forEach((edge) => {
+		const source = analysis.nodes.get(edge.source)
+		const target = analysis.nodes.get(edge.target)
+		if (source)
+			source.outDegree++
+		if (target)
+			target.inDegree++
+		if (adj.has(edge.source))
+			adj.get(edge.source)!.push(edge.target)
+	})
+
+	analysis.startNodeIds = allNodeIds.filter(id => analysis.nodes.get(id)!.inDegree === 0)
+
+	const visited = new Set<string>()
+	const recursionStack = new Set<string>()
+	function detectCycleUtil(nodeId: string, path: string[]) {
+		visited.add(nodeId)
+		recursionStack.add(nodeId)
+		path.push(nodeId)
+
+		const neighbors = adj.get(nodeId) || []
+		for (const neighbor of neighbors) {
+			if (recursionStack.has(neighbor)) {
+				const cycleStartIndex = path.indexOf(neighbor)
+				const cycle = path.slice(cycleStartIndex)
+				analysis.cycles.push([...cycle, neighbor])
+			}
+			else if (!visited.has(neighbor)) {
+				detectCycleUtil(neighbor, path)
+			}
+		}
+
+		recursionStack.delete(nodeId)
+		path.pop()
+	}
+
+	for (const nodeId of allNodeIds) {
+		if (!visited.has(nodeId))
+			detectCycleUtil(nodeId, [])
+	}
+
+	return analysis
+}
+
+/**
+ * Factory for creating a generic, reusable validator that checks node properties.
+ *
+ * @param description A human-readable description of the rule for error messages.
+ * @param filter A predicate to select which nodes this rule applies to.
+ * @param check A function that validates the properties of a selected node.
+ * @returns A Validator function.
+ */
+// (Type-Safe Overload) Creates a validator with strong types based on a NodeTypeMap.
+export function createNodeRule<T extends NodeTypeMap>(
+	description: string,
+	filter: (node: TypedGraphNode<T>) => boolean,
+	check: (node: TypedGraphNode<T> & { inDegree: number, outDegree: number }) => { valid: boolean, message?: string },
+): Validator<T>
+// (Untyped Overload) Creates a validator with basic types.
+export function createNodeRule(
+	description: string,
+	filter: (node: GraphNode) => boolean,
+	check: (node: GraphNode & { inDegree: number, outDegree: number }) => { valid: boolean, message?: string },
+): Validator
+// (Implementation) Factory for creating a generic, reusable validator.
+export function createNodeRule(
+	description: string,
+	filter: (node: any) => boolean,
+	check: (node: any) => { valid: boolean, message?: string },
+): Validator {
+	return (analysis: GraphAnalysis, _graph: WorkflowGraph): ValidationError[] => {
+		const errors: ValidationError[] = []
+		for (const node of analysis.nodes.values()) {
+			if (filter(node)) {
+				const result = check(node)
+				if (!result.valid) {
+					errors.push({
+						nodeId: node.id,
+						type: 'ConnectionRuleViolation',
+						message: result.message || `Node ${node.id} failed rule: ${description}`,
+					})
+				}
+			}
+		}
+		return errors
+	}
+}
+
+/**
+ * A built-in validator that reports any cycles found in the graph.
+ */
+export const checkForCycles: Validator = (analysis) => {
+	const uniqueCycles = new Set(analysis.cycles.map(c => c.slice(0, -1).sort().join(',')))
+	return Array.from(uniqueCycles).map((cycleKey) => {
+		const representativeCycle = analysis.cycles.find(c => c.slice(0, -1).sort().join(',') === cycleKey)!
+		return {
+			nodeId: representativeCycle[0],
+			type: 'CycleDetected',
+			message: `Cycle detected involving nodes: ${representativeCycle.join(' -> ')}`,
+		}
+	})
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './graph'
+export * from './mermaid'
+export * from './sleep'

package/src/utils/mermaid.test.ts

@@ -0,0 +1,239 @@
+import type { AbstractNode } from '../workflow'
+import { describe, expect, it } from 'vitest'
+import { ParallelFlow } from '../builder'
+import { DEFAULT_ACTION, FILTER_FAILED, Flow, Node } from '../workflow'
+import { generateMermaidGraph } from './mermaid'
+
+// Define simple, named node classes to make test assertions clearer.
+class StartNode extends Node { }
+class ProcessNode extends Node { }
+class EndNode extends Node { }
+class DecisionNode extends Node { }
+class PathANode extends Node { }
+class PathBNode extends Node { }
+class PathCNode extends Node { } // For 3-way branch test
+class FailureNode extends Node { }
+class TopNode extends Node { } // For diamond test
+class LeftNode extends Node { } // For diamond test
+class RightNode extends Node { } // For diamond test
+class BottomNode extends Node { } // For diamond test
+
+describe('testGenerateMermaidGraph', () => {
+	it('should generate a correct graph for a simple linear flow', () => {
+		const startNode = new StartNode()
+		const processNode = new ProcessNode()
+		const endNode = new EndNode()
+		startNode.next(processNode).next(endNode)
+		const flow = new Flow(startNode)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('graph TD')
+		expect(result).toContain('StartNode_0[StartNode]')
+		expect(result).toContain('ProcessNode_0[ProcessNode]')
+		expect(result).toContain('EndNode_0[EndNode]')
+		expect(result).toContain('StartNode_0 --> ProcessNode_0')
+		expect(result).toContain('ProcessNode_0 --> EndNode_0')
+	})
+
+	it('should handle conditional branching with custom string actions', () => {
+		const decisionNode = new DecisionNode()
+		const pathANode = new PathANode()
+		const pathBNode = new PathBNode()
+		decisionNode.next(pathANode, 'action_a')
+		decisionNode.next(pathBNode, 'action_b')
+		const flow = new Flow(decisionNode)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('DecisionNode_0[DecisionNode]')
+		expect(result).toContain('PathANode_0[PathANode]')
+		expect(result).toContain('PathBNode_0[PathBNode]')
+		expect(result).toContain('DecisionNode_0 -- "action_a" --> PathANode_0')
+		expect(result).toContain('DecisionNode_0 -- "action_b" --> PathBNode_0')
+	})
+
+	it('should use special labels for FILTER_FAILED and DEFAULT_ACTION', () => {
+		const decisionNode = new DecisionNode()
+		const pathANode = new PathANode()
+		const failureNode = new FailureNode()
+		decisionNode.next(pathANode, DEFAULT_ACTION)
+		decisionNode.next(failureNode, FILTER_FAILED)
+		const flow = new Flow(decisionNode)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('DecisionNode_0 --> PathANode_0')
+		expect(result).toContain('DecisionNode_0 -- "filter failed" --> FailureNode_0')
+	})
+
+	it('should correctly represent a flow with a cycle', () => {
+		const startNode = new StartNode()
+		const processNode = new ProcessNode()
+		startNode.next(processNode)
+		processNode.next(startNode) // Loop back
+		const flow = new Flow(startNode)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('StartNode_0[StartNode]')
+		expect(result).toContain('ProcessNode_0[ProcessNode]')
+		expect(result).toContain('StartNode_0 --> ProcessNode_0')
+		expect(result).toContain('ProcessNode_0 --> StartNode_0')
+	})
+
+	it('should handle multiple nodes fanning into a single node', () => {
+		const decisionNode = new DecisionNode()
+		const pathANode = new PathANode()
+		const pathBNode = new PathBNode()
+		const endNode = new EndNode()
+		decisionNode.next(pathANode, 'a')
+		decisionNode.next(pathBNode, 'b')
+		pathANode.next(endNode)
+		pathBNode.next(endNode)
+		const flow = new Flow(decisionNode)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('PathANode_0 --> EndNode_0')
+		expect(result).toContain('PathBNode_0 --> EndNode_0')
+	})
+
+	it('should return a minimal graph for a flow with only a single node', () => {
+		const flow = new Flow(new StartNode())
+		const result = generateMermaidGraph(flow)
+		expect(result).toBe('graph TD\n  StartNode_0[StartNode]')
+	})
+
+	it('should return an empty graph definition for an empty flow', () => {
+		const flow = new Flow() // No start node
+		const result = generateMermaidGraph(flow)
+		expect(result).toBe('graph TD\n  %% Empty Flow')
+	})
+
+	it('should generate unique names for multiple instances of the same node class', () => {
+		const startNode = new ProcessNode()
+		const middleNode = new ProcessNode()
+		const endNode = new ProcessNode()
+		startNode.next(middleNode).next(endNode)
+		const flow = new Flow(startNode)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('ProcessNode_0[ProcessNode]')
+		expect(result).toContain('ProcessNode_1[ProcessNode]')
+		expect(result).toContain('ProcessNode_2[ProcessNode]')
+		expect(result).toContain('ProcessNode_0 --> ProcessNode_1')
+		expect(result).toContain('ProcessNode_1 --> ProcessNode_2')
+	})
+
+	it('should correctly render a diamond-shaped graph', () => {
+		const top = new TopNode()
+		const left = new LeftNode()
+		const right = new RightNode()
+		const bottom = new BottomNode()
+		top.next(left, 'go_left')
+		top.next(right, 'go_right')
+		left.next(bottom)
+		right.next(bottom)
+		const flow = new Flow(top)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('TopNode_0 -- "go_left" --> LeftNode_0')
+		expect(result).toContain('TopNode_0 -- "go_right" --> RightNode_0')
+		expect(result).toContain('LeftNode_0 --> BottomNode_0')
+		expect(result).toContain('RightNode_0 --> BottomNode_0')
+	})
+
+	it('should handle a node with three or more branches', () => {
+		const decision = new DecisionNode()
+		const pathA = new PathANode()
+		const pathB = new PathBNode()
+		const pathC = new PathCNode()
+		decision.next(pathA, 'a')
+		decision.next(pathB, 'b')
+		decision.next(pathC, 'c')
+		const flow = new Flow(decision)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('DecisionNode_0 -- "a" --> PathANode_0')
+		expect(result).toContain('DecisionNode_0 -- "b" --> PathBNode_0')
+		expect(result).toContain('DecisionNode_0 -- "c" --> PathCNode_0')
+	})
+
+	it('should handle a branch that leads to another branch (multi-level)', () => {
+		const root = new DecisionNode()
+		const branchA = new PathANode() // Terminal branch
+		const branchB = new DecisionNode() // This branch also branches
+		const leafA = new EndNode()
+		const leafB1 = new EndNode()
+		const leafB2 = new EndNode()
+		root.next(branchA, 'path_a')
+		root.next(branchB, 'path_b')
+		branchA.next(leafA)
+		branchB.next(leafB1, 'sub_b1')
+		branchB.next(leafB2, 'sub_b2')
+		const flow = new Flow(root)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('DecisionNode_0 -- "path_a" --> PathANode_0')
+		expect(result).toContain('DecisionNode_0 -- "path_b" --> DecisionNode_1')
+		expect(result).toContain('PathANode_0 --> EndNode_0')
+		expect(result).toContain('DecisionNode_1 -- "sub_b1" --> EndNode_1')
+		expect(result).toContain('DecisionNode_1 -- "sub_b2" --> EndNode_2')
+	})
+
+	it('should handle a branch that loops while another terminates', () => {
+		const decision = new DecisionNode()
+		const loopNode = new ProcessNode()
+		const endNode = new EndNode()
+		decision.next(loopNode, 'continue')
+		decision.next(endNode, 'finish')
+		loopNode.next(decision) // Loop back to the decision
+		const flow = new Flow(decision)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('DecisionNode_0 -- "continue" --> ProcessNode_0')
+		expect(result).toContain('DecisionNode_0 -- "finish" --> EndNode_0')
+		expect(result).toContain('ProcessNode_0 --> DecisionNode_0')
+	})
+})
+
+describe('testGraphBuilderGraphs', () => {
+	class ParallelBranchContainer extends ParallelFlow {
+		public readonly isParallelContainer = true
+		constructor(public readonly nodesToRun: AbstractNode[]) { super(nodesToRun) }
+	}
+	it('should generate descriptive labels using node.graphData', () => {
+		const nodeA = new Node().withGraphData({ id: 'start-node', type: 'llm-process' })
+		const nodeB = new Node().withGraphData({ id: 'end-node', type: 'output' })
+		nodeA.next(nodeB)
+		const flow = new Flow(nodeA)
+		const result = generateMermaidGraph(flow)
+
+		expect(result).toContain('startnode_0["start-node (llm-process)"]')
+		expect(result).toContain('endnode_0["end-node (output)"]')
+		expect(result).toContain('startnode_0 --> endnode_0')
+	})
+
+	it('should generate special labels for parallel containers and mappers', () => {
+		const start = new Node().withGraphData({ id: 'start', type: 'start-type' })
+		const branchA = new Node().withGraphData({ id: 'branch-a', type: 'type-a' })
+		const branchB = new Node().withGraphData({ id: 'branch-b', type: 'type-b' })
+		const parallel = new ParallelBranchContainer([branchA, branchB])
+		const finalNode = new Node().withGraphData({ id: 'final', type: 'end-type' })
+
+		// This is how the GraphBuilder wires the flow
+		start.next(parallel)
+		branchA.next(finalNode) // Internal node fans out
+		branchB.next(finalNode) // Internal node fans out
+
+		const flow = new Flow(start)
+		const result = generateMermaidGraph(flow)
+
+		// Check for container label
+		expect(result).toContain('ParallelBlock_0{Parallel Block}')
+		// Check for fan-out from container
+		expect(result).toContain('start_0 --> ParallelBlock_0')
+		expect(result).toContain('ParallelBlock_0 --> brancha_0')
+		expect(result).toContain('ParallelBlock_0 --> branchb_0')
+		// Check for fan-in to final node
+		expect(result).toContain('brancha_0 --> final_0')
+		expect(result).toContain('branchb_0 --> final_0')
+	})
+
+	it('should get original ID from graphData, ignoring prefixes', () => {
+		// Simulates a node from an inlined sub-workflow
+		const inlinedNode = new Node().withGraphData({
+			id: 'parent:child-node',
+			type: 'child-type',
+		})
+		const flow = new Flow(inlinedNode)
+		const result = generateMermaidGraph(flow)
+		expect(result).toContain('childnode_0["child-node (child-type)"]')
+	})
+})