@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/nodes/switch.ts

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