@divmain/jdm-asm 0.2.1 → 0.2.3

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

@@ -1,236 +0,0 @@
-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

@@ -1,97 +0,0 @@
-/**
- * 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

@@ -1,103 +0,0 @@
-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

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