@divmain/jdm-asm 0.2.0

package/test-data/zen-reference/table.json

@@ -0,0 +1,76 @@
+{
+  "nodes": [
+    {
+      "id": "3e3f5093-c969-4c3a-97e1-560e4b769a12",
+      "type": "inputNode",
+      "position": {
+        "x": 150,
+        "y": 210
+      },
+      "name": "Request"
+    },
+    {
+      "id": "0624d5fd-1944-4781-92bb-e32873ce91e2",
+      "type": "decisionTableNode",
+      "position": {
+        "x": 410,
+        "y": 210
+      },
+      "name": "Hello",
+      "content": {
+        "hitPolicy": "first",
+        "inputs": [
+          {
+            "field": "input",
+            "id": "xWauegxfG7",
+            "name": "Input",
+            "type": "expression"
+          }
+        ],
+        "outputs": [
+          {
+            "field": "output",
+            "id": "qGAHmak0xj",
+            "name": "Output",
+            "type": "expression"
+          }
+        ],
+        "rules": [
+          {
+            "_id": "5ZnYGPFT-N",
+            "xWauegxfG7": "> 10",
+            "qGAHmak0xj": "10"
+          },
+          {
+            "_id": "pSg-vIQR5Q",
+            "xWauegxfG7": "",
+            "qGAHmak0xj": "0"
+          }
+        ]
+      }
+    },
+    {
+      "id": "e0438c6b-dee0-405e-a941-9b4c3d9c4b83",
+      "type": "outputNode",
+      "position": {
+        "x": 660,
+        "y": 210
+      },
+      "name": "Response"
+    }
+  ],
+  "edges": [
+    {
+      "id": "c30b9bfd-2da6-445f-a31a-31eeb4bfa803",
+      "sourceId": "3e3f5093-c969-4c3a-97e1-560e4b769a12",
+      "type": "edge",
+      "targetId": "0624d5fd-1944-4781-92bb-e32873ce91e2"
+    },
+    {
+      "id": "dbda85da-4c1d-4e0b-b4e7-9bb475bd00b9",
+      "sourceId": "0624d5fd-1944-4781-92bb-e32873ce91e2",
+      "type": "edge",
+      "targetId": "e0438c6b-dee0-405e-a941-9b4c3d9c4b83"
+    }
+  ]
+}

package/tests/helpers/index.ts

@@ -0,0 +1,73 @@
+/**
+ * Test helper utilities for JDM-ASM.
+ *
+ * This module exports utilities for writing tests:
+ *
+ * - **Round-trip testing**: Verify marshal/unmarshal operations
+ * - **WASM testing**: Compile and evaluate JDM decisions
+ * - **JDM builders**: Create JDM structures for testing
+ *
+ * @module tests/helpers
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   // Round-trip testing
+ *   testMarshalRoundTrip,
+ *   testMarshalRoundTripBatch,
+ *   executeRoundTrip,
+ *
+ *   // WASM testing
+ *   compileAndEvaluate,
+ *   compileAndEvaluateInline,
+ *   compileAndEvaluateFull,
+ *
+ *   // JDM builders
+ *   createExpressionJDM,
+ *   createDecisionTableJDM,
+ *   createSwitchJDM,
+ *
+ *   // Utilities
+ *   inferSchema,
+ *   deepEqual,
+ *   assertEvaluationResult,
+ *
+ *   // Mock factories
+ *   createMockContext,
+ *   createMockContextWithRealParser,
+ * } from '../tests/helpers';
+ * ```
+ */
+
+// Round-trip testing utilities
+export {
+  testMarshalRoundTrip,
+  testMarshalRoundTripBatch,
+  executeRoundTrip,
+  deepEqual,
+  createRoundTripTester,
+  type RoundTripOptions,
+  type RoundTripResult,
+} from './round-trip';
+
+// WASM testing utilities
+export {
+  compileAndEvaluate,
+  compileAndEvaluateInline,
+  compileAndEvaluateFull,
+  compileJDM,
+  createExpressionJDM,
+  createDecisionTableJDM,
+  createSwitchJDM,
+  inferSchema,
+  assertEvaluationResult,
+  type CompileAndEvaluateOptions,
+  type EvaluationResult,
+} from './wasm-test';
+
+// Mock context factory utilities
+export {
+  createMockContext,
+  createMockContextWithRealParser,
+  type MockContextOptions,
+} from './mock-context';

package/tests/helpers/mock-context.ts

@@ -0,0 +1,231 @@
+/**
+ * Mock Context Factory
+ *
+ * Shared factory for creating mock CompilationContext objects in unit tests.
+ * This eliminates duplication of the createMockContext function across test files.
+ *
+ * @module tests/helpers/mock-context
+ */
+
+import type { CompilationContext } from '../../src/compiler/types';
+import { Type, type TSchema } from '@sinclair/typebox';
+import type { JDMDecision } from '../../src/compiler/parser';
+import { parseUnaryExpression } from '../../src/compiler/unary-parser';
+
+/**
+ * Options for customizing the mock context.
+ */
+export interface MockContextOptions {
+  /**
+   * Custom input schema (defaults to empty object schema)
+   */
+  inputSchema?: TSchema;
+
+  /**
+   * Custom output schema (defaults to empty object schema)
+   */
+  outputSchema?: TSchema;
+
+  /**
+   * Field names to create in the input layout.
+   * Each field will be created as f64 type with offset 0 and size 8.
+   */
+  inputFields?: string[];
+
+  /**
+   * Field names to create in the output layout.
+   * Each field will be created as f64 type with offset 0 and size 8.
+   */
+  outputFields?: string[];
+
+  /**
+   * Custom parseExpression function.
+   * Defaults to a simple mock that returns an empty object.
+   */
+  parseExpression?: (expr: string) => any;
+
+  /**
+   * Custom parseUnaryExpression function.
+   * Defaults to a simple mock that returns an empty object.
+   */
+  parseUnaryExpression?: (expr: string) => any;
+
+  /**
+   * Custom loadDecision function.
+   * Defaults to throwing an error "Mock loader not configured".
+   */
+  loadDecision?: (key: string) => JDMDecision;
+
+  /**
+   * Custom getUniqueId function.
+   * Defaults to using Math.random() for ID generation.
+   */
+  getUniqueId?: (prefix: string) => string;
+
+  /**
+   * JDM nodes to include in the context.
+   * Defaults to empty array.
+   */
+  nodes?: any[];
+
+  /**
+   * JDM edges to include in the context.
+   * Defaults to empty array.
+   */
+  edges?: any[];
+
+  /**
+   * Compiler options.
+   * Defaults to empty object.
+   */
+  options?: any;
+
+  /**
+   * Pre-compiled sub-decisions.
+   * Defaults to empty Map.
+   */
+  compiledSubDecisions?: Map<string, string>;
+
+  /**
+   * Decision path for cycle detection.
+   * Defaults to empty array.
+   */
+  decisionPath?: string[];
+
+  /**
+   * Helper functions map.
+   * Defaults to empty Map.
+   */
+  helperFunctions?: Map<string, string>;
+
+  /**
+   * Function sources for JavaScript bridge.
+   */
+  functionSources?: Map<string, string>;
+
+  /**
+   * Schema hash for runtime validation.
+   * Defaults to 0n.
+   */
+  schemaHash?: bigint;
+}
+
+/**
+ * Creates a mock CompilationContext for testing.
+ *
+ * This factory function provides sensible defaults for all required fields
+ * and allows selective override of specific properties via options.
+ *
+ * @param options - Optional customization options
+ * @returns A mock CompilationContext suitable for unit tests
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with defaults
+ * const ctx = createMockContext();
+ *
+ * // With input fields
+ * const ctx = createMockContext({
+ *   inputFields: ['age', 'income']
+ * });
+ *
+ * // With real parser
+ * import { parseUnaryExpression } from '../../src/compiler/unary-parser';
+ * const ctx = createMockContext({
+ *   parseExpression: parseUnaryExpression,
+ *   parseUnaryExpression: parseUnaryExpression
+ * });
+ *
+ * // With custom parser logic
+ * const ctx = createMockContext({
+ *   parseExpression: (expr) => {
+ *     if (expr === "true") return { type: "BooleanLiteral", value: true };
+ *     if (expr === "false") return { type: "BooleanLiteral", value: false };
+ *     throw new Error("Parse error");
+ *   }
+ * });
+ * ```
+ */
+export function createMockContext(options: MockContextOptions = {}): CompilationContext {
+  const {
+    inputSchema = Type.Object({}),
+    outputSchema = Type.Object({}),
+    inputFields = [],
+    outputFields = [],
+    parseExpression = () => ({}),
+    parseUnaryExpression = () => ({}),
+    loadDecision = () => {
+      throw new Error('Mock loader not configured');
+    },
+    getUniqueId = (prefix: string) => `${prefix}_${Math.random().toString(36).substr(2, 9)}`,
+    nodes = [],
+    edges = [],
+    options: compilerOptions = {},
+    compiledSubDecisions = new Map(),
+    decisionPath = [],
+    helperFunctions = new Map<string, string>(),
+    functionSources,
+    schemaHash = 0n,
+  } = options;
+
+  return {
+    jdm: {
+      nodes,
+      edges,
+    },
+    inputSchema,
+    outputSchema,
+    inputLayout: {
+      fields: inputFields.map((path) => ({
+        path,
+        flatName: path.replace(/\./g, '_'),
+        type: 'f64' as any,
+        offset: 0,
+        size: 8,
+      })),
+    },
+    outputLayout: {
+      fields: outputFields.map((path) => ({
+        path,
+        flatName: path.replace(/\./g, '_'),
+        type: 'f64' as any,
+        offset: 0,
+        size: 8,
+      })),
+    },
+    schemaHash,
+    options: compilerOptions,
+    parseExpression,
+    parseUnaryExpression,
+    loadDecision,
+    compiledSubDecisions,
+    decisionPath,
+    getUniqueId,
+    helperFunctions,
+    ...(functionSources && { functionSources }),
+  };
+}
+
+/**
+ * Creates a mock context with real parsers.
+ *
+ * Convenience function that uses the actual unary expression parser
+ * instead of a mock.
+ *
+ * @param options - Optional customization options
+ * @returns A mock CompilationContext with real parsers
+ *
+ * @example
+ * ```typescript
+ * const ctx = createMockContextWithRealParser();
+ * ```
+ */
+export function createMockContextWithRealParser(
+  options: Omit<MockContextOptions, 'parseExpression' | 'parseUnaryExpression'> = {},
+): CompilationContext {
+  return createMockContext({
+    ...options,
+    parseExpression: parseUnaryExpression,
+    parseUnaryExpression: parseUnaryExpression,
+  });
+}