Function validateExpressionContent

pkg/workflow/expression_syntax_validation.go:116–165

validateExpressionContent validates the content inside ${{ }}

(expr string, fullGroup string)

// validateExpressionContent validates the content inside ${{ }}
func validateExpressionContent(expr string, fullGroup string) error {
	// Check for unbalanced parentheses
	parenCount := 0
	for i, ch := range expr {
		switch ch {
		case '(':
			parenCount++
		case ')':
			parenCount--
			if parenCount < 0 {
				return NewValidationError(
					"expression",
					"unbalanced parentheses in expression",
					fmt.Sprintf("found closing ')' without matching opening '(' at position %d in expression: %s", i, expr),
					"Ensure all parentheses are properly balanced in your expression.",
				)
			}
		}
	}

	if parenCount > 0 {
		return NewValidationError(
			"expression",
			"unclosed parentheses in expression",
			fmt.Sprintf("found %d unclosed opening '(' in expression: %s", parenCount, expr),
			"Add the missing closing ')' to balance parentheses in your expression.",
		)
	}

	// Check for unbalanced quotes (single, double, backtick)
	if err := validateBalancedQuotes(expr); err != nil {
		return err
	}

	// Try to parse complex expressions with logical operators
	if containsLogicalOperators(expr) {
		expressionValidationLog.Print("Expression contains logical operators, performing deep validation")
		if _, err := ParseExpression(expr); err != nil {
			expressionValidationLog.Printf("Expression parsing failed: %v", err)
			return NewValidationError(
				"expression",
				"invalid expression syntax",
				"failed to parse expression: "+err.Error(),
				"Fix the syntax error in your expression. Full expression: "+fullGroup,
			)
		}
	}

	return nil
}

// validateBalancedQuotes checks for balanced quotes in an expression
func validateBalancedQuotes(expr string) error {