@divmain/jdm-asm 0.2.0

package/src/runtime/context.ts

@@ -0,0 +1,189 @@
+// assembly/runtime/context.ts (AssemblyScript)
+import { Value, TYPE_OBJECT } from './values';
+
+/**
+ * Stores cached path resolution metadata to avoid redundant string splitting
+ * and prefix matching on frequently-accessed paths.
+ */
+class PathResolutionCache {
+  // Cache entry: stores the matched prefix key, its length, and the split parts for a given path
+  prefixKey: string;
+  prefixLen: i32;
+  parts: string[];
+
+  constructor(prefixKey: string, prefixLen: i32, parts: string[]) {
+    this.prefixKey = prefixKey;
+    this.prefixLen = prefixLen;
+    this.parts = parts;
+  }
+}
+
+/**
+ * Resolves a potentially dotted path against a data map with caching support.
+ *
+ * Keys like "$nodes.expression2" are stored as literal strings with dots in them,
+ * not as nested objects. This function handles both cases:
+ * 1. Exact key match (e.g., "$nodes.expression2")
+ * 2. Nested path (e.g., "$nodes.expression2.L1" where "$nodes.expression2" is a key
+ *    and "L1" is a property inside the object stored at that key)
+ *
+ * The algorithm finds the longest matching prefix in the data map, then navigates
+ * any remaining path segments through nested object properties.
+ *
+ * Performance: Uses an optional cache to avoid redundant path splitting and prefix
+ * matching for frequently-accessed paths within a single evaluation.
+ */
+export function resolvePathInData(
+  data: Map<string, Value>,
+  path: string,
+  cache: Map<string, PathResolutionCache> | null = null,
+): Value {
+  // Check for exact key match first
+  if (data.has(path)) {
+    return data.get(path);
+  }
+
+  // If no dot, the key doesn't exist
+  if (!path.includes('.')) {
+    return Value.Null();
+  }
+
+  // Check cache if available
+  let matchedPrefixLen: i32 = 0;
+  let prefixKey: string = '';
+  let parts: string[];
+
+  if (cache !== null && cache.has(path)) {
+    // Cache hit - use cached resolution metadata AND cached parts array
+    const cached = cache.get(path);
+    prefixKey = cached.prefixKey;
+    matchedPrefixLen = cached.prefixLen;
+    parts = cached.parts;
+  } else {
+    // Cache miss - perform full path resolution
+    parts = path.split('.');
+
+    // Try progressively longer prefixes to find a matching key
+    // e.g., for "$nodes.expression2.L1", try:
+    //   1. "$nodes" (no match)
+    //   2. "$nodes.expression2" (match! then access .L1 inside)
+    let currentPrefix = '';
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0) currentPrefix += '.';
+      currentPrefix += parts[i];
+      if (data.has(currentPrefix)) {
+        matchedPrefixLen = i + 1;
+        prefixKey = currentPrefix;
+      }
+    }
+
+    // Store in cache if available (including the parts array to avoid future splits)
+    if (cache !== null) {
+      cache.set(path, new PathResolutionCache(prefixKey, matchedPrefixLen, parts));
+    }
+  }
+
+  // If no prefix matched, path doesn't exist
+  if (matchedPrefixLen == 0) {
+    return Value.Null();
+  }
+
+  // Get the value at the matched prefix
+  let current = data.get(prefixKey);
+
+  // Navigate remaining parts as object properties
+  for (let i = matchedPrefixLen; i < parts.length; i++) {
+    if (!current.isObject()) return Value.Null();
+    const obj = current.asObject();
+    const key = parts[i];
+    if (!obj.has(key)) return Value.Null();
+    current = obj.get(key);
+  }
+  return current;
+}
+
+export class Context {
+  data: Map<string, Value>;
+  // Cache for decision node results to avoid redundant evaluation. Caching prevents
+  // exponential evaluation time for DAG structures where multiple nodes reference
+  // the same upstream computation.
+  decisionResults: Map<string, Value>;
+  // Stack to track currently evaluating decisions for recursion detection
+  decisionStack: string[];
+  // When merging results, we need to know which keys are original inputs (should be
+  // preserved) vs computed outputs (may be overwritten). This prevents input shadowing.
+  inputKeys: Set<string>;
+  // Cache for path resolution to avoid redundant string splitting and prefix matching.
+  // For decisions with many field accesses (e.g., 100-rule decision table with 5 inputs
+  // per rule = 500 path lookups), this eliminates most splitting overhead.
+  pathCache: Map<string, PathResolutionCache>;
+
+  constructor(input: Map<string, Value>) {
+    this.data = input;
+    this.decisionResults = new Map<string, Value>();
+    this.decisionStack = new Array<string>();
+    this.pathCache = new Map<string, PathResolutionCache>();
+    // Store original input keys
+    this.inputKeys = new Set<string>();
+    const keys = input.keys();
+    for (let i = 0; i < keys.length; i++) {
+      this.inputKeys.add(keys[i]);
+    }
+  }
+
+  // Unlike JS Map which returns undefined for missing keys, AS Map.get() throws.
+  // We must check has() first or handle dots carefully to avoid runtime errors.
+  get(path: string): Value {
+    return resolvePathInData(this.data, path, this.pathCache);
+  }
+
+  set(path: string, value: Value): void {
+    this.data.set(path, value);
+  }
+
+  // Merge another result into this context (for passthrough mode)
+  merge(other: Map<string, Value>): void {
+    const keys = other.keys();
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      this.data.set(key, other.get(key));
+    }
+  }
+
+  // Convert the context data to a Value (for passthrough sub-decisions)
+  toValue(): Value {
+    return Value.Object(this.data);
+  }
+}
+
+/**
+ * ScopedContext is a lightweight context wrapper for scoped expression evaluation.
+ * Scoped evaluation (loops, sub-object navigation) needs simple Map-based get/set
+ * without decision caching/recursion tracking. Separate class avoids polluting
+ * Context with unnecessary state and provides clearer semantics.
+ *
+ * Used for:
+ * - inputField scoping (expressions evaluated within a sub-object scope)
+ * - executionMode: "loop" (expressions evaluated for each array item)
+ *
+ * Performance: Includes path caching for loop-mode expressions where the same paths
+ * are accessed repeatedly across array items.
+ */
+export class ScopedContext {
+  data: Map<string, Value>;
+  // Path resolution cache for frequently-accessed paths in loops
+  pathCache: Map<string, PathResolutionCache>;
+
+  constructor(data: Map<string, Value>) {
+    this.data = data;
+    this.pathCache = new Map<string, PathResolutionCache>();
+  }
+
+  get(path: string): Value {
+    return resolvePathInData(this.data, path, this.pathCache);
+  }
+
+  set(path: string, value: Value): void {
+    this.data.set(path, value);
+  }
+}