@divmain/jdm-asm 0.2.1 → 0.2.3

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

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