@divmain/jdm-asm 0.2.1 → 0.2.3

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

@@ -1,878 +0,0 @@
-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);
-    });
-  });
-});