@divmain/jdm-asm 0.2.0 → 0.2.3

package/tests/integration/expressions.test.ts

@@ -1,513 +0,0 @@
-/**
- * Expression Evaluation Tests
- *
- * Test suite for expression node evaluation, organized by subset:
- * - Subset 1: Basic Arithmetic & Comparisons
- * - Subset 2: Logical Operators
- * - Subset 3: String Operations
- * - Subset 4: Built-in Functions (coming later)
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'fs';
-import { runSimpleCompatibilityTest, type SimpleTestConfig } from '../helpers/test-harness';
-
-/**
- * Load a test fixture from file
- */
-function loadFixture(filePath: string): string {
-  const content = readFileSync(filePath, 'utf-8');
-  return content;
-}
-
-/**
- * Load a complete test configuration including input and expected values
- * Uses SimpleTestConfig to avoid TypeBox schema requirements
- */
-function loadTestWithFixture(
-  fixturePath: string,
-  input?: Record<string, unknown>,
-  expected?: Record<string, unknown>,
-  unsupported?: string[],
-  skipZen?: boolean,
-): SimpleTestConfig {
-  const jdm = loadFixture(fixturePath);
-  return {
-    name: fixturePath.split('/').pop() || 'unknown',
-    jdm,
-    input,
-    expected,
-    unsupported,
-    skipZen,
-  };
-}
-
-describe('Expression Evaluation', () => {
-  // Subset 1: Basic Arithmetic & Comparisons
-  describe('Subset 1: Basic Arithmetic & Comparisons', () => {
-    const testDir = 'test-data/expressions/arithmetic';
-
-    it('should evaluate arithmetic expressions', async () => {
-      const test = loadTestWithFixture(`${testDir}/expression.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    it('should handle expression passthrough', async () => {
-      const test = loadTestWithFixture(`${testDir}/expression-passthrough.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    it('should evaluate expressions with defaults', async () => {
-      const test = loadTestWithFixture(`${testDir}/expression-default.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    it('should handle nested requests', async () => {
-      const test = loadTestWithFixture(`${testDir}/nested-request.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    // inputField/outputPath scoping - expressions resolve from within the specified sub-object
-    it('should evaluate expression fields', async () => {
-      const test = loadTestWithFixture(`${testDir}/expression-fields.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    // executionMode:'loop' - evaluate expressions for each item in an array
-    it('should handle expression loops', async () => {
-      const test = loadTestWithFixture(`${testDir}/expression-loop.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    it('should test number functions', async () => {
-      const test = loadTestWithFixture(`${testDir}/test-number-functions.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    // Note: This test was a duplicate (same as "should handle expression loops")
-    // Now testing that loop also works with the same fixture
-    it('should handle expression loops (duplicate fixture)', async () => {
-      const test = loadTestWithFixture(`${testDir}/expression-loop.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    describe('Error Cases', () => {
-      // Error detection tests verify proper handling of:
-      // - Missing input nodes
-      // - Missing output nodes
-      // - Cyclic dependencies
-
-      it('should detect missing input errors', async () => {
-        const jdm = loadFixture('test-data/expressions/arithmetic/error-missing-input.json');
-
-        // Define a schema that doesn't include all referenced inputs
-        const inputSchema = {
-          type: 'object',
-          properties: {
-            numbers: { type: 'array', items: { type: 'number' } },
-          },
-        } as any;
-
-        const outputSchema = {
-          type: 'object',
-          properties: {
-            result: { type: 'number' },
-          },
-        } as any;
-
-        // Create a compile function with validation enabled
-        // Note: validation is disabled by default in compile(), so we need to patch it
-        // For now, we'll test by directly calling the compileDecision function with validation
-
-        // First, let's test that the validation module works correctly
-        const { parseStandardExpression } = await import('../../src/compiler/unary-parser');
-        const { collectIdentifiers, validateInputReferences } =
-          await import('../../src/compiler/input-validation');
-
-        // Compile expressions and collect identifiers
-        const identifiers = new Set<string>();
-        const jdmObj = JSON.parse(jdm);
-        for (const node of jdmObj.nodes) {
-          if (node.type === 'expressionNode' && node.content?.expressions) {
-            for (const expr of node.content.expressions) {
-              const ast = parseStandardExpression(expr.value);
-              const exprIds = collectIdentifiers(ast);
-              exprIds.forEach((id) => identifiers.add(id));
-            }
-          }
-        }
-
-        // Check that we collected the expected identifiers
-        expect(identifiers.has('numbers')).toBe(true);
-        expect(identifiers.has('firstName')).toBe(true);
-        expect(identifiers.has('lastName')).toBe(true);
-
-        // Now create a mock context and validate
-        const mockContext = {
-          inputLayout: {
-            fields: [
-              { path: 'numbers', flatName: 'numbers', type: 'array' as any, offset: 0, size: 8 },
-            ],
-          },
-          jdm: jdmObj,
-          inputSchema: inputSchema,
-          outputSchema: outputSchema,
-          outputLayout: { fields: [] },
-          schemaHash: 0n,
-          options: {},
-          parseExpression: parseStandardExpression as any,
-          parseUnaryExpression: parseStandardExpression as any,
-          getUniqueId: ((prefix: string) => prefix) as any,
-          loadDecision: ((_key: string) => {
-            throw new Error('Not implemented');
-          }) as any,
-          compiledSubDecisions: new Map(),
-          decisionPath: [],
-          helperFunctions: new Map(),
-        };
-
-        // This should throw an error about missing inputs
-        expect(() => validateInputReferences(identifiers, mockContext)).toThrow();
-      });
-
-      it('should detect missing output errors', async () => {
-        const jdm = loadFixture('test-data/expressions/arithmetic/error-missing-output.json');
-
-        // Define input schema that matches the used inputs
-        const inputSchema = {
-          type: 'object',
-          properties: {
-            numbers: { type: 'array', items: { type: 'number' } },
-            firstName: { type: 'string' },
-            lastName: { type: 'string' },
-          },
-        } as any;
-
-        // Define output schema that includes outputs NOT assigned by the expression node
-        // The expression node assigns: deep.nested.sum, fullName, largeNumbers, smallNumbers
-        // But we'll also require: result, timestamp (which are NOT assigned)
-        const outputSchema = {
-          type: 'object',
-          properties: {
-            result: { type: 'number' }, // NOT assigned
-            timestamp: { type: 'number' }, // NOT assigned
-            'deep.nested.sum': { type: 'number' }, // assigned
-            fullName: { type: 'string' }, // assigned
-            largeNumbers: { type: 'array', items: { type: 'number' } }, // assigned
-            smallNumbers: { type: 'array', items: { type: 'number' } }, // assigned
-          },
-        } as any;
-
-        // Create mock layout directly
-        const outputLayout = {
-          fields: [
-            { path: 'result', flatName: 'result', type: 'f64' as const, offset: 0, size: 8 },
-            { path: 'timestamp', flatName: 'timestamp', type: 'f64' as const, offset: 8, size: 8 },
-            {
-              path: 'deep.nested.sum',
-              flatName: 'deep_nested_sum',
-              type: 'f64' as const,
-              offset: 16,
-              size: 8,
-            },
-            {
-              path: 'fullName',
-              flatName: 'fullName',
-              type: 'string' as const,
-              offset: 24,
-              size: -1,
-            },
-            {
-              path: 'largeNumbers',
-              flatName: 'largeNumbers',
-              type: 'array' as const,
-              offset: 32,
-              size: -1,
-            },
-            {
-              path: 'smallNumbers',
-              flatName: 'smallNumbers',
-              type: 'array' as const,
-              offset: 40,
-              size: -1,
-            },
-          ],
-        };
-
-        // Create a mock context
-        const mockContext = {
-          inputLayout: {
-            fields: [
-              { path: 'numbers', flatName: 'numbers', type: 'array' as any, offset: 0, size: 8 },
-              {
-                path: 'firstName',
-                flatName: 'firstName',
-                type: 'string' as any,
-                offset: 8,
-                size: 24,
-              },
-              {
-                path: 'lastName',
-                flatName: 'lastName',
-                type: 'string' as any,
-                offset: 32,
-                size: 24,
-              },
-            ],
-          },
-          jdm: JSON.parse(jdm),
-          inputSchema: inputSchema,
-          outputSchema: outputSchema,
-          outputLayout: outputLayout,
-          schemaHash: 0n,
-          options: {},
-          parseExpression: ((expr: string) => {
-            const { parseStandardExpression } = require('../../src/compiler/unary-parser');
-            return parseStandardExpression(expr);
-          }) as any,
-          parseUnaryExpression: ((expr: string) => {
-            const { parseStandardExpression } = require('../../src/compiler/unary-parser');
-            return parseStandardExpression(expr);
-          }) as any,
-          getUniqueId: ((prefix: string) => prefix) as any,
-          loadDecision: ((_key: string) => {
-            throw new Error('Not implemented');
-          }) as any,
-          compiledSubDecisions: new Map(),
-          decisionPath: [],
-          helperFunctions: new Map(),
-        };
-
-        // Test using the validation module directly
-        const { collectOutputAssignments, validateOutputReferences } =
-          await import('../../src/compiler/input-validation');
-
-        // Collect assigned outputs
-        const assignedOutputs = collectOutputAssignments(mockContext);
-
-        // Check that we collected the expected outputs
-        expect(assignedOutputs.has('deep.nested.sum')).toBe(true);
-        expect(assignedOutputs.has('fullName')).toBe(true);
-        expect(assignedOutputs.has('largeNumbers')).toBe(true);
-        expect(assignedOutputs.has('smallNumbers')).toBe(true);
-
-        // This should throw an error about missing outputs
-        expect(() => validateOutputReferences(assignedOutputs, mockContext)).toThrow();
-      });
-      it.todo('should detect cyclic dependencies');
-    });
-  });
-
-  // Subset 2: Logical Operators
-  describe('Subset 2: Logical Operators', () => {
-    const testDir = 'test-data/expressions/logical';
-
-    it('should evaluate logical AND operators', async () => {
-      const test = loadTestWithFixture(`${testDir}/logical-and.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    it('should evaluate logical OR operators', async () => {
-      const test = loadTestWithFixture(`${testDir}/logical-or.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate logical NOT operators', async () => {
-      const test = loadTestWithFixture(`${testDir}/logical-not.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-
-    it('should handle complex logical expressions', async () => {
-      const test = loadTestWithFixture(`${testDir}/logical-complex.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-  });
-
-  // Subset 3: String Operations
-  describe('Subset 3: String Operations', () => {
-    const testDir = 'test-data/expressions/string';
-
-    // Tests will be added progressively as we implement string operation support
-
-    it('should concatenate strings', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-concat.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should handle string comparison operators', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-comparison.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate upper() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-upper.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate lower() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-lower.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate trim() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-trim.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate substring() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-substring.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate indexOf() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-indexOf.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate startsWith() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-startsWith.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate endsWith() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-endsWith.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate contains() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-contains.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate split() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-split.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate join() string function', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-join.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate replace() and replaceAll() string functions', async () => {
-      const test = loadTestWithFixture(
-        `${testDir}/string-replace.json`,
-        undefined,
-        undefined,
-        undefined,
-        true,
-      );
-      await runSimpleCompatibilityTest(test);
-    });
-    it.todo('should evaluate string built-in functions');
-  });
-
-  // Subset 4: Built-in Functions
-  describe('Subset 4: Built-in Functions', () => {
-    const testDir = 'test-data/expressions/functions';
-
-    // Tests will be added progressively as we implement built-in functions
-
-    it.todo('should evaluate sum() function');
-    it.todo('should evaluate count() function');
-    it('should evaluate avg() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/avg.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate filter() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/filter.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate map() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/map.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate map() with string transformations', async () => {
-      const test = loadTestWithFixture(`${testDir}/map-strings.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate reduce() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/reduce.json`);
-      await runSimpleCompatibilityTest({ ...test, skipZen: true });
-    });
-    it('should evaluate all() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/all.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate some() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/some.json`);
-      await runSimpleCompatibilityTest(test);
-    });
-    it('should evaluate sort() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/sort.json`);
-      await runSimpleCompatibilityTest({ ...test, skipZen: true });
-    });
-    it('should evaluate sort() with strings', async () => {
-      const test = loadTestWithFixture(`${testDir}/sort-strings.json`);
-      await runSimpleCompatibilityTest({ ...test, skipZen: true });
-    });
-    it('should evaluate flat() function', async () => {
-      const test = loadTestWithFixture(`${testDir}/flat.json`);
-      await runSimpleCompatibilityTest({ ...test, skipZen: true });
-    }, 15000); // Increase timeout for 14 test cases
-  });
-});

package/tests/integration/function-node-integration.test.ts

@@ -1,182 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { compile, type JDMDecision } from '../../src/compiler';
-
-describe('Function Node Integration Tests', () => {
-  it('should compile a decision with function node', async () => {
-    const jdm: JDMDecision = {
-      nodes: [
-        {
-          id: 'input-1',
-          type: 'inputNode' as any,
-          position: { x: 0, y: 0 },
-          name: 'Request',
-        },
-        {
-          id: 'func-1',
-          type: 'functionNode' as any,
-          position: { x: 200, y: 0 },
-          name: 'CustomFunction',
-          content: {
-            source: 'export const handler = (input) => ({ output: input.input * 2 })',
-          },
-        },
-        {
-          id: 'output-1',
-          type: 'outputNode' as any,
-          position: { x: 400, y: 0 },
-          name: 'Response',
-        },
-      ],
-      edges: [
-        { id: 'edge-1', sourceId: 'input-1', targetId: 'func-1', type: 'edge' },
-        { id: 'edge-2', sourceId: 'func-1', targetId: 'output-1', type: 'edge' },
-      ],
-    };
-
-    const InputSchema = Type.Object({
-      input: Type.Number(),
-    });
-
-    const OutputSchema = Type.Object({
-      output: Type.Number(),
-    });
-
-    // Should compile without errors
-    const result = await compile({
-      inputSchema: InputSchema,
-      outputSchema: OutputSchema,
-      jdm,
-      optimize: false,
-      debug: true,
-    });
-
-    expect(result.wasm).toBeDefined();
-    expect(result.wasm.length).toBeGreaterThan(0);
-    expect(result.schemaHash).toBeDefined();
-    expect(result.marshalCode).toBeDefined();
-    expect(result.validationCode).toBeDefined();
-
-    // Check that function sources are stored in the compilation context
-    // (This is important for future JavaScript bridge implementation)
-    if (result.assemblyScript) {
-      expect(result.assemblyScript).toContain('evaluateNode_func_1');
-      expect(result.assemblyScript).toContain('_isFunctionNode');
-    }
-  }, 10000);
-
-  it('should compile a decision with function node with multiple parameters', async () => {
-    const jdm: JDMDecision = {
-      nodes: [
-        {
-          id: 'input-1',
-          type: 'inputNode' as any,
-          position: { x: 0, y: 0 },
-          name: 'Request',
-        },
-        {
-          id: 'func-2',
-          type: 'functionNode' as any,
-          position: { x: 200, y: 0 },
-          name: 'MultiParamFunction',
-          content: {
-            source:
-              'export const handler = (input, context) => ({ result: input.value + context.offset })',
-          },
-        },
-        {
-          id: 'output-1',
-          type: 'outputNode' as any,
-          position: { x: 400, y: 0 },
-          name: 'Response',
-        },
-      ],
-      edges: [
-        { id: 'edge-1', sourceId: 'input-1', targetId: 'func-2', type: 'edge' },
-        { id: 'edge-2', sourceId: 'func-2', targetId: 'output-1', type: 'edge' },
-      ],
-    };
-
-    const InputSchema = Type.Object({
-      value: Type.Number(),
-      offset: Type.Number(),
-    });
-
-    const OutputSchema = Type.Object({
-      result: Type.Number(),
-    });
-
-    const result = await compile({
-      inputSchema: InputSchema,
-      outputSchema: OutputSchema,
-      jdm,
-      optimize: false,
-      debug: true,
-    });
-
-    expect(result.wasm).toBeDefined();
-    if (result.assemblyScript) {
-      const as = result.assemblyScript;
-      expect(as).toContain('evaluateNode_func_2');
-      expect(as).toContain('let input = ctx.get("input");');
-      expect(as).toContain('let context = ctx.get("context");');
-    }
-  }, 10000);
-
-  it('should compile a decision with function node v2 format', async () => {
-    const jdm: JDMDecision = {
-      nodes: [
-        {
-          id: 'input-1',
-          type: 'inputNode' as any,
-          position: { x: 100, y: 95 },
-          name: 'request',
-        },
-        {
-          id: 'output-1',
-          type: 'outputNode' as any,
-          position: { x: 515, y: 255 },
-          name: 'response',
-        },
-        {
-          id: 'func-3',
-          type: 'functionNode' as any,
-          content: {
-            source:
-              'export const handler = async (input) => ({ hello: "world", multiplied: input.input * 2 })',
-          },
-          position: { x: 210, y: 285 },
-          name: 'function1',
-        },
-      ],
-      edges: [
-        { id: 'edge-1', sourceId: 'input-1', targetId: 'func-3', type: 'edge' },
-        { id: 'edge-2', sourceId: 'func-3', targetId: 'output-1', type: 'edge' },
-      ],
-    };
-
-    const InputSchema = Type.Object({
-      input: Type.Number(),
-    });
-
-    const OutputSchema = Type.Object({
-      hello: Type.String(),
-      multiplied: Type.Number(),
-    });
-
-    const result = await compile({
-      inputSchema: InputSchema,
-      outputSchema: OutputSchema,
-      jdm,
-      optimize: false,
-      debug: true,
-    });
-
-    expect(result.wasm).toBeDefined();
-    if (result.assemblyScript) {
-      const as = result.assemblyScript;
-      expect(as).toContain('evaluateNode_func_3');
-      expect(as).toContain('function1'); // check the function name is in the comments
-    }
-  }, 10000);
-});