@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/nodes/function-compile.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect } from 'vitest';
+import { compileFunctionNode } from '../../../../src/compiler/nodes/function.js';
+import { CompilationError } from '../../../../src/compiler/errors';
+import { parseJDM } from '../../../../src/compiler/parser.js';
+import { parseStandardExpression } from '../../../../src/compiler/unary-parser.js';
+import { createMockContext } from '../../../helpers';
+
+// Helper function to create a counter-based ID generator for testing
+function createCounterIdGenerator() {
+  let counter = 0;
+  return (prefix: string) => {
+    return `${prefix}_${counter++}`;
+  };
+}
+
+describe('Function Node Compilation', () => {
+  it('should compile function node with simple parameter', () => {
+    const node = {
+      id: 'func1',
+      name: 'TestFunction',
+      content: {
+        source: 'export const handler = (input) => ({ output: input * 2 })',
+      },
+      parsedContent: {
+        source: 'export const handler = (input) => ({ output: input * 2 })',
+        parameters: ['input'],
+        ast: null,
+      },
+    };
+
+    const context = createMockContext({
+      nodes: parseJDM('{"nodes": [], "edges": []}').nodes,
+      edges: parseJDM('{"nodes": [], "edges": []}').edges,
+      options: { optimize: true, debug: false, validate: false },
+      parseExpression: parseStandardExpression,
+      parseUnaryExpression: (expr: string) => parseStandardExpression(expr),
+      getUniqueId: createCounterIdGenerator(),
+      loadDecision: () => parseJDM('{"nodes": [], "edges": []}'),
+      functionSources: new Map(),
+    });
+
+    const code = compileFunctionNode(node, context);
+
+    // Verify that the generated code contains the expected structure
+    expect(code).toContain('export function evaluateNode_func1(ctx: Context): Value');
+    expect(code).toContain('Function node: TestFunction');
+    expect(code).toContain('let input = ctx.get("input");');
+    expect(code).toContain('let result = Value.Object(mockResult);');
+  });
+
+  it('should compile function node with multiple parameters', () => {
+    const node = {
+      id: 'func2',
+      name: 'MultiParamFunction',
+      content: {
+        source: 'export const handler = (input, context) => ({ output: input })',
+      },
+      parsedContent: {
+        source: 'export const handler = (input, context) => ({ output: input })',
+        parameters: ['input', 'context'],
+        ast: null,
+      },
+    };
+
+    const context = createMockContext({
+      nodes: parseJDM('{"nodes": [], "edges": []}').nodes,
+      edges: parseJDM('{"nodes": [], "edges": []}').edges,
+      options: { optimize: true, debug: false, validate: false },
+      parseExpression: parseStandardExpression,
+      parseUnaryExpression: (expr: string) => parseStandardExpression(expr),
+      getUniqueId: createCounterIdGenerator(),
+      loadDecision: () => parseJDM('{"nodes": [], "edges": []}'),
+      functionSources: new Map(),
+    });
+
+    const code = compileFunctionNode(node, context);
+
+    expect(code).toContain('let input = ctx.get("input");');
+    expect(code).toContain('let context = ctx.get("context");');
+    expect(code).toContain('_isFunctionNode');
+    expect(code).toContain('_nodeName');
+  });
+
+  it('should compile function node with destructured parameters', () => {
+    const node = {
+      id: 'func3',
+      name: 'DestructuredFunction',
+      content: {
+        source: 'export const handler = ({ input, helpers }) => ({ output: input })',
+      },
+      parsedContent: {
+        source: 'export const handler = ({ input, helpers }) => ({ output: input })',
+        parameters: ['input', 'helpers'],
+        ast: null,
+      },
+    };
+
+    const context = createMockContext({
+      nodes: parseJDM('{"nodes": [], "edges": []}').nodes,
+      edges: parseJDM('{"nodes": [], "edges": []}').edges,
+      options: { optimize: true, debug: false, validate: false },
+      parseExpression: parseStandardExpression,
+      parseUnaryExpression: (expr: string) => parseStandardExpression(expr),
+      getUniqueId: createCounterIdGenerator(),
+      loadDecision: () => parseJDM('{"nodes": [], "edges": []}'),
+      functionSources: new Map(),
+    });
+
+    const code = compileFunctionNode(node, context);
+
+    expect(code).toContain('let input = ctx.get("input");');
+    expect(code).toContain('let helpers = ctx.get("helpers");');
+  });
+
+  it('should compile function node with no parameters', () => {
+    const node = {
+      id: 'func4',
+      name: 'NoParamFunction',
+      content: {
+        source: 'export const handler = () => ({ output: "test" })',
+      },
+      parsedContent: {
+        source: 'export const handler = () => ({ output: "test" })',
+        parameters: [],
+        ast: null,
+      },
+    };
+
+    const context = createMockContext({
+      nodes: parseJDM('{"nodes": [], "edges": []}').nodes,
+      edges: parseJDM('{"nodes": [], "edges": []}').edges,
+      options: { optimize: true, debug: false, validate: false },
+      parseExpression: parseStandardExpression,
+      parseUnaryExpression: (expr: string) => parseStandardExpression(expr),
+      getUniqueId: createCounterIdGenerator(),
+      loadDecision: () => parseJDM('{"nodes": [], "edges": []}'),
+      functionSources: new Map(),
+    });
+
+    const code = compileFunctionNode(node, context);
+
+    expect(code).toContain('No parameters');
+    expect(code).not.toContain('ctx.get("'); // Should have no parameter reads
+    expect(code).toContain('let result = Value.Object(mockResult);');
+  });
+
+  it('should store function source in context', () => {
+    const node = {
+      id: 'func5',
+      name: 'SourceStorageFunction',
+      content: {
+        source: 'export const handler = (input) => ({ output: input })',
+      },
+      parsedContent: {
+        source: 'export const handler = (input) => ({ output: input })',
+        parameters: ['input'],
+        ast: null,
+      },
+    };
+
+    const functionSources = new Map<string, string>();
+    const context = createMockContext({
+      nodes: parseJDM('{"nodes": [], "edges": []}').nodes,
+      edges: parseJDM('{"nodes": [], "edges": []}').edges,
+      options: { optimize: true, debug: false, validate: false },
+      parseExpression: parseStandardExpression,
+      parseUnaryExpression: (expr: string) => parseStandardExpression(expr),
+      getUniqueId: createCounterIdGenerator(),
+      loadDecision: () => parseJDM('{"nodes": [], "edges": []}'),
+      functionSources,
+    });
+
+    compileFunctionNode(node, context);
+
+    expect(functionSources.has('func5')).toBe(true);
+    expect(functionSources.get('func5')).toBe(
+      'export const handler = (input) => ({ output: input })',
+    );
+  });
+
+  it('should throw error if parsedContent is missing', () => {
+    const node = {
+      id: 'func6',
+      name: 'UnparsedFunction',
+      content: {
+        source: 'export const handler = (input) => ({ output: input })',
+      },
+    };
+
+    const context = createMockContext({
+      nodes: parseJDM('{"nodes": [], "edges": []}').nodes,
+      edges: parseJDM('{"nodes": [], "edges": []}').edges,
+      options: { optimize: true, debug: false, validate: false },
+      parseExpression: parseStandardExpression,
+      parseUnaryExpression: (expr: string) => parseStandardExpression(expr),
+      getUniqueId: createCounterIdGenerator(),
+      loadDecision: () => parseJDM('{"nodes": [], "edges": []}'),
+      functionSources: new Map(),
+    });
+
+    expect(() => compileFunctionNode(node, context)).toThrow(CompilationError);
+    expect(() => compileFunctionNode(node, context)).toThrow('has not been parsed');
+  });
+});

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

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validateFunctionNode,
+  extractFunctionSource,
+  parseFunctionCode,
+} from '../../../../src/compiler/nodes/function.js';
+import type { FunctionNodeContent } from '../../../../src/compiler/nodes/function.js';
+
+describe('Function Node Parsing', () => {
+  describe('extractFunctionSource', () => {
+    it('should extract source from v2 format (object with source property)', () => {
+      const content = {
+        source: 'export const handler = (input) => ({ output: input })',
+      };
+      const source = extractFunctionSource(content);
+      expect(source).toBe('export const handler = (input) => ({ output: input })');
+    });
+
+    it('should extract source from legacy format (plain string)', () => {
+      const content = 'export const handler = (input) => ({ output: input })';
+      const source = extractFunctionSource(content);
+      expect(source).toBe('export const handler = (input) => ({ output: input })');
+    });
+
+    it('should throw error for missing content', () => {
+      expect(() => extractFunctionSource(null)).toThrow('Function node content is missing');
+      expect(() => extractFunctionSource(undefined)).toThrow('Function node content is missing');
+    });
+
+    it('should throw error for invalid content format', () => {
+      const content = { invalid: 'format' };
+      expect(() => extractFunctionSource(content)).toThrow(
+        'must be either a string or an object with a source property',
+      );
+    });
+
+    it('should throw error when source property is not a string', () => {
+      const content = { source: 123 };
+      expect(() => extractFunctionSource(content)).toThrow('content.source must be a string');
+    });
+  });
+
+  describe('parseFunctionCode', () => {
+    it('should parse arrow function with single parameter', () => {
+      const source = 'export const handler = (input) => ({ output: input })';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.source).toBe(source);
+      expect(parsed.parameters).toEqual(['input']);
+      expect(parsed.ast).toBeDefined();
+    });
+
+    it('should parse arrow function with multiple parameters', () => {
+      const source = 'export const handler = (input, context) => ({ output: input })';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input', 'context']);
+    });
+
+    it('should parse function declaration', () => {
+      const source = 'export function handler(input) { return { output: input }; }';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input']);
+    });
+
+    it('should parse function expression', () => {
+      const source = 'export const handler = function(input) { return { output: input }; }';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input']);
+    });
+
+    it('should parse function with destructured parameters', () => {
+      const source = 'export const handler = ({ input, context }) => ({ output: input })';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input', 'context']);
+    });
+
+    it('should parse function with array destructuring', () => {
+      const source = 'export const handler = ([input, context]) => ({ output: input })';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input', 'context']);
+    });
+
+    it('should handle function with no parameters', () => {
+      const source = 'export const handler = () => ({ output: "test" })';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual([]);
+    });
+
+    it('should handle complex function with helpers', () => {
+      const source = 'export const handler = (input, { moment, env }) => ({ output: input })';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input', 'moment', 'env']);
+    });
+
+    it('should parse async function', () => {
+      const source = 'export const handler = async (input) => ({ output: await fetch(input) })';
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input']);
+    });
+
+    it('should throw error for invalid JavaScript syntax', () => {
+      const source = 'this is not valid javascript {{{';
+      expect(() => parseFunctionCode(source)).toThrow('Failed to parse function code');
+    });
+
+    it('should extract function from mixed module code', () => {
+      const source = `
+import { helper } from './helper.js';
+
+export const handler = (input) => {
+  return helper(input);
+};
+`;
+      const parsed = parseFunctionCode(source);
+      expect(parsed.parameters).toEqual(['input']);
+    });
+  });
+
+  describe('validateFunctionNode', () => {
+    it('should validate function node with valid content', () => {
+      const node = {
+        id: 'func1',
+        name: 'TestFunction',
+        content: {
+          source: 'export const handler = (input) => ({ output: input })',
+        },
+      };
+      const result = validateFunctionNode(node);
+      expect(result.source).toContain('export const handler');
+      expect(result.parameters).toEqual(['input']);
+      expect(result.ast).toBeDefined();
+    });
+
+    it('should throw error for function node with missing content', () => {
+      const node = {
+        id: 'func1',
+        name: 'TestFunction',
+      };
+      expect(() => validateFunctionNode(node)).toThrow('missing required content field');
+    });
+
+    it('should throw error for function node with invalid syntax', () => {
+      const node = {
+        id: 'func1',
+        name: 'TestFunction',
+        content: {
+          source: 'invalid javascript syntax {{{',
+        },
+      };
+      expect(() => validateFunctionNode(node)).toThrow('Failed to parse function code');
+    });
+
+    it('should validate legacy format function node', () => {
+      const node = {
+        id: 'func1',
+        name: 'TestFunction',
+        content: 'export const handler = (input) => ({ output: input })',
+      };
+      const result = validateFunctionNode(node);
+      expect(result.source).toContain('export const handler');
+      expect(result.parameters).toEqual(['input']);
+    });
+  });
+
+  describe('FunctionNodeContent interface', () => {
+    it('should have correct structure', () => {
+      const content: FunctionNodeContent = {
+        source: 'test source',
+        parameters: ['input', 'context'],
+        ast: null,
+      };
+      expect(content.source).toBe('test source');
+      expect(content.parameters).toEqual(['input', 'context']);
+      expect(content.ast).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { compileInputNode } from '../../../../src/compiler/nodes/input';
+import { NodeType, type JDMNode } from '../../../../src/compiler/parser';
+import { createMockContext } from '../../../helpers';
+
+/**
+ * Input Node Compilation Tests
+ *
+ * These tests verify that the input node compiler produces valid output.
+ * The actual behavior of the generated code is tested through integration tests.
+ */
+describe('Input Node Compilation', () => {
+  describe('compileInputNode', () => {
+    it('should generate code for an input node', () => {
+      const node: JDMNode = {
+        id: 'input1',
+        type: NodeType.INPUT,
+        name: 'Input Node',
+        position: { x: 0, y: 0 },
+      };
+
+      const context = createMockContext();
+      const code = compileInputNode(node, context);
+
+      // Verify code is generated
+      expect(typeof code).toBe('string');
+      expect(code.length).toBeGreaterThan(0);
+    });
+  });
+});

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

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+import { compileSwitchNode } from '../../../../src/compiler/nodes/switch';
+import { NodeType, type JDMNode } from '../../../../src/compiler/parser';
+import { createMockContext } from '../../../helpers';
+
+/**
+ * Switch Node Compilation Tests
+ *
+ * These tests verify the compiler's validation and error handling for switch nodes.
+ * The actual code generation behavior is tested through integration tests that compile
+ * and execute the generated code.
+ */
+describe('Switch Node Compilation', () => {
+  describe('compileSwitchNode', () => {
+    // Custom parseExpression for switch node tests
+    const parseExpression = (expr: string) => {
+      // Return a simple AST for basic expressions
+      if (expr === 'true' || expr === 'false') {
+        return { type: 'BooleanLiteral', value: expr === 'true' };
+      }
+      if (expr.includes('could not parse')) {
+        throw new Error('Parse error');
+      }
+      // Default to a boolean literal for simplicity in tests
+      return { type: 'BooleanLiteral', value: true };
+    };
+
+    const createSwitchNode = (
+      id: string,
+      statements: Array<{ id: string; condition: string }>,
+      hitPolicy?: string,
+      extraFields?: Record<string, any>,
+    ): JDMNode => ({
+      id,
+      type: NodeType.SWITCH,
+      name: 'Switch Node',
+      position: { x: 0, y: 0 },
+      content: {
+        statements,
+        hitPolicy: hitPolicy as any,
+        ...extraFields,
+      },
+    });
+
+    it('should generate code for a switch node', () => {
+      const node = createSwitchNode('switch-1', []);
+      const context = createMockContext({ parseExpression });
+      const code = compileSwitchNode(node, context);
+
+      expect(typeof code).toBe('string');
+      expect(code.length).toBeGreaterThan(0);
+    });
+
+    it('should generate code with different hit policies', () => {
+      const policies = ['first', 'collect', 'ruleOrder', 'outputOrder', 'priority'];
+
+      for (const policy of policies) {
+        const node = createSwitchNode(`switch-${policy}`, [{ id: 'cond1', condition: 'true' }]);
+        node.content.hitPolicy = policy;
+
+        const context = createMockContext({
+          parseExpression,
+          edges: [
+            {
+              id: 'edge1',
+              type: 'edge',
+              sourceId: `switch-${policy}`,
+              targetId: 'nodeA',
+              sourceHandle: 'cond1',
+            },
+          ],
+        });
+
+        const code = compileSwitchNode(node, context);
+        expect(code.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should gracefully handle parse errors in expressions', () => {
+      const node = createSwitchNode('switch-error', [
+        { id: 'cond1', condition: 'could not parse' },
+      ]);
+
+      const context = createMockContext({
+        parseExpression,
+        edges: [
+          {
+            id: 'edge1',
+            type: 'edge',
+            sourceId: 'switch-error',
+            targetId: 'node1',
+            sourceHandle: 'cond1',
+          },
+        ],
+      });
+
+      const code = compileSwitchNode(node, context);
+
+      // Should include error comment in generated code
+      expect(code).toContain('/* ERROR: Could not parse expression */');
+    });
+
+    it('should compile successfully when RETURN_DEFAULT is used with a value', () => {
+      const node = createSwitchNode('switch-no-match-default-with-value', [
+        { id: 'cond1', condition: 'false' },
+      ]);
+      node.content.noMatchBehavior = { type: 'returnDefault', value: 'default-value' };
+
+      const context = createMockContext({
+        parseExpression,
+        edges: [
+          {
+            id: 'edge1',
+            type: 'edge',
+            sourceId: 'switch-no-match-default-with-value',
+            targetId: 'node1',
+            sourceHandle: 'cond1',
+          },
+        ],
+      });
+
+      const code = compileSwitchNode(node, context);
+      expect(code).toContain('Value.String("default-value")');
+      expect(code).not.toContain('Value.Null()');
+    });
+  });
+});