@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/graph.test.ts

@@ -0,0 +1,878 @@
+import { describe, it, expect } from 'vitest';
+import {
+  buildGraph,
+  validateGraph,
+  getEvaluationOrder,
+  getInputNodes,
+  getOutputNodes,
+} from '../../../src/compiler/graph';
+import { NodeType, type JDMDecision } from '../../../src/compiler/parser';
+import { CompilationError } from '../../../src/compiler/errors';
+
+describe('Graph Construction & Validation', () => {
+  describe('buildGraph', () => {
+    const validJDM: JDMDecision = {
+      nodes: [
+        {
+          id: 'input1',
+          type: NodeType.INPUT,
+          name: 'Input Node',
+          position: { x: 0, y: 0 },
+        },
+        {
+          id: 'expr1',
+          type: NodeType.EXPRESSION,
+          name: 'Expression Node',
+          position: { x: 100, y: 0 },
+          content: { expression: 'a + b' },
+        },
+        {
+          id: 'output1',
+          type: NodeType.OUTPUT,
+          name: 'Output Node',
+          position: { x: 200, y: 0 },
+        },
+      ],
+      edges: [
+        {
+          id: 'edge1',
+          type: 'direct',
+          sourceId: 'input1',
+          targetId: 'expr1',
+        },
+        {
+          id: 'edge2',
+          type: 'direct',
+          sourceId: 'expr1',
+          targetId: 'output1',
+        },
+      ],
+    };
+
+    it('should build a graph from a valid JDM', () => {
+      const graph = buildGraph(validJDM);
+      expect(graph.order).toBe(3); // 3 nodes
+      expect(graph.size).toBe(2); // 2 edges
+    });
+
+    it('should throw error for edge referencing non-existent node', () => {
+      const invalidJDMSource: JDMDecision = {
+        nodes: [
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 0, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'nonexistent',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      expect(() => buildGraph(invalidJDMSource)).toThrow(CompilationError);
+      expect(() => buildGraph(invalidJDMSource)).toThrow('Invalid edge');
+      expect(() => buildGraph(invalidJDMSource)).toThrow('references non-existent node');
+
+      const invalidJDMTarget: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'nonexistent',
+          },
+        ],
+      };
+
+      expect(() => buildGraph(invalidJDMTarget)).toThrow(CompilationError);
+      expect(() => buildGraph(invalidJDMTarget)).toThrow('Invalid edge');
+      expect(() => buildGraph(invalidJDMTarget)).toThrow('references non-existent node');
+    });
+
+    it('should handle JDM with no edges', () => {
+      const jdmNoEdges: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 100, y: 0 },
+          },
+        ],
+        edges: [],
+      };
+
+      const graph = buildGraph(jdmNoEdges);
+      expect(graph.order).toBe(2);
+      expect(graph.size).toBe(0);
+    });
+  });
+
+  describe('validateGraph', () => {
+    it('should validate a graph with exactly one input and at least one output', () => {
+      const jdm: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 100, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdm);
+      expect(() => validateGraph(graph)).not.toThrow();
+    });
+
+    it('should validate graph with single input and multiple outputs', () => {
+      const jdm: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node 1',
+            position: { x: 100, y: 0 },
+          },
+          {
+            id: 'output2',
+            type: NodeType.OUTPUT,
+            name: 'Output Node 2',
+            position: { x: 200, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'output1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'output2',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdm);
+      expect(() => validateGraph(graph)).not.toThrow();
+    });
+
+    it('should throw CompilationError when graph contains cycles', () => {
+      const jdmWithCycle: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 1',
+            position: { x: 100, y: 0 },
+          },
+          {
+            id: 'expr2',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 2',
+            position: { x: 200, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 300, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'expr1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'expr2',
+          },
+          {
+            id: 'edge3',
+            type: 'direct',
+            sourceId: 'expr2',
+            targetId: 'expr1', // Creates a cycle: expr1 -> expr2 -> expr1
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdmWithCycle);
+      expect(() => validateGraph(graph)).toThrow(CompilationError);
+      expect(() => validateGraph(graph)).toThrow('Circular dependency detected');
+      expect(() => validateGraph(graph)).toThrow(
+        'Expression Node 1 -> Expression Node 2 -> Expression Node 1',
+      );
+    });
+
+    it('should throw CompilationError for self-referencing nodes', () => {
+      const jdmWithSelfRef: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node',
+            position: { x: 100, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 200, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'expr1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'expr1', // Self-reference: expr1 -> expr1
+          },
+          {
+            id: 'edge3',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      expect(() => buildGraph(jdmWithSelfRef)).toThrow(CompilationError);
+      expect(() => buildGraph(jdmWithSelfRef)).toThrow('Self-reference detected');
+      expect(() => buildGraph(jdmWithSelfRef)).toThrow('references itself');
+      expect(() => buildGraph(jdmWithSelfRef)).toThrow('Expression Node');
+    });
+
+    it('should throw CompilationError when graph has no input nodes', () => {
+      const jdmNoInput: JDMDecision = {
+        nodes: [
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 100, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdmNoInput);
+      expect(() => validateGraph(graph)).toThrow(CompilationError);
+      expect(() => validateGraph(graph)).toThrow('Expected exactly 1 input node, found 0');
+    });
+
+    it('should throw CompilationError when graph has multiple input nodes', () => {
+      const jdmMultipleInputs: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node 1',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'input2',
+            type: NodeType.INPUT,
+            name: 'Input Node 2',
+            position: { x: 100, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 200, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'output1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'input2',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdmMultipleInputs);
+      expect(() => validateGraph(graph)).toThrow(CompilationError);
+      expect(() => validateGraph(graph)).toThrow('Expected exactly 1 input node, found 2');
+    });
+
+    it('should throw CompilationError when graph has no output nodes', () => {
+      const jdmNoOutput: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node',
+            position: { x: 100, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'expr1',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdmNoOutput);
+      expect(() => validateGraph(graph)).toThrow(CompilationError);
+      expect(() => validateGraph(graph)).toThrow('Expected at least 1 output node, found 0');
+    });
+  });
+
+  describe('getEvaluationOrder', () => {
+    it('should return nodes in topological order', () => {
+      const jdm: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 1',
+            position: { x: 100, y: 0 },
+          },
+          {
+            id: 'expr2',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 2',
+            position: { x: 200, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 300, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'expr1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'expr2',
+          },
+          {
+            id: 'edge3',
+            type: 'direct',
+            sourceId: 'expr2',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdm);
+      const order = getEvaluationOrder(graph);
+
+      // Input must come before expressions
+      const inputIndex = order.indexOf('input1');
+      const expr1Index = order.indexOf('expr1');
+      const expr2Index = order.indexOf('expr2');
+      const outputIndex = order.indexOf('output1');
+
+      expect(inputIndex).toBeLessThan(expr1Index);
+      expect(expr1Index).toBeLessThan(expr2Index);
+      expect(expr2Index).toBeLessThan(outputIndex);
+    });
+
+    it('should handle diamond topology correctly', () => {
+      const jdm: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 1',
+            position: { x: 100, y: -50 },
+          },
+          {
+            id: 'expr2',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 2',
+            position: { x: 100, y: 50 },
+          },
+          {
+            id: 'expr3',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 3',
+            position: { x: 200, y: 0 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 300, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'expr1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'expr2',
+          },
+          {
+            id: 'edge3',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'expr3',
+          },
+          {
+            id: 'edge4',
+            type: 'direct',
+            sourceId: 'expr2',
+            targetId: 'expr3',
+          },
+          {
+            id: 'edge5',
+            type: 'direct',
+            sourceId: 'expr3',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdm);
+      const order = getEvaluationOrder(graph);
+
+      const inputIndex = order.indexOf('input1');
+      const expr1Index = order.indexOf('expr1');
+      const expr2Index = order.indexOf('expr2');
+      const expr3Index = order.indexOf('expr3');
+      const outputIndex = order.indexOf('output1');
+
+      // Input must come before expr1 and expr2
+      expect(inputIndex).toBeLessThan(expr1Index);
+      expect(inputIndex).toBeLessThan(expr2Index);
+      // Both expr1 and expr2 must come before expr3
+      expect(expr1Index).toBeLessThan(expr3Index);
+      expect(expr2Index).toBeLessThan(expr3Index);
+      // expr3 must come before output
+      expect(expr3Index).toBeLessThan(outputIndex);
+    });
+  });
+
+  describe('getInputNodes', () => {
+    const jdm: JDMDecision = {
+      nodes: [
+        {
+          id: 'input1',
+          type: NodeType.INPUT,
+          name: 'Input Node',
+          position: { x: 0, y: 0 },
+        },
+        {
+          id: 'expr1',
+          type: NodeType.EXPRESSION,
+          name: 'Expression Node',
+          position: { x: 100, y: 0 },
+        },
+        {
+          id: 'output1',
+          type: NodeType.OUTPUT,
+          name: 'Output Node',
+          position: { x: 200, y: 0 },
+        },
+      ],
+      edges: [
+        {
+          id: 'edge1',
+          type: 'direct',
+          sourceId: 'input1',
+          targetId: 'expr1',
+        },
+        {
+          id: 'edge2',
+          type: 'direct',
+          sourceId: 'expr1',
+          targetId: 'output1',
+        },
+      ],
+    };
+
+    it('should return all nodes that feed into a target node', () => {
+      const graph = buildGraph(jdm);
+      const inputs = getInputNodes(graph, 'expr1');
+
+      expect(inputs).toHaveLength(1);
+      expect(inputs[0].id).toBe('input1');
+    });
+
+    it('should return empty array for input node (no incoming edges)', () => {
+      const graph = buildGraph(jdm);
+      const inputs = getInputNodes(graph, 'input1');
+
+      expect(inputs).toHaveLength(0);
+    });
+
+    it('should return multiple input nodes for a node with multiple incoming edges', () => {
+      const jdmMultiInput: JDMDecision = {
+        nodes: [
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 1',
+            position: { x: 0, y: -50 },
+          },
+          {
+            id: 'expr2',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 2',
+            position: { x: 0, y: 50 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Output Node',
+            position: { x: 100, y: 0 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'output1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'expr2',
+            targetId: 'output1',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdmMultiInput);
+      const inputs = getInputNodes(graph, 'output1');
+
+      expect(inputs).toHaveLength(2);
+      expect(inputs.map((n) => n.id).sort()).toEqual(['expr1', 'expr2']);
+    });
+  });
+
+  describe('getOutputNodes', () => {
+    const jdm: JDMDecision = {
+      nodes: [
+        {
+          id: 'input1',
+          type: NodeType.INPUT,
+          name: 'Input Node',
+          position: { x: 0, y: 0 },
+        },
+        {
+          id: 'expr1',
+          type: NodeType.EXPRESSION,
+          name: 'Expression Node',
+          position: { x: 100, y: 0 },
+        },
+        {
+          id: 'output1',
+          type: NodeType.OUTPUT,
+          name: 'Output Node',
+          position: { x: 200, y: 0 },
+        },
+      ],
+      edges: [
+        {
+          id: 'edge1',
+          type: 'direct',
+          sourceId: 'input1',
+          targetId: 'expr1',
+        },
+        {
+          id: 'edge2',
+          type: 'direct',
+          sourceId: 'expr1',
+          targetId: 'output1',
+        },
+      ],
+    };
+
+    it('should return all nodes that a source node feeds into', () => {
+      const graph = buildGraph(jdm);
+      const outputs = getOutputNodes(graph, 'expr1');
+
+      expect(outputs).toHaveLength(1);
+      expect(outputs[0].id).toBe('output1');
+    });
+
+    it('should return empty array for output node (no outgoing edges)', () => {
+      const graph = buildGraph(jdm);
+      const outputs = getOutputNodes(graph, 'output1');
+
+      expect(outputs).toHaveLength(0);
+    });
+
+    it('should return multiple output nodes for a node with multiple outgoing edges', () => {
+      const jdmMultiOutput: JDMDecision = {
+        nodes: [
+          {
+            id: 'input1',
+            type: NodeType.INPUT,
+            name: 'Input Node',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'expr1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node',
+            position: { x: 100, y: 0 },
+          },
+          {
+            id: 'expr2',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 2',
+            position: { x: 200, y: -50 },
+          },
+          {
+            id: 'expr3',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node 3',
+            position: { x: 200, y: 50 },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge1',
+            type: 'direct',
+            sourceId: 'input1',
+            targetId: 'expr1',
+          },
+          {
+            id: 'edge2',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'expr2',
+          },
+          {
+            id: 'edge3',
+            type: 'direct',
+            sourceId: 'expr1',
+            targetId: 'expr3',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdmMultiOutput);
+      const outputs = getOutputNodes(graph, 'expr1');
+
+      expect(outputs).toHaveLength(2);
+      expect(outputs.map((n) => n.id).sort()).toEqual(['expr2', 'expr3']);
+    });
+  });
+
+  describe('Integration - End-to-end graph construction and validation', () => {
+    it('should successfully build and validate a complex decision graph', () => {
+      const jdm: JDMDecision = {
+        nodes: [
+          {
+            id: 'input',
+            type: NodeType.INPUT,
+            name: 'Request',
+            position: { x: 0, y: 0 },
+          },
+          {
+            id: 'risk-calc',
+            type: NodeType.EXPRESSION,
+            name: 'Risk Assessment',
+            position: { x: 100, y: 0 },
+            content: { expression: 'request.score > 0.7' },
+          },
+          {
+            id: 'decision-table',
+            type: NodeType.DECISION_TABLE,
+            name: 'Decision Table',
+            position: { x: 200, y: -50 },
+          },
+          {
+            id: 'switch',
+            type: NodeType.SWITCH,
+            name: 'Region Switch',
+            position: { x: 200, y: 50 },
+          },
+          {
+            id: 'output1',
+            type: NodeType.OUTPUT,
+            name: 'Approval',
+            position: { x: 300, y: -50 },
+          },
+          {
+            id: 'output2',
+            type: NodeType.OUTPUT,
+            name: 'Rejection',
+            position: { x: 300, y: 50 },
+          },
+        ],
+        edges: [
+          {
+            id: 'e1',
+            type: 'direct',
+            sourceId: 'input',
+            targetId: 'risk-calc',
+          },
+          {
+            id: 'e2',
+            type: 'direct',
+            sourceId: 'risk-calc',
+            targetId: 'decision-table',
+          },
+          {
+            id: 'e3',
+            type: 'direct',
+            sourceId: 'risk-calc',
+            targetId: 'switch',
+          },
+          {
+            id: 'e4',
+            type: 'direct',
+            sourceId: 'decision-table',
+            targetId: 'output1',
+          },
+          {
+            id: 'e5',
+            type: 'direct',
+            sourceId: 'switch',
+            targetId: 'output2',
+          },
+        ],
+      };
+
+      const graph = buildGraph(jdm);
+      expect(() => validateGraph(graph)).not.toThrow();
+
+      const order = getEvaluationOrder(graph);
+      const inputIndex = order.indexOf('input');
+      const riskCalcIndex = order.indexOf('risk-calc');
+      const decisionTableIndex = order.indexOf('decision-table');
+      const switchIndex = order.indexOf('switch');
+      const output1Index = order.indexOf('output1');
+      const output2Index = order.indexOf('output2');
+
+      // Verify input comes first
+      expect(inputIndex).toBeLessThan(riskCalcIndex);
+      // Risk calculation comes before its dependents
+      expect(riskCalcIndex).toBeLessThan(decisionTableIndex);
+      expect(riskCalcIndex).toBeLessThan(switchIndex);
+      // Intermediate nodes come before outputs
+      expect(decisionTableIndex).toBeLessThan(output1Index);
+      expect(switchIndex).toBeLessThan(output2Index);
+    });
+  });
+});