@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/nodes/expression.ts

@@ -1,425 +0,0 @@
-// ============================================================================
-// 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);
-}
-`;
-}