@divmain/jdm-asm 0.2.0

package/src/compiler/nodes/switch.ts

@@ -0,0 +1,547 @@
+import type { JDMNode } from '../parser';
+import type { CompilationContext, AssemblyScriptCode, NoMatchBehavior } from '../types';
+import { compileExpression } from './expression';
+import { sanitizeId } from '../utils';
+import { generateNodeEvaluationCode, generateBuildFinalResultCode } from '../code-generators';
+
+/**
+ * Switch statement definition (from JDM format).
+ */
+interface SwitchStatement {
+  id: string;
+  condition: string; // Empty string means default case
+}
+
+/**
+ * Switch node content structure (from JDM format).
+ */
+interface JDMNodeContent {
+  statements: SwitchStatement[];
+  hitPolicy?: 'first' | 'collect' | 'unique' | 'ruleOrder' | 'outputOrder' | 'priority';
+  /** Override the global no-match behavior for this switch */
+  noMatchBehavior?: NoMatchBehavior;
+}
+
+/**
+ * Internal switch condition definition.
+ */
+interface SwitchCondition {
+  id: string;
+  expression: string;
+  nodes: string[];
+  isDefault: boolean;
+}
+
+/**
+ * Get all nodes reachable from a starting node via BFS, stopping at switch nodes.
+ *
+ * Each switch evaluates its own branches independently. If we traversed into nested
+ * switches, we'd incorrectly include nodes that should be conditionally evaluated by
+ * the nested switch, not unconditionally evaluated by the parent branch.
+ */
+function getBranchNodes(startNodeId: string, context: CompilationContext): string[] {
+  const nodeMap = new Map(context.jdm.nodes.map((n) => [n.id, n]));
+  const visited = new Set<string>();
+  const result: string[] = [];
+  const queue = [startNodeId];
+
+  while (queue.length > 0) {
+    const currentId = queue.shift()!;
+    if (visited.has(currentId)) {
+      continue;
+    }
+    visited.add(currentId);
+    result.push(currentId);
+
+    // Get the current node
+    const currentNode = nodeMap.get(currentId);
+
+    // If node not found in context, just include it and stop traversal
+    // (this handles test mocks that don't define all nodes)
+    if (!currentNode) {
+      continue;
+    }
+
+    // If this is a switch node, don't traverse its outgoing edges
+    // The switch will handle its own branches when it's evaluated
+    if (currentNode.type === 'switchNode') {
+      continue;
+    }
+
+    // Find outgoing edges from this node
+    const outgoingEdges = context.jdm.edges.filter((e) => e.sourceId === currentId);
+    for (const edge of outgoingEdges) {
+      queue.push(edge.targetId);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Generate inline code to evaluate an entire branch (all nodes in sequence).
+ * Returns the statements and a final result expression.
+ *
+ * Uses shared node evaluation infrastructure (generateNodeEvaluationCode) to ensure
+ * consistent handling of outputPath and passThrough across the codebase.
+ */
+function generateBranchEvaluation(
+  branchNodeIds: string[],
+  context: CompilationContext,
+): { statements: string; resultExpr: string } {
+  const nodeMap = new Map(context.jdm.nodes.map((n) => [n.id, n]));
+
+  if (branchNodeIds.length === 0) {
+    return { statements: '', resultExpr: 'Value.Null()' };
+  }
+
+  // Generate evaluation code for each node using shared helper
+  const evalStatements = branchNodeIds.map((nodeId) => {
+    const node = nodeMap.get(nodeId);
+    const nodeName = node?.name || sanitizeId(nodeId);
+    return generateNodeEvaluationCode(nodeId, nodeName, node);
+  });
+
+  // Determine result expression based on the last node's type
+  const lastNodeId = branchNodeIds[branchNodeIds.length - 1];
+  const lastNode = nodeMap.get(lastNodeId);
+  const lastNodeName = lastNode?.name || sanitizeId(lastNodeId);
+
+  // For output nodes or nodes with passThrough, build result from accumulated context
+  const shouldUseAccumulatedContext =
+    lastNode?.type === 'outputNode' || lastNode?.content?.passThrough === true;
+
+  if (shouldUseAccumulatedContext) {
+    // Use shared helper to build final result from context
+    evalStatements.push(generateBuildFinalResultCode('__branchFinalResult', '__branch'));
+    return {
+      statements: evalStatements.join('\n    '),
+      resultExpr: 'Value.Object(__branchFinalResult)',
+    };
+  }
+
+  return {
+    statements: evalStatements.join('\n    '),
+    resultExpr: `ctx.get("$nodes.${lastNodeName}")`,
+  };
+}
+
+/**
+ * Compile a switch node.
+ *
+ * Generates conditional chains (switch-like logic) for evaluating multiple
+ * conditions and routing to the appropriate target nodes.
+ *
+ * Supports:
+ * - FIRST hit policy: Returns the first matching condition's result
+ * - COLLECT hit policy: Aggregates all matching conditions' results
+ * - RULE ORDER hit policy: Returns all matching conditions' results in order
+ * - UNIQUE hit policy: Returns result if exactly one condition matches
+ * - OUTPUT ORDER hit policy: Returns all matching conditions' results sorted by value
+ * - PRIORITY hit policy: Returns only the highest-priority matching condition's result
+ *
+ * Default Cases:
+ * - A statement with an empty condition string acts as the default case
+ * - When no conditions match, the default case is evaluated (if provided)
+ * - Default case has access to the full input context
+ * - If no default case is provided, the configured no-match behavior applies
+ *
+ * @param node - The JDM switch node
+ * @param context - The compilation context
+ * @returns Generated AssemblyScript code
+ */
+export function compileSwitchNode(node: JDMNode, context: CompilationContext): AssemblyScriptCode {
+  const jdmContent = node.content as JDMNodeContent;
+  const {
+    statements,
+    hitPolicy: jdmHitPolicy,
+    noMatchBehavior: switchNoMatchBehavior,
+  } = jdmContent;
+
+  const hitPolicy = jdmHitPolicy ?? 'first';
+
+  // Determine the effective no-match behavior (node-level overrides global)
+  const noMatchBehavior = switchNoMatchBehavior ??
+    context.options.noMatchBehavior ?? { type: 'returnNull' };
+
+  // RULE ORDER, COLLECT, OUTPUT ORDER, and PRIORITY all use array collection mode
+  const isCollectMode =
+    hitPolicy === 'collect' ||
+    hitPolicy === 'ruleOrder' ||
+    hitPolicy === 'outputOrder' ||
+    hitPolicy === 'priority';
+
+  const nodeMap = new Map(context.jdm.nodes.map((n) => [n.id, n]));
+
+  // In collect mode, if all branches terminate at output nodes, we can merge their results into
+  // a single object instead of returning an array. This allows collect-mode switches to build
+  // structured outputs progressively, avoiding unnecessary nesting.
+  function checkAllBranchesTerminateAtOutput(): boolean {
+    if (!isCollectMode) {
+      return false;
+    }
+
+    for (const statement of statements) {
+      if (statement.condition === '' || statement.condition.trim() === '') {
+        continue;
+      } // Skip default
+
+      // Find target edge for this statement
+      const edge = context.jdm.edges.find(
+        (e) => e.sourceId === node.id && e.sourceHandle === statement.id,
+      );
+      if (!edge) {
+        continue;
+      }
+
+      // Get the terminal node(s) for this branch
+      const branchNodes = getBranchNodes(edge.targetId, context);
+      if (branchNodes.length === 0) {
+        return false;
+      }
+
+      const lastNodeId = branchNodes[branchNodes.length - 1];
+      const lastNode = nodeMap.get(lastNodeId);
+      if (!lastNode || lastNode.type !== 'outputNode') {
+        return false;
+      }
+    }
+
+    // Also check default case if exists
+    const defaultStatement = statements.find(
+      (s) => s.condition === '' || s.condition.trim() === '',
+    );
+    if (defaultStatement) {
+      const edge = context.jdm.edges.find(
+        (e) => e.sourceId === node.id && e.sourceHandle === defaultStatement.id,
+      );
+      if (edge) {
+        const branchNodes = getBranchNodes(edge.targetId, context);
+        if (branchNodes.length > 0) {
+          const lastNodeId = branchNodes[branchNodes.length - 1];
+          const lastNode = nodeMap.get(lastNodeId);
+          if (!lastNode || lastNode.type !== 'outputNode') {
+            return false;
+          }
+        }
+      }
+    }
+
+    return true;
+  }
+
+  const shouldMergeCollectResults = checkAllBranchesTerminateAtOutput();
+
+  // Transform JDM statements to internal conditions format
+  const conditions: SwitchCondition[] = statements.map((statement) => {
+    // Find target nodes for this statement by looking for edges with this statement as sourceHandle
+    const edges = context.jdm.edges.filter(
+      (edge) => edge.sourceId === node.id && edge.sourceHandle === statement.id,
+    );
+    const targetNodeIds = edges.map((edge) => sanitizeId(edge.targetId));
+
+    return {
+      id: statement.id,
+      expression: statement.condition,
+      nodes: targetNodeIds,
+      // In collect mode, all matching conditions execute (empty = always match).
+      // In first mode, execution stops at first match, so empty condition acts as fallback "default" case.
+      isDefault:
+        !isCollectMode && (statement.condition === '' || statement.condition.trim() === ''),
+    };
+  });
+
+  // Separate regular conditions from default case
+  // In collect mode, there are no defaults - empty conditions are just "always true"
+  const regularConditions = conditions.filter((c) => !c.isDefault);
+  const defaultCase = isCollectMode ? undefined : conditions.find((c) => c.isDefault);
+
+  // Generate the result declaration based on hit policy
+  const resultDeclaration = isCollectMode ? 'let results = new Array<Value>();' : '';
+
+  // Generate the no-match handler based on the effective behavior
+  function generateNoMatchHandler(): string {
+    if (noMatchBehavior.type === 'throwError') {
+      return `SetLastErrorWithMessage(RuntimeErrorCode.EVALUATION_ERROR, "Switch node \\"${node.name}\\" (id: ${node.id}): No matching condition found");\n  return Value.Null();`;
+    } else if (noMatchBehavior.type === 'returnDefault') {
+      // Generate the default value as a Value
+      const defaultValue = noMatchBehavior.value;
+      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)}")`;
+      }
+
+      return isCollectMode
+        ? `return Value.Array([${defaultValueCode}]);`
+        : `return ${defaultValueCode};`;
+    } else {
+      // Default: returnNull
+      return 'return Value.Null();';
+    }
+  }
+
+  // Helper function to generate code that evaluates the default case (entire branch)
+  function generateDefaultCaseEvaluation(): string {
+    if (!defaultCase) {
+      return generateNoMatchHandler();
+    }
+
+    // Get the first node ID for the default case
+    // If no target node is connected to the default case, use no-match behavior
+    if (!defaultCase.nodes || defaultCase.nodes.length === 0) {
+      // Default case exists but has no target - treat as no-match
+      return generateNoMatchHandler();
+    }
+
+    // Get all nodes in this branch (from target to end)
+    const branchStartId = defaultCase.nodes[0]; // Use raw ID, not sanitized
+    // Find the raw ID from the edge
+    const defaultEdge = context.jdm.edges.find(
+      (e) => e.sourceId === node.id && e.sourceHandle === defaultCase.id,
+    );
+    const rawTargetId = defaultEdge?.targetId || branchStartId;
+    const branchNodeIds = getBranchNodes(rawTargetId, context);
+
+    // Generate code to evaluate the entire branch
+    const { statements, resultExpr } = generateBranchEvaluation(branchNodeIds, context);
+
+    if (isCollectMode) {
+      return `    ${statements}\n    results.push(${resultExpr});`;
+    } else {
+      return `    ${statements}\n    return ${resultExpr};`;
+    }
+  }
+
+  // Generate the conditional branches for each condition (excluding default)
+  let conditionBranches: string;
+  let finalReturn: string;
+
+  // Helper to get branch nodes for a condition
+  function getBranchNodesForCondition(condition: SwitchCondition): string[] {
+    if (!condition.nodes || condition.nodes.length === 0) {
+      return [];
+    }
+
+    // Find the edge for this condition to get the raw target ID
+    const edge = context.jdm.edges.find(
+      (e) => e.sourceId === node.id && e.sourceHandle === condition.id,
+    );
+    const rawTargetId = edge?.targetId || condition.nodes[0];
+    return getBranchNodes(rawTargetId, context);
+  }
+
+  // Handle the case where there are no regular conditions but there is a default case
+  if (regularConditions.length === 0) {
+    conditionBranches = '';
+    if (defaultCase && defaultCase.nodes && defaultCase.nodes.length > 0) {
+      // Only default case exists with a target - evaluate the entire branch
+      const branchNodeIds = getBranchNodesForCondition(defaultCase);
+      const { statements, resultExpr } = generateBranchEvaluation(branchNodeIds, context);
+
+      if (isCollectMode) {
+        finalReturn = `
+  ${statements}
+  results.push(${resultExpr});
+  return Value.Array(results);`;
+      } else {
+        finalReturn = `
+  ${statements}
+  return ${resultExpr};`;
+      }
+    } else {
+      // No conditions and no default case (or default with no target) - use no-match behavior
+      finalReturn = `\n  ${generateNoMatchHandler()}`;
+    }
+  } else {
+    // Generate the conditional branches for each condition (excluding default)
+    conditionBranches = regularConditions
+      .map((condition, idx) => {
+        // Parse and compile the condition expression
+        let compiledExpr: string;
+        // Empty condition means "always true" (especially in collect mode)
+        if (condition.expression === '' || condition.expression.trim() === '') {
+          compiledExpr = 'true';
+        } else {
+          try {
+            const ast = context.parseExpression(condition.expression);
+            // Get the conditional value (expects a boolean result)
+            const exprCode = compileExpression(ast, context);
+            compiledExpr = `${exprCode}.asBool()`;
+          } catch {
+            // If parsing fails, provide a comment indicating the issue
+            // Can fail if expression syntax is invalid (checked at compile time)
+            compiledExpr = '/* ERROR: Could not parse expression */ false';
+          }
+        }
+
+        // Get all nodes in this branch (from target to end)
+        const branchNodeIds = getBranchNodesForCondition(condition);
+        const { statements, resultExpr } = generateBranchEvaluation(branchNodeIds, context);
+
+        // Generate the conditional branch
+        if (isCollectMode) {
+          // For collect-mode hit policies, evaluate all conditions independently
+          if (shouldMergeCollectResults) {
+            // When all branches terminate at output nodes, just evaluate (don't collect)
+            // The context accumulates all results which get merged at the end
+            const branchCode = `\n  if (${compiledExpr}) {
+    ${statements}
+  }`;
+            return branchCode;
+          }
+          const branchCode = `\n  if (${compiledExpr}) {
+    ${statements}
+    results.push(${resultExpr});
+  }`;
+          return branchCode;
+        } else {
+          // For FIRST hit policy, use if/else if chain (short-circuit on first match)
+          const prefix = idx === 0 ? '\n  if' : '\n  else if';
+          const branchCode = `${prefix} (${compiledExpr}) {
+    ${statements}
+    return ${resultExpr};
+  }`;
+          return branchCode;
+        }
+      })
+      .join('');
+
+    if (isCollectMode) {
+      // For OUTPUT ORDER and PRIORITY, sort the results by value (descending)
+      if (hitPolicy === 'outputOrder' || hitPolicy === 'priority') {
+        if (
+          defaultCase ||
+          noMatchBehavior.type === 'throwError' ||
+          noMatchBehavior.type === 'returnDefault'
+        ) {
+          finalReturn = `
+  // Sort by value (descending priority), with rule order as tie-breaker
+  // compareValues returns: -1 if a < b, 0 if equal, 1 if a > b
+  // For descending order (higher priority first): return inverted comparison
+  // Tie-breaker: when equal, return 1 to maintain original rule order (stable sort)
+  results.sort((a: Value, b: Value): i32 => {
+    let cmp = compareValues(a, b);
+    if (cmp == 0) {
+      return 1;
+    }
+    return cmp < 0 ? 1 : -1;
+  });
+
+  if (results.length == 0) {
+${generateDefaultCaseEvaluation()}
+  }
+
+  ${hitPolicy === 'priority' ? 'return results[0];' : 'return Value.Array(results);'}`;
+        } else {
+          finalReturn = `
+  // Sort by value (descending priority), with rule order as tie-breaker
+  // compareValues returns: -1 if a < b, 0 if equal, 1 if a > b
+  // For descending order (higher priority first): return inverted comparison
+  // Tie-breaker: when equal, return 1 to maintain original rule order (stable sort)
+  results.sort((a: Value, b: Value): i32 => {
+    let cmp = compareValues(a, b);
+    if (cmp == 0) {
+      return 1;
+    }
+    return cmp < 0 ? 1 : -1;
+  });
+
+  ${
+    hitPolicy === 'priority'
+      ? 'return results.length > 0 ? results[0] : Value.Null();'
+      : 'return Value.Array(results);'
+  }`;
+        }
+      } else {
+        // Collect or rule order without sorting
+        if (shouldMergeCollectResults) {
+          // When merging results, return the accumulated context (excluding input keys)
+          // First check if any branch was evaluated, if not run default
+          if (defaultCase) {
+            finalReturn = `
+  // Build merged result from accumulated context (excluding input keys)
+  // Runtime variables: $=context root, #=current array element, acc=reduce accumulator
+  let __mergedResult = new Map<string, Value>();
+  const __mergedCtxKeys = ctx.data.keys();
+  for (let __mergedI = 0; __mergedI < __mergedCtxKeys.length; __mergedI++) {
+    const __mergedKey = __mergedCtxKeys[__mergedI];
+    // Skip internal entries, special variables, and input keys
+    if (!__mergedKey.startsWith("$") && __mergedKey !== "#" && __mergedKey !== "acc" && !ctx.inputKeys.has(__mergedKey)) {
+      __mergedResult.set(__mergedKey, ctx.data.get(__mergedKey));
+    }
+  }
+  // If no output was produced, run default case
+  if (__mergedResult.size == 0) {
+${generateDefaultCaseEvaluation()}
+    // Rebuild result after default case
+    __mergedResult = new Map<string, Value>();
+    const __afterDefaultKeys = ctx.data.keys();
+    for (let __afterI = 0; __afterI < __afterDefaultKeys.length; __afterI++) {
+      const __afterKey = __afterDefaultKeys[__afterI];
+      if (!__afterKey.startsWith("$") && __afterKey !== "#" && __afterKey !== "acc" && !ctx.inputKeys.has(__afterKey)) {
+        __mergedResult.set(__afterKey, ctx.data.get(__afterKey));
+      }
+    }
+  }
+  return Value.Object(__mergedResult);`;
+          } else {
+            finalReturn = `
+  // Build merged result from accumulated context (excluding input keys)
+  // Runtime variables: $=context root, #=current array element, acc=reduce accumulator
+  let __mergedResult = new Map<string, Value>();
+  const __mergedCtxKeys = ctx.data.keys();
+  for (let __mergedI = 0; __mergedI < __mergedCtxKeys.length; __mergedI++) {
+    const __mergedKey = __mergedCtxKeys[__mergedI];
+    // Skip internal entries, special variables, and input keys
+    if (!__mergedKey.startsWith("$") && __mergedKey !== "#" && __mergedKey !== "acc" && !ctx.inputKeys.has(__mergedKey)) {
+      __mergedResult.set(__mergedKey, ctx.data.get(__mergedKey));
+    }
+  }
+  return Value.Object(__mergedResult);`;
+          }
+        } else if (
+          defaultCase ||
+          noMatchBehavior.type === 'throwError' ||
+          noMatchBehavior.type === 'returnDefault'
+        ) {
+          finalReturn = `
+  if (results.length == 0) {
+${generateDefaultCaseEvaluation()}
+  }
+  return Value.Array(results);`;
+        } else {
+          finalReturn = '\n  return Value.Array(results);';
+        }
+      }
+    } else {
+      // Non-collect mode (FIRST, PRIORITY)
+      if (defaultCase) {
+        // Use else block to evaluate default case
+        // Last branch already has closing brace, so just add else block
+        finalReturn = `\n  else {\n    // Default case - no conditions matched\n${generateDefaultCaseEvaluation()}\n  }`;
+      } else {
+        // Use else block for no-match handling
+        finalReturn = `\n  else {\n    ${generateNoMatchHandler()}\n  }`;
+      }
+    }
+  }
+
+  const sanitizedId = sanitizeId(node.id);
+  return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  ${resultDeclaration}
+
+  ${conditionBranches}${finalReturn}
+}
+`;
+}