@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/logical-or-parser.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { parser, lexer } from '../../../src/compiler/expression-parser';
+import { cstToAst } from '../../../src/compiler/cst-visitor';
+
+describe('Expression Parser - Logical OR Operator', () => {
+  beforeEach(() => {
+    // Reset parser state before each test
+    parser.reset();
+  });
+
+  /**
+   * Note: both `or` keyword and `||` (double pipe) syntax are parsed.
+   * zen-engine evaluation only supports `or` keyword, but our compiler
+   * supports both forms for compatibility.
+   */
+
+  it('should parse "true" as just a boolean literal', () => {
+    const lexingResult = lexer.tokenize('true');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    expect(ast).toEqual({
+      type: 'BooleanLiteral',
+      value: true,
+    });
+  });
+
+  it('should parse "true or true"', () => {
+    const lexingResult = lexer.tokenize('true or true');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    expect(ast).toEqual({
+      type: 'BinaryOp',
+      op: 'or',
+      left: { type: 'BooleanLiteral', value: true },
+      right: { type: 'BooleanLiteral', value: true },
+    });
+  });
+
+  it('should parse "true || true"', () => {
+    const lexingResult = lexer.tokenize('true || true');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    expect(ast).toEqual({
+      type: 'BinaryOp',
+      op: 'or',
+      left: { type: 'BooleanLiteral', value: true },
+      right: { type: 'BooleanLiteral', value: true },
+    });
+  });
+
+  it('should parse "x < 5 or x > 10"', () => {
+    const lexingResult = lexer.tokenize('x < 5 or x > 10');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    expect(ast).toEqual({
+      type: 'BinaryOp',
+      op: 'or',
+      left: {
+        type: 'BinaryOp',
+        op: '<',
+        left: { type: 'Identifier', name: 'x' },
+        right: { type: 'NumberLiteral', value: 5 },
+      },
+      right: {
+        type: 'BinaryOp',
+        op: '>',
+        left: { type: 'Identifier', name: 'x' },
+        right: { type: 'NumberLiteral', value: 10 },
+      },
+    });
+  });
+
+  it('should parse "x < 5 || x > 10"', () => {
+    const lexingResult = lexer.tokenize('x < 5 || x > 10');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    expect(ast).toEqual({
+      type: 'BinaryOp',
+      op: 'or',
+      left: {
+        type: 'BinaryOp',
+        op: '<',
+        left: { type: 'Identifier', name: 'x' },
+        right: { type: 'NumberLiteral', value: 5 },
+      },
+      right: {
+        type: 'BinaryOp',
+        op: '>',
+        left: { type: 'Identifier', name: 'x' },
+        right: { type: 'NumberLiteral', value: 10 },
+      },
+    });
+  });
+
+  it('should parse "false or false or false"', () => {
+    const lexingResult = lexer.tokenize('false or false or false');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    // Multiple ORs are left-associative: (false or false) or false
+    expect(ast).toEqual({
+      type: 'BinaryOp',
+      op: 'or',
+      left: {
+        type: 'BinaryOp',
+        op: 'or',
+        left: { type: 'BooleanLiteral', value: false },
+        right: { type: 'BooleanLiteral', value: false },
+      },
+      right: { type: 'BooleanLiteral', value: false },
+    });
+  });
+
+  it('should parse "x and y or z" (OR has lower precedence than AND)', () => {
+    const lexingResult = lexer.tokenize('x and y or z');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    // OR has lower precedence, so this is: (x and y) or z
+    expect(ast).toEqual({
+      type: 'BinaryOp',
+      op: 'or',
+      left: {
+        type: 'BinaryOp',
+        op: 'and',
+        left: { type: 'Identifier', name: 'x' },
+        right: { type: 'Identifier', name: 'y' },
+      },
+      right: { type: 'Identifier', name: 'z' },
+    });
+  });
+
+  it('should parse "x or y and z" (AND has higher precedence than OR)', () => {
+    const lexingResult = lexer.tokenize('x or y and z');
+
+    if (lexingResult.errors.length > 0) {
+      throw new Error(`Lexer error: ${lexingResult.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    parser.input = lexingResult.tokens;
+    const cst = parser.expression();
+
+    if (parser.errors.length > 0) {
+      throw new Error(`Parse error: ${parser.errors.map((e: any) => e.message).join(', ')}`);
+    }
+
+    const ast = cstToAst(cst);
+    // AND has higher precedence, so this is: x or (y and z)
+    expect(ast).toEqual({
+      type: 'BinaryOp',
+      op: 'or',
+      left: { type: 'Identifier', name: 'x' },
+      right: {
+        type: 'BinaryOp',
+        op: 'and',
+        left: { type: 'Identifier', name: 'y' },
+        right: { type: 'Identifier', name: 'z' },
+      },
+    });
+  });
+});

package/tests/unit/compiler/marshal-gen/marshal-gen.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Marshaling Code Generation Tests
+ *
+ * Tests for the marshaling code generation:
+ * - Marshal code generation
+ * - Unmarshal code generation
+ * - Validation code generation
+ *
+ * These tests verify that the code generators produce syntactically valid output.
+ * The actual marshaling/unmarshaling behavior is tested through integration tests.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Type } from '@sinclair/typebox';
+import { generateMarshalCode, generateValidationCode } from '../../../../src/compiler/marshal-gen';
+import { flattenSchema, computeSchemaHash } from '../../../../src/compiler/schema';
+
+describe('Marshaling Code Generation', () => {
+  describe('generateMarshalCode', () => {
+    it('should generate marshal code that is syntactically valid', () => {
+      const schema = Type.Object({
+        age: Type.Number(),
+        name: Type.String(),
+      });
+
+      const layout = flattenSchema(schema);
+      const hash = computeSchemaHash(schema, schema);
+
+      const code = generateMarshalCode(layout, layout, hash);
+
+      // Verify code is generated
+      expect(typeof code).toBe('string');
+      expect(code.length).toBeGreaterThan(0);
+
+      // Verify balanced braces/parens (basic syntax check)
+      checkBalancedSyntax(code);
+    });
+
+    it('should generate code with required exports', () => {
+      const schema = Type.Object({
+        value: Type.Number(),
+      });
+
+      const layout = flattenSchema(schema);
+      const hash = computeSchemaHash(schema, schema);
+
+      const code = generateMarshalCode(layout, layout, hash);
+
+      // These exports are required for the runtime to function
+      expect(code).toMatch(/export function marshalInput/);
+      expect(code).toMatch(/export function unmarshalOutput/);
+    });
+  });
+
+  describe('generateValidationCode', () => {
+    it('should generate validation code that is syntactically valid', () => {
+      const schema = Type.Object({
+        age: Type.Number(),
+        name: Type.String(),
+      });
+
+      const code = generateValidationCode(schema);
+
+      expect(typeof code).toBe('string');
+      expect(code.length).toBeGreaterThan(0);
+      checkBalancedSyntax(code);
+    });
+
+    it('should generate code with required exports', () => {
+      const schema = Type.Object({ value: Type.Number() });
+
+      const code = generateValidationCode(schema);
+
+      // These exports are required for the runtime to function
+      expect(code).toMatch(/export function validateInput/);
+      expect(code).toMatch(/export class ValidationError/);
+      expect(code).toMatch(/export function checkInput/);
+    });
+  });
+});
+
+/**
+ * Helper to check if generated code has balanced braces, parens, and brackets
+ */
+function checkBalancedSyntax(code: string): void {
+  const openBraces = (code.match(/{/g) || []).length;
+  const closeBraces = (code.match(/}/g) || []).length;
+  expect(openBraces).toBe(closeBraces);
+
+  const openParens = (code.match(/\(/g) || []).length;
+  const closeParens = (code.match(/\)/g) || []).length;
+  expect(openParens).toBe(closeParens);
+
+  const openBrackets = (code.match(/\[/g) || []).length;
+  const closeBrackets = (code.match(/\]/g) || []).length;
+  expect(openBrackets).toBe(closeBrackets);
+}

package/tests/unit/compiler/nodes/decision-table.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import { compileDecisionTableNode } from '../../../../src/compiler/nodes/decision-table';
+import { NodeType, type JDMNode } from '../../../../src/compiler/parser';
+import { createMockContextWithRealParser } from '../../../helpers';
+
+/**
+ * Decision Table Node Compilation Tests
+ *
+ * These tests verify the compiler's validation and error handling for decision table nodes.
+ * The actual code generation behavior is tested through integration tests that compile
+ * and execute the generated code.
+ */
+describe('Decision Table Node Compilation', () => {
+  describe('compileDecisionTableNode', () => {
+    const createMockContext = createMockContextWithRealParser;
+
+    it('should generate code for a decision table node', () => {
+      const node: JDMNode = {
+        id: 'decision-table-1',
+        type: NodeType.DECISION_TABLE,
+        name: 'Decision Table',
+        position: { x: 0, y: 0 },
+        content: {
+          rules: [{ input1: 'value', output1: 'result' }],
+          inputs: [{ id: 'input1', type: 'string', field: 'input' }],
+          outputs: [{ id: 'output1', type: 'string', field: 'result' }],
+          hitPolicy: 'first',
+        },
+      };
+
+      const context = createMockContext();
+      const code = compileDecisionTableNode(node, context);
+
+      expect(typeof code).toBe('string');
+      expect(code.length).toBeGreaterThan(0);
+    });
+
+    it('should generate code with different hit policies', () => {
+      const policies = ['first', 'collect', 'priority', 'unique'];
+
+      for (const policy of policies) {
+        const node: JDMNode = {
+          id: `dt-${policy}`,
+          type: NodeType.DECISION_TABLE,
+          name: `${policy} Hit Policy`,
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [{ rule1: 'value', output1: 'result1' }],
+            inputs: [{ id: 'rule1', type: 'string', field: 'input' }],
+            outputs: [{ id: 'output1', type: 'string', field: 'result' }],
+            hitPolicy: policy,
+          },
+        };
+
+        const context = createMockContext();
+        const code = compileDecisionTableNode(node, context);
+
+        expect(code.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should throw error when PRIORITY is used with no outputs', () => {
+      const node: JDMNode = {
+        id: 'dt-priority-no-outputs',
+        type: NodeType.DECISION_TABLE,
+        name: 'Priority No Outputs',
+        position: { x: 0, y: 0 },
+        content: {
+          rules: [{ input1: 'value1' }],
+          inputs: [{ id: 'input1', type: 'string', field: 'input' }],
+          outputs: [],
+          hitPolicy: 'priority',
+        },
+      };
+
+      const context = createMockContext();
+
+      expect(() => compileDecisionTableNode(node, context)).toThrow(
+        'PRIORITY hit policy requires at least one output field',
+      );
+    });
+
+    it('should compile successfully when RETURN_DEFAULT is used with a value', () => {
+      const node: JDMNode = {
+        id: 'dt-no-match-default-with-value',
+        type: NodeType.DECISION_TABLE,
+        name: 'No Match Default With Value',
+        position: { x: 0, y: 0 },
+        content: {
+          rules: [{ input1: 'value1', output1: '10' }],
+          inputs: [{ id: 'input1', type: 'string', field: 'input' }],
+          outputs: [{ id: 'output1', type: 'number', field: 'output' }],
+          hitPolicy: 'first',
+          noMatchBehavior: { type: 'returnDefault', value: 'default-value' },
+        },
+      };
+
+      const context = createMockContext();
+      const code = compileDecisionTableNode(node, context);
+      expect(code).toContain('result.set("output", Value.String("default-value"))');
+    });
+  });
+});

package/tests/unit/compiler/nodes/decision.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { compileDecisionNode } from '../../../../src/compiler/nodes/decision';
+import type { JDMNode, JDMDecision } from '../../../../src/compiler/parser';
+import { createMockContext } from '../../../helpers';
+
+/**
+ * Sub-Decision Node Compilation Tests
+ *
+ * These tests verify the compiler's validation and error handling for sub-decision nodes.
+ * The actual code generation behavior is tested through integration tests that compile
+ * and execute the generated code.
+ */
+describe('Sub-Decision Node Compilation', () => {
+  describe('compileDecisionNode', () => {
+    const createSubDecision = (): JDMDecision => ({
+      nodes: [
+        {
+          id: 'sub-input',
+          type: 'inputNode' as any,
+          name: 'Sub Decision Input',
+          position: { x: 0, y: 0 },
+        },
+        {
+          id: 'sub-output',
+          type: 'outputNode' as any,
+          name: 'Sub Decision Output',
+          position: { x: 100, y: 0 },
+        },
+      ],
+      edges: [
+        {
+          id: 'sub-edge',
+          type: 'direct',
+          sourceId: 'sub-input',
+          targetId: 'sub-output',
+        },
+      ],
+    });
+
+    it('should generate code for a valid sub-decision node', () => {
+      const node: JDMNode = {
+        id: 'sub-decision-1',
+        type: 'decisionNode' as any,
+        name: 'Sub Decision',
+        position: { x: 0, y: 0 },
+        content: { key: '$test.json' },
+      };
+
+      const subDecision = createSubDecision();
+      const context = createMockContext();
+      context.loadDecision = () => subDecision;
+
+      const code = compileDecisionNode(node, context);
+
+      // Verify code is generated (non-empty string)
+      expect(typeof code).toBe('string');
+      expect(code.length).toBeGreaterThan(0);
+    });
+
+    it('should detect circular dependencies', () => {
+      const node: JDMNode = {
+        id: 'sub-cycle',
+        type: 'decisionNode' as any,
+        name: 'Circular Dep',
+        position: { x: 0, y: 0 },
+        content: { key: '$cycle.json' },
+      };
+
+      const subDecision = createSubDecision();
+      const context = createMockContext();
+      context.loadDecision = () => subDecision;
+
+      // Add node to decision path to simulate circular reference
+      context.decisionPath.push('sub-cycle');
+
+      expect(() => compileDecisionNode(node, context)).toThrow('Circular dependency detected');
+    });
+
+    it('should throw an error when node has no content.key', () => {
+      const node: JDMNode = {
+        id: 'sub-no-key',
+        type: 'decisionNode' as any,
+        name: 'No Key',
+        position: { x: 0, y: 0 },
+        // No content.key!
+      };
+
+      const context = createMockContext();
+      context.loadDecision = () => createSubDecision();
+
+      expect(() => compileDecisionNode(node, context)).toThrow('no content.key');
+    });
+
+    it('should throw an error when sub-decision has no input node', () => {
+      const node: JDMNode = {
+        id: 'sub-no-input',
+        type: 'decisionNode' as any,
+        name: 'No Input',
+        position: { x: 0, y: 0 },
+        content: { key: '$no-input.json' },
+      };
+
+      const subDecision: JDMDecision = {
+        nodes: [
+          {
+            id: 'sub-output',
+            type: 'outputNode' as any,
+            name: 'Output',
+            position: { x: 0, y: 0 },
+          },
+        ],
+        edges: [],
+      };
+
+      const context = createMockContext();
+      context.loadDecision = () => subDecision;
+
+      expect(() => compileDecisionNode(node, context)).toThrow('no input node');
+    });
+
+    it('should throw an error when sub-decision has no output nodes', () => {
+      const node: JDMNode = {
+        id: 'sub-no-output',
+        type: 'decisionNode' as any,
+        name: 'No Output',
+        position: { x: 0, y: 0 },
+        content: { key: '$no-output.json' },
+      };
+
+      const subDecision: JDMDecision = {
+        nodes: [
+          {
+            id: 'sub-input',
+            type: 'inputNode' as any,
+            name: 'Input',
+            position: { x: 0, y: 0 },
+          },
+        ],
+        edges: [],
+      };
+
+      const context = createMockContext();
+      context.loadDecision = () => subDecision;
+
+      expect(() => compileDecisionNode(node, context)).toThrow('no output nodes');
+    });
+
+    it('should cache compiled sub-decisions to avoid recompilation', () => {
+      const subDecision = createSubDecision();
+      const node1: JDMNode = {
+        id: 'node1',
+        type: 'decisionNode' as any,
+        name: 'First Reference',
+        position: { x: 0, y: 0 },
+        content: { key: '$shared.json' },
+      };
+      const node2: JDMNode = {
+        id: 'node2',
+        type: 'decisionNode' as any,
+        name: 'Second Reference',
+        position: { x: 0, y: 0 },
+        content: { key: '$shared.json' },
+      };
+
+      const context = createMockContext();
+      context.loadDecision = () => subDecision;
+
+      // Compile the same sub-decision twice
+      const code1 = compileDecisionNode(node1, context);
+      const code2 = compileDecisionNode(node2, context);
+
+      // First compilation should produce code
+      expect(code1.length).toBeGreaterThan(0);
+
+      // Both should produce valid code
+      expect(code2.length).toBeGreaterThan(0);
+
+      // Verify caching occurred (the cache should have an entry)
+      expect(context.compiledSubDecisions.size).toBe(1);
+    });
+  });
+});