@divmain/jdm-asm 0.2.0

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

@@ -0,0 +1,508 @@
+import { describe, it, expect } from 'vitest';
+import {
+  NodeType,
+  type JDMDecision,
+  parseJDM,
+  validateNodeStructure,
+} from '../../../src/compiler/parser';
+import { CompilationError, ErrorCode } from '../../../src/compiler/errors';
+
+describe('validateNodeStructure', () => {
+  it('should not throw for valid node', () => {
+    const validNode = {
+      id: 'node1',
+      type: 'inputNode',
+      name: 'Input Node',
+      position: { x: 0, y: 0 },
+    };
+    expect(() => validateNodeStructure(validNode, 0)).not.toThrow();
+  });
+
+  it('should throw for node missing id', () => {
+    const invalidNode = {
+      type: 'inputNode',
+      name: 'Input Node',
+    };
+    expect(() => validateNodeStructure(invalidNode, 0)).toThrow(CompilationError);
+    expect(() => validateNodeStructure(invalidNode, 0)).toThrow('id');
+  });
+
+  it('should throw for node missing name', () => {
+    const invalidNode = {
+      id: 'node1',
+      type: 'inputNode',
+    };
+    expect(() => validateNodeStructure(invalidNode, 0)).toThrow(CompilationError);
+    expect(() => validateNodeStructure(invalidNode, 0)).toThrow('name');
+  });
+
+  it('should throw for node missing type', () => {
+    const invalidNode = {
+      id: 'node1',
+      name: 'Node',
+    };
+    expect(() => validateNodeStructure(invalidNode, 0)).toThrow(CompilationError);
+    expect(() => validateNodeStructure(invalidNode, 0)).toThrow('type');
+  });
+
+  it('should list all missing fields', () => {
+    const invalidNode = { position: { x: 0, y: 0 } };
+    expect(() => validateNodeStructure(invalidNode, 0)).toThrow('id, name, type');
+  });
+
+  it('should include error code INVALID_NODE_STRUCTURE', () => {
+    const invalidNode = { position: { x: 0, y: 0 } };
+    try {
+      validateNodeStructure(invalidNode, 0);
+      expect.fail('Should have thrown');
+    } catch (error) {
+      expect(error).toBeInstanceOf(CompilationError);
+      expect((error as CompilationError).code).toBe(ErrorCode.INVALID_NODE_STRUCTURE);
+    }
+  });
+});
+
+describe('JDM Type Definitions & Parsing', () => {
+  describe('NodeType enum', () => {
+    it('should have all expected node types', () => {
+      expect(NodeType.INPUT).toBe('inputNode');
+      expect(NodeType.OUTPUT).toBe('outputNode');
+      expect(NodeType.DECISION_TABLE).toBe('decisionTableNode');
+      expect(NodeType.SWITCH).toBe('switchNode');
+      expect(NodeType.EXPRESSION).toBe('expressionNode');
+      expect(NodeType.DECISION).toBe('decisionNode');
+      expect(NodeType.FUNCTION).toBe('functionNode');
+    });
+  });
+
+  describe('parseJDM', () => {
+    const validJDM: JDMDecision = {
+      nodes: [
+        {
+          id: 'node1',
+          type: NodeType.INPUT,
+          name: 'Input Node',
+          position: { x: 0, y: 0 },
+        },
+        {
+          id: 'node2',
+          type: NodeType.OUTPUT,
+          name: 'Output Node',
+          position: { x: 100, y: 0 },
+        },
+      ],
+      edges: [
+        {
+          id: 'edge1',
+          type: 'direct',
+          sourceId: 'node1',
+          targetId: 'node2',
+        },
+      ],
+    };
+
+    it('should parse valid JDM object', () => {
+      const result = parseJDM(validJDM);
+      expect(result).toEqual(validJDM);
+    });
+
+    it('should parse valid JDM JSON string', () => {
+      const result = parseJDM(JSON.stringify(validJDM));
+      expect(result).toEqual(validJDM);
+    });
+
+    it('should parse function nodes with content', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Node',
+            position: { x: 200, y: 0 },
+            content: {
+              source: 'export const handler = (input) => ({ output: input.input * 2 })',
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithFunction);
+      expect(result.nodes[0].type).toBe(NodeType.FUNCTION);
+      expect(result.nodes[0].parsedContent).toBeDefined();
+      expect(result.nodes[0].parsedContent?.source).toBe(
+        'export const handler = (input) => ({ output: input.input * 2 })',
+      );
+      expect(result.nodes[0].parsedContent?.parameters).toEqual(['input']);
+    });
+
+    it('should parse function nodes with legacy string content format', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Node',
+            position: { x: 200, y: 0 },
+            content: 'export const handler = (input) => ({ output: input.input * 2 })',
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithFunction);
+      expect(result.nodes[0].type).toBe(NodeType.FUNCTION);
+      expect(result.nodes[0].parsedContent).toBeDefined();
+      expect(result.nodes[0].parsedContent?.source).toBe(
+        'export const handler = (input) => ({ output: input.input * 2 })',
+      );
+      expect(result.nodes[0].parsedContent?.parameters).toEqual(['input']);
+    });
+
+    it('should parse function nodes with multiple parameters', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Node',
+            position: { x: 200, y: 0 },
+            content: {
+              source: 'export const handler = (input, context) => ({ output: input })',
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithFunction);
+      expect(result.nodes[0].parsedContent?.parameters).toEqual(['input', 'context']);
+    });
+
+    it('should parse function nodes with destructured parameters', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Node',
+            position: { x: 200, y: 0 },
+            content: {
+              source: 'export const handler = ({ input, helpers }) => ({ output: input })',
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithFunction);
+      expect(result.nodes[0].parsedContent?.parameters).toEqual(['input', 'helpers']);
+    });
+
+    it('should throw CompilationError when function node is missing content', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Node',
+            position: { x: 200, y: 0 },
+          },
+        ],
+        edges: [],
+      };
+
+      expect(() => parseJDM(jdmWithFunction)).toThrow(CompilationError);
+      expect(() => parseJDM(jdmWithFunction)).toThrow('missing required content field');
+    });
+
+    it('should throw CompilationError when function node content has invalid format', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Node',
+            position: { x: 200, y: 0 },
+            content: { invalid: 'format' },
+          },
+        ],
+        edges: [],
+      };
+
+      expect(() => parseJDM(jdmWithFunction)).toThrow(CompilationError);
+      expect(() => parseJDM(jdmWithFunction)).toThrow(
+        'must be either a string or an object with a source property',
+      );
+    });
+
+    it('should handle metadata in JDM', () => {
+      const jdmWithMetadata: JDMDecision = {
+        ...validJDM,
+        metadata: {
+          version: '1.0',
+          author: 'Test Author',
+        },
+      };
+
+      const result = parseJDM(jdmWithMetadata);
+      expect(result.metadata).toEqual({
+        version: '1.0',
+        author: 'Test Author',
+      });
+    });
+
+    it('should handle node with content', () => {
+      const jdmWithContent: JDMDecision = {
+        nodes: [
+          {
+            id: 'node1',
+            type: NodeType.EXPRESSION,
+            name: 'Expression Node',
+            position: { x: 0, y: 0 },
+            content: {
+              expression: 'a + b',
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithContent);
+      expect(result.nodes[0].content).toEqual({ expression: 'a + b' });
+    });
+
+    describe('node structure validation', () => {
+      it('should throw CompilationError when node is missing id', () => {
+        const jdmMissingId = {
+          nodes: [
+            {
+              type: NodeType.INPUT,
+              name: 'Input Node',
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmMissingId)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmMissingId)).toThrow('missing required field(s): id');
+      });
+
+      it('should throw CompilationError when node is missing name', () => {
+        const jdmMissingName = {
+          nodes: [
+            {
+              id: 'node1',
+              type: NodeType.INPUT,
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmMissingName)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmMissingName)).toThrow('missing required field(s): name');
+      });
+
+      it('should throw CompilationError when node is missing type', () => {
+        const jdmMissingType = {
+          nodes: [
+            {
+              id: 'node1',
+              name: 'Input Node',
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmMissingType)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmMissingType)).toThrow('missing required field(s): type');
+      });
+
+      it('should throw CompilationError when node is missing multiple required fields', () => {
+        const jdmMissingMultiple = {
+          nodes: [
+            {
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmMissingMultiple)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmMissingMultiple)).toThrow('id, name, type');
+      });
+
+      it('should throw CompilationError when id is empty string', () => {
+        const jdmEmptyId = {
+          nodes: [
+            {
+              id: '',
+              type: NodeType.INPUT,
+              name: 'Input Node',
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmEmptyId)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmEmptyId)).toThrow('missing required field(s): id');
+      });
+
+      it('should throw CompilationError when type is empty string', () => {
+        const jdmEmptyType = {
+          nodes: [
+            {
+              id: 'node1',
+              type: '',
+              name: 'Input Node',
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmEmptyType)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmEmptyType)).toThrow('missing required field(s): type');
+      });
+
+      it('should throw CompilationError when nodes array is missing', () => {
+        const jdmMissingNodes = {
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmMissingNodes)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmMissingNodes)).toThrow("missing or invalid 'nodes' array");
+      });
+
+      it('should throw CompilationError when nodes is not an array', () => {
+        const jdmInvalidNodes = {
+          nodes: 'not an array',
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmInvalidNodes)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmInvalidNodes)).toThrow("missing or invalid 'nodes' array");
+      });
+
+      it('should include node identifier (id or name) in error message', () => {
+        // When id is missing but name exists, use name
+        const jdmWithName = {
+          nodes: [
+            {
+              name: 'MyNode',
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmWithName)).toThrow('Node "MyNode"');
+      });
+
+      it('should include index in error message when no identifier available', () => {
+        const jdmNoIdentifier = {
+          nodes: [
+            {
+              position: { x: 0, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmNoIdentifier)).toThrow('at index 0');
+      });
+
+      it('should validate all nodes and report first error', () => {
+        const jdmMultipleNodes = {
+          nodes: [
+            {
+              id: 'node1',
+              type: NodeType.INPUT,
+              name: 'Valid Node',
+              position: { x: 0, y: 0 },
+            },
+            {
+              id: 'node2',
+              // missing type and name
+              position: { x: 100, y: 0 },
+            },
+          ],
+          edges: [],
+        };
+
+        expect(() => parseJDM(jdmMultipleNodes)).toThrow(CompilationError);
+        expect(() => parseJDM(jdmMultipleNodes)).toThrow('Node "node2"');
+      });
+    });
+
+    it('should parse function node with complex parameter destructuring', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Complex Function',
+            position: { x: 200, y: 0 },
+            content: {
+              source:
+                'export const handler = ({ user, context: { env, helpers } }) => ({ output: user })',
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithFunction);
+      expect(result.nodes[0].type).toBe(NodeType.FUNCTION);
+      expect(result.nodes[0].parsedContent).toBeDefined();
+      expect(result.nodes[0].parsedContent?.source).toContain('export const handler');
+      // Complex destructuring should still capture top-level names
+      expect(result.nodes[0].parsedContent?.parameters.length).toBeGreaterThan(0);
+    });
+
+    it('should parse function node with function expression syntax', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Expression',
+            position: { x: 200, y: 0 },
+            content: {
+              source:
+                'export const handler = function(input, options) { return { result: input }; };',
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithFunction);
+      expect(result.nodes[0].parsedContent?.parameters).toEqual(['input', 'options']);
+    });
+
+    it('should parse function node with function declaration', () => {
+      const jdmWithFunction: JDMDecision = {
+        nodes: [
+          {
+            id: 'func1',
+            type: NodeType.FUNCTION,
+            name: 'Function Declaration',
+            position: { x: 200, y: 0 },
+            content: {
+              source: 'export function handler(input) { return { result: input }; }',
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const result = parseJDM(jdmWithFunction);
+      expect(result.nodes[0].parsedContent?.parameters).toEqual(['input']);
+    });
+  });
+});