@divmain/jdm-asm 0.2.0

package/src/compiler/nodes/decision.ts

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