@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/optimizer-implementation.test.ts

@@ -0,0 +1,625 @@
+import { describe, it, expect } from 'vitest';
+import {
+  constantFolding,
+  expressionInlining,
+  tableIndexing,
+  runOptimizations,
+} from '../../../src/compiler/optimizer';
+import { NodeType } from '../../../src/compiler/parser';
+
+describe('Constant Folding', () => {
+  it('should handle empty cells and dash wildcards', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Wildcard Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: '', output1: 'test1' },
+              { input1: '-', output1: 'test2' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'string' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = constantFolding(jdm);
+    // Empty and dash cells should remain unchanged
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('-');
+  });
+
+  it('should preserve non-constant expression references', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Variable Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'admin', output1: 'test1' },
+              { input1: '> 100', output1: 'test2' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'string' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = constantFolding(jdm);
+    // Non-constant expressions should remain unchanged
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('admin');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('> 100');
+  });
+});
+
+describe('Expression Inlining', () => {
+  it('should inline sum() function calls with constant arguments', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Inline Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'sum(1, 2, 3)', output1: 'test1' },
+              { input1: 'sum(10, 20, 30)', output1: 'test2' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('6');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('60');
+  });
+
+  it('should inline max() function calls', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Max Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'max(10, 5)', output1: 'test1' },
+              { input1: 'max(3, 7)', output1: 'test2' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('10');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('7');
+  });
+
+  it('should inline min() function calls', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Min Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'min(10, 5)', output1: 'test1' },
+              { input1: 'min(3, 7)', output1: 'test2' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('5');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('3');
+  });
+
+  it('should not inline non-constant function calls', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Variable Function Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'sum(x, y, z)', output1: 'test1' },
+              { input1: 'max(price, discountedPrice)', output1: 'test2' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    // Non-constant function calls should remain unchanged
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('sum(x, y, z)');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('max(price, discountedPrice)');
+  });
+
+  it('should inline abs() function calls with negative numbers', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Abs Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'abs(-5)', output1: 'test1' },
+              { input1: 'abs(-3.14)', output1: 'test2' },
+              { input1: 'abs(10)', output1: 'test3' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('5');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('3.14');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('10');
+  });
+
+  it('should inline floor() function calls with decimal numbers', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Floor Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'floor(3.7)', output1: 'test1' },
+              { input1: 'floor(-2.3)', output1: 'test2' },
+              { input1: 'floor(10)', output1: 'test3' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('3');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('-3');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('10');
+  });
+
+  it('should inline ceil() function calls with decimal numbers', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Ceil Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'ceil(3.2)', output1: 'test1' },
+              { input1: 'ceil(-2.7)', output1: 'test2' },
+              { input1: 'ceil(10)', output1: 'test3' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('4');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('-2');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('10');
+  });
+
+  it('should inline round() function calls with decimal numbers', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Round Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'round(3.5)', output1: 'test1' },
+              { input1: 'round(3.4)', output1: 'test2' },
+              { input1: 'round(-2.5)', output1: 'test3' },
+              { input1: 'round(-2.4)', output1: 'test4' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('4');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('3');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('-2'); // JavaScript rounds -2.5 to -2
+    expect(optimized.nodes[0].content.rules[3].input1).toBe('-2');
+  });
+
+  it('should inline upper() function calls with constant strings', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Upper Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'upper("hello")', output1: 'test1' },
+              { input1: 'upper("WORLD")', output1: 'test2' },
+              { input1: 'upper("MiXeD")', output1: 'test3' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('"HELLO"');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('"WORLD"');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('"MIXED"');
+  });
+
+  it('should inline lower() function calls with constant strings', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Lower Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'lower("HELLO")', output1: 'test1' },
+              { input1: 'lower("world")', output1: 'test2' },
+              { input1: 'lower("MiXeD")', output1: 'test3' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('"hello"');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('"world"');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('"mixed"');
+  });
+
+  it('should inline len() function calls with constant strings', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Len String Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'len("hello")', output1: 'test1' },
+              { input1: 'len("")', output1: 'test2' },
+              { input1: 'len("ABCD")', output1: 'test3' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('5');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('0');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('4');
+  });
+
+  it('should inline len() function calls with constant numbers', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Len Number Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'len(123)', output1: 'test1' },
+              { input1: 'len(45678)', output1: 'test2' },
+              { input1: 'len(-987)', output1: 'test3' },
+              { input1: 'len(12.34)', output1: 'test4' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'number' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('3');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('5');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('3'); // Sign doesn't count
+    expect(optimized.nodes[0].content.rules[3].input1).toBe('4'); // Decimal point doesn't count
+  });
+
+  it('should handle multiple function inlining in the same table', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Mixed Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'sum(1, 2, 3)', input2: 'abs(-5)', output1: 'test1' },
+              { input1: 'upper("hi")', input2: 'floor(3.7)', output1: 'test2' },
+              { input1: 'len(123)', input2: 'max(10, 5)', output1: 'test3' },
+            ],
+            inputs: [
+              { id: 'input1', field: 'input1', type: 'number' },
+              { id: 'input2', field: 'input2', type: 'number' },
+            ],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = expressionInlining(jdm);
+
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('6');
+    expect(optimized.nodes[0].content.rules[0].input2).toBe('5');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('"HI"');
+    expect(optimized.nodes[0].content.rules[1].input2).toBe('3');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('3');
+    expect(optimized.nodes[0].content.rules[2].input2).toBe('10');
+  });
+});
+
+describe('Table Indexing', () => {
+  it('should mark inputs as indexable when they have unique literal values', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Indexing Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: '"admin"', input2: '100', output1: 'result1' },
+              { input1: '"user"', input2: '200', output1: 'result2' },
+              { input1: '"guest"', input2: '300', output1: 'result3' },
+            ],
+            inputs: [
+              { id: 'input1', field: 'role', type: 'string' },
+              { id: 'input2', field: 'level', type: 'number' },
+            ],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = tableIndexing(jdm);
+
+    // Both inputs should be marked as indexable
+    expect(optimized.nodes[0].content.inputs[0]._indexable).toBe(true);
+    expect(optimized.nodes[0].content.inputs[1]._indexable).toBe(true);
+
+    // Unique values should be captured
+    expect(optimized.nodes[0].content.inputs[0]._uniqueValues).toEqual([
+      '"admin"',
+      '"user"',
+      '"guest"',
+    ]);
+    expect(optimized.nodes[0].content.inputs[1]._uniqueValues).toEqual(['100', '200', '300']);
+  });
+
+  it('should not mark inputs with duplicate values as indexable', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Duplicate Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: '"admin"', output1: 'result1' },
+              { input1: '"admin"', output1: 'result2' },
+              { input1: '"user"', output1: 'result3' },
+            ],
+            inputs: [{ id: 'input1', field: 'role', type: 'string' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = tableIndexing(jdm);
+
+    // Input should NOT be indexable because of duplicates
+    expect(optimized.nodes[0].content.inputs[0]._indexable).toBe(false);
+  });
+
+  it('should not mark inputs with many unique values as indexable', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Large Value Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: Array.from({ length: 60 }, (_, i) => ({
+              input1: `"value${i}"`,
+              output1: `result${i}`,
+            })),
+            inputs: [{ id: 'input1', field: 'key', type: 'string' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = tableIndexing(jdm);
+
+    // Input should NOT be indexable because value count exceeds threshold
+    expect(optimized.nodes[0].content.inputs[0]._indexable).toBe(false);
+  });
+});
+
+describe('runOptimizations', () => {
+  it('should run all optimization passes in sequence', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Multi-Opt Table',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [
+              { input1: 'sum(1, 2)', output1: 'test1' },
+              { input1: 'sum(10, 20)', output1: 'test2' },
+              { input1: 'admin', output1: 'test3' },
+            ],
+            inputs: [{ id: 'input1', field: 'input', type: 'string' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = runOptimizations(jdm);
+
+    // Expression inlining should turn sum(1, 2) into 3 and sum(10, 20) into 30
+    expect(optimized.nodes[0].content.rules.length).toBe(3);
+    expect(optimized.nodes[0].content.rules[0].input1).toBe('3');
+    expect(optimized.nodes[0].content.rules[1].input1).toBe('30');
+    expect(optimized.nodes[0].content.rules[2].input1).toBe('admin');
+  });
+
+  it('should preserve the original AST structure', () => {
+    const jdm = {
+      nodes: [
+        {
+          id: 'table1',
+          type: NodeType.DECISION_TABLE,
+          name: 'Structure Test',
+          position: { x: 0, y: 0 },
+          content: {
+            rules: [{ input1: 'admin', output1: 'test' }],
+            inputs: [{ id: 'input1', field: 'input', type: 'string' }],
+            outputs: [{ id: 'output1', field: 'output', type: 'string' }],
+            hitPolicy: 'first',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    const optimized = runOptimizations(jdm);
+
+    // Structure should be preserved
+    expect(optimized.nodes).toHaveLength(1);
+    expect(optimized.nodes[0].id).toBe('table1');
+    expect(optimized.nodes[0].type).toBe(NodeType.DECISION_TABLE);
+    expect(optimized.nodes[0].name).toBe('Structure Test');
+    expect(optimized.nodes[0].position).toEqual({ x: 0, y: 0 });
+    expect(optimized.edges).toEqual([]);
+  });
+});