@divmain/jdm-asm 0.2.0 → 0.2.3

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

@@ -1,507 +0,0 @@
-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;
-}