refactor(pipeline): refactor the condition evaluation (#952)

Because

- The original implementation for pipeline condition evaluation is not
robust. It converts the condition string into Go code and evaluates it
using the AST. However, in our syntax, we typically use dot notation in
recipes, while Go maps require bracket notation, especially when
component or variable names are not valid Go identifiers.

This commit

- Refactors the condition evaluation.

pkg/data/array.go

@@ -92,3 +92,14 @@ func (a Array) String() string {
 	}
 	return fmt.Sprintf("[%s]", strings.Join(segments, ", "))
 }
+
+func (a Array) ToJSONValue() (v any, err error) {
+	jsonArr := make([]any, len(a))
+	for i, v := range a {
+		jsonArr[i], err = v.ToJSONValue()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return jsonArr, nil
+}

pkg/data/boolean.go

@@ -55,3 +55,7 @@ func (b *booleanData) Equal(other format.Value) bool {
 func (b *booleanData) Hash() string {
 	return fmt.Sprintf("%t", b.Raw)
 }
+
+func (b *booleanData) ToJSONValue() (v any, err error) {
+	return b.Raw, nil
+}

pkg/data/bytearray.go

@@ -50,3 +50,8 @@ func (b *byteArrayData) Equal(other format.Value) bool {
 	}
 	return false
 }
+
+func (b *byteArrayData) ToJSONValue() (v any, err error) {
+	base64str := base64.StdEncoding.EncodeToString(b.Raw)
+	return base64str, nil
+}

pkg/data/file.go

@@ -180,3 +180,11 @@ func (f *fileData) Equal(other format.Value) bool {
 	}
 	return false
 }
+
+func (f *fileData) ToJSONValue() (v any, err error) {
+	base64str, err := f.Base64()
+	if err != nil {
+		return nil, err
+	}
+	return base64str.String(), nil
+}

pkg/data/format/value.go

@@ -9,6 +9,7 @@ import (
 type Value interface {
 	IsValue()
 	ToStructValue() (v *structpb.Value, err error)
+	ToJSONValue() (v any, err error)
 	Get(p *path.Path) (v Value, err error)
 	Equal(other Value) bool
 	String() string

pkg/data/map.go

@@ -81,3 +81,15 @@ func (m Map) String() string {
 	}
 	return fmt.Sprintf("{%s}", strings.Join(segments, ", "))
 }
+
+func (m Map) ToJSONValue() (v any, err error) {
+
+	jsonMap := make(map[string]any)
+	for k, v := range m {
+		jsonMap[k], err = v.ToJSONValue()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return jsonMap, nil
+}

pkg/data/null.go

@@ -43,3 +43,7 @@ func (n *nullData) Equal(other format.Value) bool {
 func (n *nullData) String() string {
 	return "null"
 }
+
+func (n *nullData) ToJSONValue() (v any, err error) {
+	return nil, nil
+}

pkg/data/number.go

@@ -74,3 +74,7 @@ func (n *numberData) Equal(other format.Value) bool {
 	}
 	return false
 }
+
+func (n *numberData) ToJSONValue() (v any, err error) {
+	return n.Float64(), nil
+}

pkg/data/string.go

@@ -45,3 +45,7 @@ func (s *stringData) Equal(other format.Value) bool {
 	}
 	return false
 }
+
+func (s *stringData) ToJSONValue() (v any, err error) {
+	return s.Raw, nil
+}

pkg/recipe/dag.go

@@ -4,14 +4,9 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"reflect"
 	"slices"
-	"strconv"
 	"strings"
 
-	"go/ast"
-	"go/token"
-
 	"google.golang.org/protobuf/types/known/structpb"
 
 	"github.com/instill-ai/pipeline-backend/pkg/constant"
@@ -238,285 +233,6 @@ func Render(ctx context.Context, template format.Value, batchIdx int, wfm memory
 	}
 }
 
-func EvalCondition(expr ast.Expr, value map[string]any) (any, error) {
-	switch e := (expr).(type) {
-	case *ast.UnaryExpr:
-		xRes, err := EvalCondition(e.X, value)
-		if err != nil {
-			return nil, err
-		}
-
-		switch e.Op {
-		case token.NOT: // !
-			switch xVal := xRes.(type) {
-			case bool:
-				return !xVal, nil
-			}
-		case token.SUB: // -
-			switch xVal := xRes.(type) {
-			case int64:
-				return -xVal, nil
-			case float64:
-				return -xVal, nil
-			}
-		}
-	case *ast.BinaryExpr:
-
-		xRes, err := EvalCondition(e.X, value)
-		if err != nil {
-			return nil, err
-		}
-		yRes, err := EvalCondition(e.Y, value)
-		if err != nil {
-			return nil, err
-		}
-
-		switch e.Op {
-		case token.LAND: // &&
-
-			xBool := false
-			yBool := false
-			switch xVal := xRes.(type) {
-			case int64, float64:
-				xBool = (xVal != 0)
-			case string:
-				xBool = (xVal != "")
-			case bool:
-				xBool = xVal
-			}
-			switch yVal := yRes.(type) {
-			case int64, float64:
-				yBool = (yVal != 0)
-			case string:
-				yBool = (yVal != "")
-			case bool:
-				yBool = yVal
-			}
-			return xBool && yBool, nil
-		case token.LOR: // ||
-
-			xBool := false
-			yBool := false
-			switch xVal := xRes.(type) {
-			case int64, float64:
-				xBool = (xVal != 0)
-			case string:
-				xBool = (xVal != "")
-			case bool:
-				xBool = xVal
-			}
-			switch yVal := yRes.(type) {
-			case int64, float64:
-				yBool = (yVal != 0)
-			case string:
-				yBool = (yVal != "")
-			case bool:
-				yBool = yVal
-			}
-			return xBool || yBool, nil
-
-		case token.EQL: // ==
-			switch xVal := xRes.(type) {
-			case int64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal == yVal, nil
-				case float64:
-					return float64(xVal) == yVal, nil
-				}
-			case float64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal == float64(yVal), nil
-				case float64:
-					return xVal == yVal, nil
-				}
-			}
-			return reflect.DeepEqual(xRes, yRes), nil
-		case token.NEQ: // !=
-			switch xVal := xRes.(type) {
-			case int64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal != yVal, nil
-				case float64:
-					return float64(xVal) != yVal, nil
-				}
-			case float64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal != float64(yVal), nil
-				case float64:
-					return xVal != yVal, nil
-				}
-			}
-			return !reflect.DeepEqual(xRes, yRes), nil
-
-		case token.LSS: // <
-			switch xVal := xRes.(type) {
-			case int64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal < yVal, nil
-				case float64:
-					return float64(xVal) < yVal, nil
-				}
-			case float64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal < float64(yVal), nil
-				case float64:
-					return xVal < yVal, nil
-				}
-			}
-		case token.GTR: // >
-			switch xVal := xRes.(type) {
-			case int64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal > yVal, nil
-				case float64:
-					return float64(xVal) > yVal, nil
-				}
-			case float64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal > float64(yVal), nil
-				case float64:
-					return xVal > yVal, nil
-				}
-			}
-
-		case token.LEQ: // <=
-			switch xVal := xRes.(type) {
-			case int64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal <= yVal, nil
-				case float64:
-					return float64(xVal) <= yVal, nil
-				}
-			case float64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal <= float64(yVal), nil
-				case float64:
-					return xVal <= yVal, nil
-				}
-			}
-		case token.GEQ: // >=
-			switch xVal := xRes.(type) {
-			case int64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal >= yVal, nil
-				case float64:
-					return float64(xVal) >= yVal, nil
-				}
-			case float64:
-				switch yVal := yRes.(type) {
-				case int64:
-					return xVal >= float64(yVal), nil
-				case float64:
-					return xVal >= yVal, nil
-				}
-			}
-		}
-
-	case *ast.ParenExpr:
-		return EvalCondition(e.X, value)
-	case *ast.SelectorExpr:
-		v, err := EvalCondition(e.X, value)
-		if err != nil {
-			return nil, err
-		}
-		// Convert InputsMemory and ComponentItemMemory into map[string]any.
-		// Ignore error handling here since all of them are JSON data.
-		b, _ := json.Marshal(v)
-		m := map[string]any{}
-		_ = json.Unmarshal(b, &m)
-		return m[e.Sel.String()], nil
-	case *ast.BasicLit:
-		if e.Kind == token.INT {
-			return strconv.ParseInt(e.Value, 10, 64)
-		}
-		if e.Kind == token.FLOAT {
-			return strconv.ParseFloat(e.Value, 64)
-		}
-		if e.Kind == token.STRING {
-			return e.Value[1 : len(e.Value)-1], nil
-		}
-		return e.Value, nil
-	case *ast.Ident:
-		if e.Name == "true" {
-			return true, nil
-		}
-		if e.Name == "false" {
-			return false, nil
-		}
-
-		return value[e.Name], nil
-
-	case *ast.IndexExpr:
-		v, err := EvalCondition(e.X, value)
-		if err != nil {
-			return nil, err
-		}
-		switch idxVal := e.Index.(type) {
-		case *ast.BasicLit:
-			// handle arr[index]
-			if idxVal.Kind == token.INT {
-				index, err := strconv.Atoi(idxVal.Value)
-				if err != nil {
-					return nil, err
-				}
-				return v.([]any)[index], nil
-			}
-			// handle obj[key]
-			if idxVal.Kind == token.STRING {
-				// key: remove ""
-				key := idxVal.Value[1 : len(idxVal.Value)-1]
-				return v.(map[string]any)[key], nil
-			}
-		}
-
-	}
-	return false, fmt.Errorf("condition error")
-}
-
-func SanitizeCondition(cond string) (string, map[string]string, map[string]string) {
-	varMapping := map[string]string{}
-	revVarMapping := map[string]string{}
-	varNameIdx := 0
-	for {
-		leftIdx := strings.Index(cond, "${")
-		if leftIdx == -1 {
-			break
-		}
-		rightIdx := strings.Index(cond, "}")
-
-		left := cond[:leftIdx]
-		v := cond[leftIdx+2 : rightIdx]
-		right := cond[rightIdx+1:]
-
-		srcName := strings.Split(strings.TrimSpace(v), ".")[0]
-		if varName, ok := revVarMapping[srcName]; ok {
-			varMapping[varName] = srcName
-			revVarMapping[srcName] = varName
-			cond = left + strings.ReplaceAll(v, srcName, varName) + right
-		} else {
-			varName := fmt.Sprintf("var%d", varNameIdx)
-			varMapping[varName] = srcName
-			revVarMapping[srcName] = varName
-			varNameIdx++
-			cond = left + strings.ReplaceAll(v, srcName, varName) + right
-		}
-
-	}
-
-	return cond, varMapping, revVarMapping
-}
-
 func GenerateDAG(componentMap datamodel.ComponentMap) (*dag, error) {
 
 	componentIDMap := make(map[string]bool)