@divmain/jdm-asm 0.2.0

package/src/compiler/nodes/expression.ts

@@ -0,0 +1,425 @@
+// ============================================================================
+// Expression Node Compilation
+// ============================================================================
+//
+// This module provides compilation functionality for JDM expression nodes.
+// Expression nodes contain key-value pairs where values are expression strings.
+//
+// For the core expression AST compilation, see expression-compiler.ts.
+// For context resolution strategies, see context-resolvers.ts.
+
+import type { CompilationContext, AssemblyScriptCode } from '../types';
+import type { JDMNode } from '../parser';
+import { sanitizeId } from '../utils';
+import { LocalDollarContextResolver, ScopedContextResolver } from './context-resolvers';
+import { compileExpressionUnified } from './expression-compiler';
+
+// Re-export commonly used items for backwards compatibility
+export type { ContextResolver } from './context-resolvers';
+export {
+  StandardContextResolver,
+  LocalDollarContextResolver,
+  ScopedContextResolver,
+} from './context-resolvers';
+
+export {
+  compileExpressionUnified,
+  compileBinaryOpWithValues,
+  compileExpression,
+  escapeString,
+  buildDollarPath,
+  checkIsNodesReference,
+  buildNodesPath,
+} from './expression-compiler';
+
+/**
+ * Compile an expression node.
+ *
+ * Expression nodes can contain one or more key-value pairs where
+ * each value is an expression string that needs to be compiled.
+ *
+ * In expression nodes, the $ symbol refers to the local result object
+ * being built, allowing later expressions to reference earlier ones.
+ * For example: { "a": "5", "b": "$.a + 10" } - $.a references the 'a' computed above.
+ *
+ * Additional features:
+ * - inputField: Specifies a sub-object path to use as the evaluation scope
+ * - outputPath: Specifies the context path where the results will be stored
+ * - executionMode: "loop" - Iterates over an array at inputField path
+ *
+ * @param node - The JDM expression node
+ * @param context - The compilation context
+ * @returns Generated AssemblyScript code
+ */
+export function compileExpressionNode(
+  node: JDMNode,
+  context: CompilationContext,
+): AssemblyScriptCode {
+  const expressions = node.content.expressions as Array<{ key: string; value: string }>;
+  const passThrough = node.content.passThrough === true;
+  const inputField = node.content.inputField as string | undefined;
+  const outputPath = node.content.outputPath as string | undefined;
+  const executionMode = node.content.executionMode as string | undefined;
+  const sanitizedId = sanitizeId(node.id);
+
+  // Loop mode: iterates over array at inputField, evaluating expressions for each element
+  // Used when executionMode === "loop" to transform array items in place
+  if (executionMode === 'loop') {
+    return compileLoopExpressionNode(
+      node,
+      context,
+      expressions,
+      passThrough,
+      inputField,
+      outputPath,
+      sanitizedId,
+    );
+  }
+
+  // If inputField is specified, generate scoped evaluation code
+  if (inputField) {
+    return compileScopedExpressionNode(
+      node,
+      context,
+      expressions,
+      passThrough,
+      inputField,
+      outputPath,
+      sanitizedId,
+    );
+  }
+
+  // Standard mode: evaluates expressions in global context without inputField scoping
+  // Used when no inputField is specified - expressions resolve variables from root context
+  const resolver = new LocalDollarContextResolver('result');
+  const expressionAssignments = expressions
+    .map((expr) => {
+      try {
+        const ast = context.parseExpression(expr.value);
+        // Compile with $ resolved to local result variable using unified compiler
+        const compiled = compileExpressionUnified(ast, context, resolver);
+        return `  result.set("${expr.key}", ${compiled});`;
+      } catch (e) {
+        throw new Error(`Failed to compile expression "${expr.value}" for key "${expr.key}": ${e}`);
+      }
+    })
+    .join('\n');
+
+  if (passThrough) {
+    return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  let result = new Map<string, Value>();
+
+  // Copy all context values to preserve workflow state and allow referencing prior node results
+  // passThrough=true ensures downstream nodes can access both input data and intermediate results
+  const keys = ctx.data.keys();
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = ctx.data.get(key);
+    result.set(key, value);
+  }
+
+${expressionAssignments}
+
+  return Value.Object(result);
+}
+`;
+  }
+
+  return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  let result = new Map<string, Value>();
+  
+${expressionAssignments}
+  
+  return Value.Object(result);
+}
+`;
+}
+
+/**
+ * Compile an expression node with inputField scoping.
+ *
+ * When inputField is specified (e.g., "customer"), expressions are evaluated
+ * with the sub-object as the scope. So `firstName` resolves to `customer.firstName`.
+ *
+ * @param node - The JDM expression node
+ * @param context - The compilation context
+ * @param expressions - Array of key-value expression pairs
+ * @param passThrough - Whether to pass through context values
+ * @param inputField - The path to the input field (e.g., "customer")
+ * @param outputPath - The path to store the output (e.g., "customer")
+ * @param sanitizedId - Sanitized node ID
+ * @returns Generated AssemblyScript code
+ */
+function compileScopedExpressionNode(
+  node: JDMNode,
+  context: CompilationContext,
+  expressions: Array<{ key: string; value: string }>,
+  passThrough: boolean,
+  inputField: string,
+  outputPath: string | undefined,
+  sanitizedId: string,
+): AssemblyScriptCode {
+  // Generate unique helper to avoid name collisions in multi-node compilation
+  const helperId = context.getUniqueId('scopedExpr');
+
+  // Scoped evaluation: creates a temporary context where inputField object properties become top-level identifiers
+  // Enables expressions like "firstName" to resolve to "customer.firstName" when inputField="customer"
+  const resolver = new ScopedContextResolver('scopedCtx', 'itemResult');
+  const expressionAssignments = expressions
+    .map((expr) => {
+      try {
+        const ast = context.parseExpression(expr.value);
+        // Use unified compiler with scoped context resolver
+        const compiled = compileExpressionUnified(ast, context, resolver);
+        return `    itemResult.set("${expr.key}", ${compiled});`;
+      } catch (e) {
+        throw new Error(`Failed to compile expression "${expr.value}" for key "${expr.key}": ${e}`);
+      }
+    })
+    .join('\n');
+
+  // Generate the helper function for scoped evaluation
+  // Can't use Context constructor directly - AssemblyScript Context requires specific initialization
+  // that's tied to the WASM module's memory management, so we use ScopedContext wrapper instead
+  const helperCode = `
+function scopedExprHelper_${helperId}(ctx: Context, inputObj: Value): Value {
+  // Build result starting with input object fields (for passThrough behavior)
+  const itemResult = new Map<string, Value>();
+  if (inputObj.isObject()) {
+    const inputMap = inputObj.asObject();
+    const inputKeys = inputMap.keys();
+    for (let i = 0; i < inputKeys.length; i++) {
+      const key = inputKeys[i];
+      itemResult.set(key, inputMap.get(key));
+    }
+  }
+  
+  // Two-layer context enables variable shadowing: inputField properties take precedence over parent context
+  // Allows "status" in inputField to shadow global "status" while preserving access to non-shadowed globals
+  const scopedData = new Map<string, Value>();
+  
+  // Copy parent context data first
+  const parentKeys = ctx.data.keys();
+  for (let i = 0; i < parentKeys.length; i++) {
+    const key = parentKeys[i];
+    scopedData.set(key, ctx.data.get(key));
+  }
+  
+  // Override with fields from the input object (inputField scope)
+  if (inputObj.isObject()) {
+    const inputMap = inputObj.asObject();
+    const inputKeys = inputMap.keys();
+    for (let i = 0; i < inputKeys.length; i++) {
+      const key = inputKeys[i];
+      scopedData.set(key, inputMap.get(key));
+    }
+  }
+  
+  // Create a scoped context wrapper for expression evaluation
+  const scopedCtx = new ScopedContext(scopedData);
+  
+  // Evaluate expressions in the scoped context
+${expressionAssignments}
+  
+  return Value.Object(itemResult);
+}`;
+
+  context.helperFunctions.set(`scopedExprHelper_${helperId}`, helperCode);
+
+  // Generate the main function that extracts inputField and calls the helper
+  if (passThrough) {
+    return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  let result = new Map<string, Value>();
+
+  // Pass through all context values (input + intermediate results)
+  const keys = ctx.data.keys();
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = ctx.data.get(key);
+    result.set(key, value);
+  }
+
+  // Get input object from inputField path: ${inputField}
+  const inputObj = ctx.get("${inputField}");
+  
+  // Evaluate expressions in scoped context and store at outputPath: ${outputPath || inputField}
+  const scopedResult = scopedExprHelper_${helperId}(ctx, inputObj);
+  result.set("${outputPath || inputField}", scopedResult);
+
+  return Value.Object(result);
+}
+`;
+  }
+
+  return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  let result = new Map<string, Value>();
+
+  // Get input object from inputField path: ${inputField}
+  const inputObj = ctx.get("${inputField}");
+  
+  // Evaluate expressions in scoped context and store at outputPath: ${outputPath || inputField}
+  const scopedResult = scopedExprHelper_${helperId}(ctx, inputObj);
+  result.set("${outputPath || inputField}", scopedResult);
+
+  return Value.Object(result);
+}
+`;
+}
+
+/**
+ * Compile an expression node with executionMode: "loop".
+ *
+ * When executionMode is "loop", expressions are evaluated for each item
+ * in the array at inputField path. Each item gets the computed fields added.
+ *
+ * @param node - The JDM expression node
+ * @param context - The compilation context
+ * @param expressions - Array of key-value expression pairs
+ * @param passThrough - Whether to pass through context values
+ * @param inputField - The path to the input array (e.g., "cart.items")
+ * @param outputPath - The path to store the output array (e.g., "cart.items")
+ * @param sanitizedId - Sanitized node ID
+ * @returns Generated AssemblyScript code
+ */
+function compileLoopExpressionNode(
+  node: JDMNode,
+  context: CompilationContext,
+  expressions: Array<{ key: string; value: string }>,
+  passThrough: boolean,
+  inputField: string | undefined,
+  outputPath: string | undefined,
+  sanitizedId: string,
+): AssemblyScriptCode {
+  if (!inputField) {
+    throw new Error(`executionMode: "loop" requires inputField to be specified`);
+  }
+
+  // Generate a unique helper function for loop evaluation
+  const helperId = context.getUniqueId('loopExpr');
+
+  // Each iteration gets its own scoped context to isolate variables and prevent data leakage between iterations
+  // Ensures expressions like "price * quantity" use current item's values, not previous iteration's
+  const resolver = new ScopedContextResolver('itemCtx', 'itemResult');
+  const expressionAssignments = expressions
+    .map((expr) => {
+      try {
+        const ast = context.parseExpression(expr.value);
+        // Use unified compiler with scoped context resolver for array item
+        const compiled = compileExpressionUnified(ast, context, resolver);
+        return `      itemResult.set("${expr.key}", ${compiled});`;
+      } catch (e) {
+        throw new Error(`Failed to compile expression "${expr.value}" for key "${expr.key}": ${e}`);
+      }
+    })
+    .join('\n');
+
+  // Generate the helper function for loop evaluation
+  const helperCode = `
+function loopExprHelper_${helperId}(ctx: Context, inputArr: Value): Value {
+  if (!inputArr.isArray()) {
+    return Value.Array(new Array<Value>(0));
+  }
+  
+  const items = inputArr.asArray();
+  const resultItems = new Array<Value>(0);
+  
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    
+    // Build result item starting with existing fields
+    const itemResult = new Map<string, Value>();
+    if (item.isObject()) {
+      const itemMap = item.asObject();
+      const itemKeys = itemMap.keys();
+      for (let j = 0; j < itemKeys.length; j++) {
+        const key = itemKeys[j];
+        itemResult.set(key, itemMap.get(key));
+      }
+    }
+    
+    // Create a scoped data map that combines parent context with item fields
+    const scopedData = new Map<string, Value>();
+    
+    // Copy parent context data first
+    const parentKeys = ctx.data.keys();
+    for (let j = 0; j < parentKeys.length; j++) {
+      const key = parentKeys[j];
+      scopedData.set(key, ctx.data.get(key));
+    }
+    
+    // Override with fields from the current item
+    if (item.isObject()) {
+      const itemMap = item.asObject();
+      const itemKeys = itemMap.keys();
+      for (let j = 0; j < itemKeys.length; j++) {
+        const key = itemKeys[j];
+        scopedData.set(key, itemMap.get(key));
+      }
+    }
+    
+    // Create a scoped context for expression evaluation
+    const itemCtx = new ScopedContext(scopedData);
+    
+    // Evaluate expressions for this item
+${expressionAssignments}
+    
+    resultItems.push(Value.Object(itemResult));
+  }
+  
+  return Value.Array(resultItems);
+}`;
+
+  context.helperFunctions.set(`loopExprHelper_${helperId}`, helperCode);
+
+  // Determine output path - use outputPath if specified, otherwise inputField
+  const effectiveOutputPath = outputPath || inputField;
+
+  // Generate the main function that extracts inputField array and calls the helper
+  if (passThrough) {
+    return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  let result = new Map<string, Value>();
+
+  // Pass through all context values (input + intermediate results)
+  const keys = ctx.data.keys();
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = ctx.data.get(key);
+    result.set(key, value);
+  }
+
+  // Get input array from inputField path: ${inputField}
+  const inputArr = ctx.get("${inputField}");
+  
+  // Evaluate expressions for each item in the array
+  const loopResult = loopExprHelper_${helperId}(ctx, inputArr);
+  
+  // Store result at outputPath: ${effectiveOutputPath}
+  result.set("${effectiveOutputPath}", loopResult);
+
+  return Value.Object(result);
+}
+`;
+  }
+
+  return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  let result = new Map<string, Value>();
+
+  // Get input array from inputField path: ${inputField}
+  const inputArr = ctx.get("${inputField}");
+  
+  // Evaluate expressions for each item in the array
+  const loopResult = loopExprHelper_${helperId}(ctx, inputArr);
+  
+  // Store result at outputPath: ${effectiveOutputPath}
+  result.set("${effectiveOutputPath}", loopResult);
+
+  return Value.Object(result);
+}
+`;
+}