@divmain/jdm-asm 0.2.0

package/src/compiler/nodes/decision-table.ts

@@ -0,0 +1,507 @@
+import type { JDMNode } from '../parser';
+import type { CompilationContext, AssemblyScriptCode, NoMatchBehavior } from '../types';
+import { sanitizeId } from '../utils';
+import { compileExpression } from './expression';
+import { replaceDollarRefWithCode, compileExpressionWithInlineCode } from '../unary-transform';
+
+/**
+ * Decision table content structure.
+ */
+interface DecisionTableContent {
+  rules: any[];
+  inputs: any[];
+  outputs: any[];
+  hitPolicy: 'first' | 'collect' | 'unique' | 'ruleOrder' | 'outputOrder' | 'priority';
+  /** Override the global no-match behavior for this table */
+  noMatchBehavior?: NoMatchBehavior;
+  /** Whether to pass through input values to output */
+  passThrough?: boolean;
+}
+
+/**
+ * Compile a comparison expression for a decision table condition.
+ *
+ * In decision tables, expressions are evaluated in a "unary" context where
+ * the $ symbol is automatically bound to the input field's value.
+ *
+ * For example:
+ * - "> 100" becomes "$ > 100" with $ bound to the input field
+ * - "admin" becomes "$ == admin" (equality check)
+ * - "[1..10]" becomes "$ in [1..10]" (range check)
+ *
+ * The field parameter can be either:
+ * - A simple field name like "creditScore" → ctx.get("creditScore")
+ * - An expression like "date(order.createdAt)" → needs to be parsed and evaluated
+ *
+ * Since AssemblyScript doesn't support closures, we transform the AST
+ * to replace DollarRef nodes with the compiled field expression.
+ *
+ * @param expr - The raw expression string
+ * @param inputType - The type of the input field
+ * @param field - The field expression to compare against
+ * @param context - The compilation context
+ * @returns Compiled AssemblyScript code for the comparison
+ */
+function compileComparison(
+  expr: string,
+  inputType: string,
+  field: string | undefined,
+  context: CompilationContext,
+): string {
+  // Handle empty expressions or unset values. Empty cells mean "any value matches" for
+  // that column. This is flexible (allows partial rule specification) but can be dangerous
+  // (typos become wildcards). Following DMN/JDM convention where blank = don't care.
+  if (!expr || expr === '' || expr === '-') {
+    return 'true';
+  }
+
+  try {
+    // When input field is "$", the cell contains a full boolean expression rather than a
+    // unary comparison:
+    //   e.g., "age > 18 and tier == 'gold'"
+    // This allows complex conditions that span multiple input values in a single cell, useful
+    // for cross-column logic.
+    if (!field || field === '$') {
+      // Parse and compile the expression directly as a standard expression
+      const ast = context.parseExpression(expr);
+      const compiledExpr = compileExpression(ast, context);
+      return `${compiledExpr}.asBool()`;
+    }
+
+    // Parse the expression using unary parser for decision table cells
+    // This transforms expressions like "> 100" into AST representing "$ > 100"
+    const ast = context.parseUnaryExpression(expr);
+
+    // Compile the field expression to get the value to compare against
+    // The field can be a simple name like "creditScore" or an expression like "date(order.createdAt)"
+    const fieldAst = context.parseExpression(field);
+    const compiledField = compileExpression(fieldAst, context);
+
+    // Transform the AST to replace DollarRef nodes with the compiled field expression
+    // AssemblyScript doesn't support closures, so we can't create a function context
+    // where $ refers to the field value. Instead, we do direct AST substitution.
+    const transformedAst = replaceDollarRefWithCode(ast, compiledField);
+
+    // Compile the transformed AST to AssemblyScript code
+    const compiledExpr = compileExpressionWithInlineCode(transformedAst, context);
+
+    // Return the compiled expression wrapped in .asBool() for the condition
+    return `${compiledExpr}.asBool()`;
+  } catch (e) {
+    // If parsing fails, log the error and return false (no match)
+    // This prevents compilation failures from breaking the entire decision
+    throw new Error(
+      `Failed to compile decision table condition "${expr}" for field "${field}": ${e}`,
+    );
+  }
+}
+
+/**
+ * Compile an output value for a decision table result.
+ *
+ * @param value - The raw value string
+ * @param outputType - The type of the output field
+ * @param field - The field name being set
+ * @param context - The compilation context
+ * @returns Compiled AssemblyScript code for the value
+ */
+function compileOutputValue(
+  value: string,
+  outputType: string,
+  field: string,
+  context: CompilationContext,
+): string {
+  // Handle empty/unset values: in multi-output tables, rules may set some outputs but not others.
+  // Empty cells mean "this rule doesn't provide a value for this output field", allowing sparse tables.
+  if (!value || value === '-' || value === '') {
+    return '';
+  }
+
+  const normalizedType = (outputType || '').toLowerCase();
+
+  // Check if value is a quoted string literal ('value' or "value")
+  // In JDM format, string literals are often wrapped in single quotes
+  const isQuotedString =
+    (value.startsWith("'") && value.endsWith("'")) ||
+    (value.startsWith('"') && value.endsWith('"'));
+
+  // Strip outer quotes if present for string literal values
+  const unquotedValue = isQuotedString ? value.slice(1, -1) : value;
+
+  switch (normalizedType) {
+    case 'expression': {
+      // For expression type, parse and compile the value as an expression
+      // This allows output values to reference context variables or perform calculations
+      const ast = context.parseExpression(value);
+      return compileExpression(ast, context);
+    }
+
+    case 'string':
+    case 'text':
+      // Input values may have quotes that need escaping for the generated AS code. Must escape
+      // both backslashes (for escape sequences) and double quotes (for string delimiters).
+      const escaped = unquotedValue.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+      return 'Value.String("' + escaped + '")';
+
+    case 'number':
+    case 'integer':
+    case 'decimal':
+    case 'double':
+      return `Value.Float(${parseFloat(value)})`;
+
+    case 'boolean':
+    case 'bool':
+      return `Value.Bool(${value.toLowerCase() === 'true'})`;
+
+    default:
+      // For untyped values, infer type through a cascade:
+      // 1. Quoted strings → string literal
+      // 2. "true"/"false" → boolean
+      // 3. Numeric format → number
+      // 4. Otherwise → try parsing as expression, fallback to string literal
+      if (isQuotedString) {
+        // Value is a string literal - use the unquoted value
+        const defaultEscaped = unquotedValue.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        return 'Value.String("' + defaultEscaped + '")';
+      }
+
+      // Check if it's a boolean
+      if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+        return `Value.Bool(${value.toLowerCase() === 'true'})`;
+      }
+
+      // Check if it's a number (use regex to handle trailing zeros like "0.10")
+      // The regex matches integer, decimal, and scientific notation formats
+      if (/^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(value)) {
+        return `Value.Float(${parseFloat(value)})`;
+      }
+
+      // For unquoted non-literal values, treat as an expression
+      // This handles cases like "basicEligibility.reason" or "totalScore * 1.5"
+      try {
+        const ast = context.parseExpression(value);
+        return compileExpression(ast, context);
+      } catch (e) {
+        // Throw error instead of silently falling back to string literal
+        // This prevents type errors and typos from being silently converted to strings
+        throw new Error(
+          `Failed to compile output value "${value}" for field "${field}": ${e}. ` +
+            `If you intended a literal string, wrap it in quotes: '"${value}"' or "'${value}'"`,
+        );
+      }
+  }
+}
+
+/**
+ * Extract string literals from compiled code and generate hoisted constants.
+ * This optimization avoids repeated string allocations in large decision tables.
+ *
+ * Hoisting string literals to module-level constants prevents repeated allocations
+ * that can exhaust WASM memory during table evaluation.
+ *
+ * @param code - The compiled code containing Value.String(...) calls
+ * @param nodeId - Unique identifier for this node (used in constant names)
+ * @returns Object with hoisted constants code and transformed code
+ */
+function hoistStringLiterals(code: string, nodeId: string): { constants: string; code: string } {
+  // Find all Value.String("...") patterns
+  const stringLiteralRegex = /Value\.String\("([^"\\]|\\.)*"\)/g;
+  const matches = code.match(stringLiteralRegex) || [];
+
+  // Count occurrences
+  const counts = new Map<string, number>();
+  for (const match of matches) {
+    counts.set(match, (counts.get(match) || 0) + 1);
+  }
+
+  // Only hoist strings that appear more than once
+  const toHoist = new Map<string, string>();
+  let constIndex = 0;
+  for (const [literal, count] of counts) {
+    if (count > 1) {
+      // Extract the string content for naming
+      const constName = `__str_${sanitizeId(nodeId)}_${constIndex++}`;
+      toHoist.set(literal, constName);
+    }
+  }
+
+  // If nothing to hoist, return original
+  if (toHoist.size === 0) {
+    return { constants: '', code };
+  }
+
+  // Generate constant declarations
+  const constants = Array.from(toHoist.entries())
+    .map(([literal, constName]) => `const ${constName}: Value = ${literal};`)
+    .join('\n');
+
+  // Replace literals with constant references
+  let transformedCode = code;
+  for (const [literal, constName] of toHoist) {
+    // Need to escape regex special chars in the literal
+    const escapedLiteral = literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    transformedCode = transformedCode.replace(new RegExp(escapedLiteral, 'g'), constName);
+  }
+
+  return { constants, code: transformedCode };
+}
+
+/**
+ * Compile a decision table node.
+ *
+ * Generates if/else chains for decision table evaluation, supporting:
+ * - FIRST hit policy: Returns the first matching rule's output
+ * - COLLECT hit policy: Aggregates all matching rules' outputs
+ * - UNIQUE hit policy: Returns output if exactly one rule matches
+ * - RULE ORDER hit policy: Returns all matching rules' outputs in rule order
+ * - OUTPUT ORDER hit policy: Returns all matching rules sorted by output priority
+ * - PRIORITY hit policy: Returns only the highest-priority matching rule
+ *
+ * For large decision tables (many rules with repeated string literals),
+ * string literals are hoisted to module-level constants to avoid
+ * repeated allocations that can exhaust memory.
+ *
+ * @param node - The JDM decision table node
+ * @param context - The compilation context
+ * @returns Generated AssemblyScript code
+ */
+export function compileDecisionTableNode(
+  node: JDMNode,
+  context: CompilationContext,
+): AssemblyScriptCode {
+  const {
+    rules,
+    inputs,
+    outputs,
+    hitPolicy,
+    noMatchBehavior: tableNoMatchBehavior,
+    passThrough,
+  } = node.content as DecisionTableContent;
+
+  // Determine the effective no-match behavior (table-level overrides global)
+  const noMatchBehavior = tableNoMatchBehavior ??
+    context.options.noMatchBehavior ?? { type: 'returnNull' };
+
+  // Unique and priority need to evaluate all rules before making a decision
+  const isCollectAll =
+    hitPolicy === 'collect' ||
+    hitPolicy === 'unique' ||
+    hitPolicy === 'ruleOrder' ||
+    hitPolicy === 'outputOrder' ||
+    hitPolicy === 'priority';
+
+  // Generate the result declaration based on hit policy
+  let resultDeclaration: string;
+  if (isCollectAll) {
+    resultDeclaration = 'let results = new Array<Value>();';
+  } else {
+    resultDeclaration = '';
+  }
+
+  // Generate the rule evaluation branches
+  const ruleBranches = rules
+    .map((rule, idx) => {
+      // Compile all input conditions for this rule
+      const conditions = inputs
+        .map((input) => {
+          const expr = rule[input.id];
+          if (!expr || expr === '' || expr === '-') {
+            return 'true';
+          }
+          return compileComparison(expr, input.type, input.field, context);
+        })
+        .join(' && ');
+
+      // Compile all output values for this rule
+      const resultAssignments = outputs
+        .map((output) => {
+          const value = rule[output.id];
+          if (!value || value === '' || value === '-') {
+            return '';
+          }
+          const compiled = compileOutputValue(value, output.type, output.field, context);
+          return `    result.set("${output.field}", ${compiled});`;
+        })
+        .filter(Boolean)
+        .join('\n');
+
+      // Generate the conditional expression and action
+      if (isCollectAll) {
+        // For collect-mode hit policies, evaluate all rules independently
+        return `
+  if (${conditions || 'true'}) {
+    let result = new Map<string, Value>();
+${resultAssignments}
+    results.push(Value.Object(result));
+  }`;
+      } else {
+        // For FIRST hit policy, use if/else if chain
+        const conditionalExpr =
+          idx === 0 ? `if (${conditions || 'true'})` : `else if (${conditions || 'true'})`;
+        return `${conditionalExpr} {
+    let result = new Map<string, Value>();
+${resultAssignments}
+    return Value.Object(result);
+  }`;
+      }
+    })
+    .join(isCollectAll ? '\n' : '\n');
+
+  // Generate the no-match handler based on the effective behavior
+  function generateNoMatchHandler(): string {
+    const returnNull = 'return Value.Null();';
+
+    // We need to signal to the caller that no rules matched but the table has passThrough enabled,
+    // so it should return accumulated context. We can't directly access the outer context here, so
+    // we return a marker object that the caller detects and handles.
+    const returnPassthroughSignal = `let __pt = new Map<string, Value>();
+    __pt.set("__passthrough", Value.Bool(true));
+    return Value.Object(__pt);`;
+
+    if (noMatchBehavior.type === 'throwError') {
+      return `SetLastErrorWithMessage(RuntimeErrorCode.EVALUATION_ERROR, "Decision table \\"${node.name}\\" (id: ${node.id}): No matching rules found");\n  ${returnNull}`;
+    } else if (noMatchBehavior.type === 'returnDefault') {
+      const defaultValue = noMatchBehavior.value;
+
+      // Generate the default value as a Value based on its JavaScript type
+      let defaultValueCode: string;
+      switch (typeof defaultValue) {
+        case 'string':
+          defaultValueCode = `Value.String("${String(defaultValue).replace(/"/g, '\\"')}")`;
+          break;
+        case 'number':
+          defaultValueCode = `Value.Float(${defaultValue})`;
+          break;
+        case 'boolean':
+          defaultValueCode = `Value.Bool(${defaultValue})`;
+          break;
+        default:
+          defaultValueCode = `Value.String("${String(defaultValue)}")`;
+      }
+
+      // Assign the default value to each output field
+      const defaultAssignments = outputs
+        .map((output) => {
+          return `    result.set("${output.field}", ${defaultValueCode});`;
+        })
+        .join('\n');
+
+      const defaultAssignmentSingle =
+        outputs.length > 0
+          ? `  let result = new Map<string, Value>();\n${defaultAssignments}\n  return Value.Object(result);`
+          : returnNull;
+
+      if (isCollectAll) {
+        // For collect-mode policies, return array with default result
+        return `  let result = new Map<string, Value>();\n${defaultAssignments}\n  return Value.Array([Value.Object(result)]);`;
+      } else {
+        return defaultAssignmentSingle;
+      }
+    } else {
+      // Default: returnNull
+      // But for FIRST hit policy with passThrough, signal to use accumulated context
+      if (passThrough && hitPolicy === 'first') {
+        return returnPassthroughSignal;
+      }
+      return returnNull;
+    }
+  }
+
+  // Generate the final return statement based on hit policy
+  // COLLECT-style policies return arrays directly (not wrapped in object)
+  // The node name keying is handled by codegen.ts when storing in context
+  let finalReturn: string;
+  if (hitPolicy === 'collect' || hitPolicy === 'ruleOrder') {
+    // For collect policies no-match handling
+    if (noMatchBehavior.type === 'throwError') {
+      finalReturn = `
+  if (results.length == 0) {
+${generateNoMatchHandler()}
+  }
+  return Value.Array(results);`;
+    } else if (noMatchBehavior.type === 'returnDefault') {
+      finalReturn = `
+  if (results.length == 0) {
+${generateNoMatchHandler()}
+  }
+  return Value.Array(results);`;
+    } else {
+      finalReturn = `return Value.Array(results);`;
+    }
+  } else if (hitPolicy === 'unique') {
+    finalReturn = `
+  // Validate exactly one match
+  if (results.length == 1) {
+    return results[0];
+  } else if (results.length == 0) {
+    ${generateNoMatchHandler()}
+  } else {
+    // Multiple matches - this violates UNIQUE constraint
+    SetLastErrorWithMessage(RuntimeErrorCode.EVALUATION_ERROR, "Decision table \\"${node.name}\\" (id: ${node.id}): Multiple rules matched but UNIQUE hit policy requires exactly one match");
+    return Value.Null();
+  }`;
+  } else if (hitPolicy === 'outputOrder' || hitPolicy === 'priority') {
+    if (outputs.length === 0) {
+      throw new Error(`${hitPolicy.toUpperCase()} hit policy requires at least one output field`);
+    }
+
+    const primaryOutput = outputs[0];
+    finalReturn = `
+  // Sort by output value (descending priority), with rule order as tie-breaker
+  results.sort((a: Value, b: Value): i32 => {
+    let aOutput = a.asObject().get("${primaryOutput.field}");
+    let bOutput = b.asObject().get("${primaryOutput.field}");
+
+    // Compare the primary output values
+    let cmp = compareValues(aOutput, bOutput);
+
+    // If outputs are equal, maintain rule order (lower index = higher priority)
+    if (cmp == 0) {
+      return 1; // already in rule order, so keep it
+    }
+
+    // Return results in descending order of output priority
+    // Higher output values come first
+    return cmp < 0 ? 1 : -1;
+  });
+
+  if (results.length == 0) {
+${generateNoMatchHandler()}
+  }
+
+  ${
+    hitPolicy === 'priority'
+      ? '// Return only the highest-priority result\n  return results[0];'
+      : 'return Value.Array(results);'
+  }`;
+  } else {
+    // Default case - FIRST hit policy
+    finalReturn = `\n  else {\n    ${generateNoMatchHandler()}\n  }`;
+  }
+
+  const sanitizedId = sanitizeId(node.id);
+
+  // Build the raw function body
+  const rawFunctionBody = `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  ${resultDeclaration}
+
+${ruleBranches}
+${finalReturn}
+}
+`;
+
+  // For large decision tables, hoist repeated string literals to module-level constants
+  // This prevents memory exhaustion from repeated Value.String() allocations
+  if (rules.length > 100) {
+    const { constants, code: optimizedBody } = hoistStringLiterals(rawFunctionBody, node.id);
+    if (constants) {
+      return `// Hoisted string constants for decision table "${node.name}" (${rules.length} rules)
+${constants}
+
+${optimizedBody}`;
+    }
+  }
+
+  return rawFunctionBody;
+}