@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/nodes/decision.ts

@@ -1,292 +0,0 @@
-import type { JDMNode, JDMDecision } from '../parser';
-import type { CompilationContext, AssemblyScriptCode } from '../types';
-import { sanitizeId } from '../utils';
-import { compileDecisionTableNode } from './decision-table';
-import { compileSwitchNode } from './switch';
-import { compileInputNode } from './input';
-import { compileExpressionNode } from './expression';
-import { compileFunctionNode } from './function';
-import { buildGraph, getEvaluationOrder } from '../graph';
-
-/**
- * Generate a unique prefix for sub-decision node IDs to avoid naming conflicts.
- */
-function decisionNodePrefix(nodeId: string): string {
-  return `sub_${sanitizeId(nodeId)}_`;
-}
-
-/**
- * Generate the sub-decision entry point function that contains the actual evaluation logic.
- */
-function generateSubDecisionEntryPoint(
-  node: JDMNode,
-  context: CompilationContext,
-  subDecision: JDMDecision,
-  prefix: string,
-): AssemblyScriptCode {
-  const sanitizedId = sanitizeId(node.id);
-
-  // Build the sub-decision graph and get evaluation order
-  const graph = buildGraph(subDecision);
-  // Catches circular sub-decision references at compile time for better error messages and
-  // fail-fast behavior, rather than discovering cycles at runtime with stack overflow.
-  const evaluationOrder = getEvaluationOrder(graph);
-
-  // Create a node lookup for quick access
-  const nodeMap = new Map(subDecision.nodes.map((n) => [n.id, n]));
-
-  // Generate evaluation code for each node in topological order
-  // Skip output nodes - they mark graph termination but don't perform computation
-  // Skip input nodes (input just passes context through)
-  const evaluationCode = evaluationOrder
-    .map((nodeId) => {
-      const subNode = nodeMap.get(nodeId);
-      if (!subNode || subNode.type === 'outputNode' || subNode.type === 'inputNode') {
-        return '';
-      }
-      const prefixedId = prefix + sanitizeId(nodeId);
-      // Store node result in context under $nodes.<nodeName>
-      return `  ctx.set("$nodes.${subNode.name}", evaluateNode_${prefixedId}(ctx));`;
-    })
-    .filter(Boolean)
-    .join('\n');
-
-  // Find the last non-input, non-output node that was evaluated to return its result
-  const evaluatedNodes = evaluationOrder.filter((id) => {
-    const subNode = nodeMap.get(id);
-    if (!subNode) {
-      return false;
-    }
-    return subNode.type !== 'inputNode' && subNode.type !== 'outputNode';
-  });
-
-  // Determine what to return:
-  // - If there are evaluated nodes, return the last one's result
-  // - Otherwise, return an empty object for passthrough graphs
-  let resultCode: string;
-  if (evaluatedNodes.length > 0) {
-    const lastNodeId = evaluatedNodes[evaluatedNodes.length - 1];
-    const lastNode = nodeMap.get(lastNodeId)!;
-    resultCode = `  let result = ctx.get("$nodes.${lastNode.name}");`;
-  } else {
-    // For passthrough graphs (input->output with no intermediate nodes),
-    // return an empty object to indicate "no transformation"
-    //
-    // Can't return ctx.toValue: Returning ctx as-is would create circular reference when the
-    // result is merged back into parent context. Empty object signals "pass through unchanged".
-    resultCode = `  let result = Value.Object(new Map<string, Value>());`;
-  }
-
-  return `
-// Sub-decision entry point function for ${node.id}
-export function evaluateSubDecision_${sanitizedId}(ctx: Context): Value {
-  // Evaluate the sub-decision graph
-${evaluationCode}
-
-  // Get the final result
-${resultCode}
-
-  return result;
-}
-`;
-}
-
-/**
- * Generate a wrapper function that handles caching, recursion detection, and delegates to the sub-decision entry point.
- */
-function generateDecisionNodeWrapper(
-  node: JDMNode,
-  subDecisionFunctionName: string,
-): AssemblyScriptCode {
-  const sanitizedId = sanitizeId(node.id);
-  const cacheKey = `"evaluateNode_${sanitizedId}"`;
-
-  return `
-// Wrapper function to evaluate sub-decision ${node.id}
-export function evaluateNode_${sanitizedId}(ctx: Context): Value {
-  // Check cache first to avoid redundant evaluation
-  if (ctx.decisionResults.has(${cacheKey})) {
-    return ctx.decisionResults.get(${cacheKey});
-  }
-
-  // Compile-time detection catches static cycles, but runtime detection is needed for dynamic
-  // sub-decision loading or conditional recursion based on input data.
-  if (ctx.decisionStack.includes("${sanitizedId}")) {
-    const recursionPath = ctx.decisionStack.join(' -> ') + ' -> ' + "${sanitizedId}";
-    SetLastError(RuntimeErrorCode.EVALUATION_ERROR);
-    return Value.Null();
-  }
-
-  // Add to decision stack before evaluation
-  ctx.decisionStack.push("${sanitizedId}");
-
-  // Evaluate the sub-decision
-  let result = ${subDecisionFunctionName}(ctx);
-
-  // Check for errors from sub-decision evaluation
-  if (hasError()) {
-    // Error occurred in sub-decision - propagate it up
-    // Remove from decision stack
-    const stackIndex = ctx.decisionStack.indexOf("${sanitizedId}");
-    if (stackIndex >= 0) {
-      ctx.decisionStack.splice(stackIndex, 1);
-    }
-    return Value.Null();
-  }
-
-  // Store result in cache
-  ctx.decisionResults.set(${cacheKey}, result);
-
-  // Remove from decision stack after evaluation
-  const stackIndex = ctx.decisionStack.indexOf("${sanitizedId}");
-  if (stackIndex >= 0) {
-    ctx.decisionStack.splice(stackIndex, 1);
-  }
-
-  return result;
-}
-`;
-}
-
-/**
- * Compile a sub-decision node.
- *
- * Sub-decision nodes allow a decision to call another decision as part of its
- * evaluation. This function generates code that:
- * 1. Loads the referenced sub-decision JDM
- * 2. Recursively compiles all nodes in the sub-decision
- * 3. Creates a wrapper function to invoke the sub-decision
- * 4. Returns the code for both the wrapper and the sub-decision logic
- *
- * @param node - The JDM sub-decision node
- * @param context - The compilation context
- * @returns Generated AssemblyScript code for the sub-decision
- */
-export function compileDecisionNode(
-  node: JDMNode,
-  context: CompilationContext,
-): AssemblyScriptCode {
-  // Check for cycles in the decision graph
-  if (context.decisionPath.includes(node.id)) {
-    throw new Error(
-      `Circular dependency detected in decision graph: ${context.decisionPath.join(' -> ')} -> ${node.id}`,
-    );
-  }
-
-  // Extract the sub-decision reference key from the decision node content
-  const subDecisionKey = node.content?.key;
-  if (!subDecisionKey) {
-    throw new Error(
-      `Decision node ${node.id} has no content.key - cannot determine which decision to call`,
-    );
-  }
-
-  // Check if this sub-decision JDM has already been loaded (caching the parsed JDM)
-  // We don't cache the generated code because each reference needs its own function names
-  // But we can cache the parsed JDM to avoid re-parsing
-  let subDecision: JDMDecision;
-
-  // Add to decision path for cycle detection
-  context.decisionPath.push(node.id);
-
-  try {
-    // Load the sub-decision JDM using the loader
-    subDecision = context.loadDecision(subDecisionKey);
-
-    // Find the input and output nodes in the sub-decision
-    const inputNode = subDecision.nodes.find((n) => n.type === 'inputNode');
-    const outputNodes = subDecision.nodes.filter((n) => n.type === 'outputNode');
-
-    if (!inputNode) {
-      throw new Error(`Sub-decision ${subDecisionKey} has no input node`);
-    }
-
-    if (outputNodes.length === 0) {
-      throw new Error(`Sub-decision ${subDecisionKey} has no output nodes`);
-    }
-
-    // Check if this sub-decision has already been compiled (for caching)
-    const cachedFunctionName = context.compiledSubDecisions.get(subDecisionKey);
-    if (cachedFunctionName) {
-      // Sub-decision was already compiled, just generate a wrapper that calls the cached entry point
-      const wrapperCode = generateDecisionNodeWrapper(node, cachedFunctionName);
-      return wrapperCode;
-    }
-
-    // Add unique prefix to sub-decision node IDs to avoid conflicts
-    const prefix = decisionNodePrefix(node.id);
-    const sanitizedId = sanitizeId(node.id);
-    const subDecisionFunctionName = `evaluateSubDecision_${sanitizedId}`;
-
-    // Cache the entry point function name for reuse
-    context.compiledSubDecisions.set(subDecisionKey, subDecisionFunctionName);
-
-    // Create a modified context for recursive compilation. Sub-decisions need isolated compilation
-    // state (separate decision path, separate compiled cache) to avoid conflicts with parent decision
-    // while sharing global settings.
-    const subContext: CompilationContext = {
-      ...context,
-      decisionPath: [...context.decisionPath],
-    };
-
-    // Compile each node in the sub-decision
-    let subCompiled = '';
-    for (const subNode of subDecision.nodes) {
-      const nodeType = subNode.type;
-
-      // Skip output nodes - they're just markers
-      if (nodeType === 'outputNode') {
-        continue;
-      }
-
-      // Create a prefixed version of the node to avoid ID conflicts
-      const prefixedNode = {
-        ...subNode,
-        id: prefix + subNode.id,
-      };
-
-      // Compile the node based on its type
-      switch (nodeType) {
-        case 'inputNode':
-          subCompiled += compileInputNode(prefixedNode, context);
-          break;
-        case 'decisionTableNode':
-          subCompiled += compileDecisionTableNode(prefixedNode, context);
-          break;
-        case 'switchNode':
-          subCompiled += compileSwitchNode(prefixedNode, context);
-          break;
-        case 'expressionNode':
-          subCompiled += compileExpressionNode(prefixedNode, context);
-          break;
-        case 'functionNode':
-          subCompiled += compileFunctionNode(prefixedNode, context);
-          break;
-        case 'decisionNode':
-          // Recursive sub-decision
-          subCompiled += compileDecisionNode(prefixedNode, subContext);
-          break;
-        default:
-          // Output nodes don't need compilation
-          break;
-      }
-    }
-
-    // Generate the sub-decision entry point function
-    const entryPointCode = generateSubDecisionEntryPoint(node, context, subDecision, prefix);
-
-    // Generate the wrapper function that handles caching, recursion detection, and delegates
-    const wrapperCode = generateDecisionNodeWrapper(node, subDecisionFunctionName);
-
-    const completeCode = wrapperCode + entryPointCode + subCompiled;
-
-    // Return the complete code (wrapper + entry point + sub-decision node functions)
-    return completeCode;
-  } finally {
-    // Remove from decision path (backtracking)
-    const pathIndex = context.decisionPath.indexOf(node.id);
-    if (pathIndex !== -1) {
-      context.decisionPath.splice(pathIndex, 1);
-    }
-  }
-}