Function parseExpression

ts/workflow-core/src/expression/parser.ts:22–95

(expr: ResolvedExpr)

 * infers types from the AST, and validates against the expected type.
 */
export function parseExpression(expr: ResolvedExpr): ParseResult {
  // Handle early returns
  if (!expr.expression.trim()) {
    return { isValid: false, inferredType: null, errors: ["Expression is empty"] };
  }
  if (expr.variables.some((v) => v === null)) {
    return { isValid: false, inferredType: null, errors: ["Expression contains stale variable references"] };
  }

  const errors: string[] = [];

  // 1. Build type context from variables
  const typeContext: TypeContext = new Map();

  // Replace ${} placeholders with temp identifiers for jsep
  let parsableExpr = expr.expression;

  // Count placeholders in expression
  const placeholderCount = (expr.expression.match(/\$\{\}/g) || []).length;

  if (placeholderCount !== expr.variables.length) {
    errors.push(`Placeholder count (${placeholderCount}) doesn't match reference count (${expr.variables.length})`);
    return { isValid: false, inferredType: null, errors };
  }

  expr.variables.forEach((variable, i) => {
    const placeholder = `__var${i}__`;
    parsableExpr = parsableExpr.replace("${}", placeholder);

    if (variable) {
      typeContext.set(placeholder, variable.dataType);
    } else {
      // Stale reference - variable was deleted
      errors.push(`Referenced variable at position ${i + 1} not found`);
    }
  });

  // If we have stale/null variables, don't proceed with parsing
  if (errors.length > 0) {
    return { isValid: false, inferredType: null, errors };
  }

  // 2. For string-type expressions, auto-wrap bare text as string literals
  //    so users don't need to type quotes. E.g. `hello __var0__` → `"hello " + __var0__`
  if (expr.expectedType === "string") {
    parsableExpr = wrapStringTemplate(parsableExpr);
  }

  // 3. Parse with jsep
  let ast: jsep.Expression;
  try {
    ast = jsep(parsableExpr);
  } catch (e) {
    const message = e instanceof Error ? e.message : String(e);
    return { isValid: false, inferredType: null, errors: [`Parse error: ${message}`] };
  }

  // 4. Infer type by walking AST