Function dfs

frontend/src/plugins/cel/logic/resolve.ts:80–133

(expr: CELExpr, negative: boolean = false)

// Convert common expr to simple expr
export const resolveCELExpr = (expr: CELExpr): SimpleExpr => {
  const dfs = (expr: CELExpr, negative: boolean = false): SimpleExpr => {
    if (expr.exprKind?.case !== "callExpr") {
      // If no callExpr, we treat it as a raw string.
      return resolveRawStringExpr(expr);
    }
    const callExpr = expr.exprKind.value;

    try {
      const { args } = callExpr;
      const operator = callExpr.function as Operator;
      if (isLogicalOperator(operator)) {
        const group: ConditionGroupExpr = {
          type: ExprType.ConditionGroup,
          operator,
          args: [],
        };
        const [left, right] = args;
        const sub = (subTree: CELExpr, expand: boolean) => {
          const subExpr = dfs(subTree);
          if (
            expand &&
            isConditionGroupExpr(subExpr) &&
            subExpr.operator === operator
          ) {
            group.args.push(...subExpr.args);
          } else {
            group.args.push(subExpr);
          }
        };
        sub(left, true);
        sub(right, false);
        return group;
      }
      if (isNegativeOperator(operator)) {
        return dfs(args[0], true);
      }
      if (isEqualityOperator(operator)) {
        return resolveEqualityExpr(expr);
      }
      if (isCompareOperator(operator)) {
        return resolveCompareExpr(expr);
      }
      if (isStringOperator(operator)) {
        return resolveStringExpr(expr, negative);
      }
      if (isCollectionOperator(operator)) {
        return resolveCollectionExpr(expr, negative);
      }
      throw new Error(`unsupported expr "${JSON.stringify(expr)}"`);
    } catch {
      // Any error occurs, we treat it as a raw string.
      return resolveRawStringExpr(expr);
    }
  };
  return dfs(expr);
};