snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/compose/service/values/expr.go

@@ -0,0 +1,117 @@
+package values
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/expr"
+	"github.com/modern-go/reflect2"
+)
+
+func makeInvalidExprErr(field *types.ModuleField, expr string, err error) types.RecordValueError {
+	return types.RecordValueError{
+		Kind:    "valueExpression",
+		Message: fmt.Sprintf("invalid expression %q: %v", expr, err.Error()),
+		Meta:    map[string]interface{}{"field": field.Name},
+	}
+}
+func makeExprEvalErr(field *types.ModuleField, expr string, err error) types.RecordValueError {
+	return types.RecordValueError{
+		Kind:    "valueExpression",
+		Message: fmt.Sprintf("failed to evaluate formula expression %q: %v", expr, err.Error()),
+		Meta:    map[string]interface{}{"field": field.Name},
+	}
+}
+
+func makeValueExprIncompErr(field *types.ModuleField) types.RecordValueError {
+	return types.RecordValueError{
+		Kind:    "evaluatedValueIncompatible",
+		Message: "evaluated results incompatible",
+		Meta:    map[string]interface{}{"field": field.Name},
+	}
+}
+
+// Expression evaluates expression in ModuleField.Expressions.Value and
+// assigns results to the record on that field
+func Expression(ctx context.Context, m *types.Module, r *types.Record, old *types.Record, rve *types.RecordValueErrorSet) {
+	var (
+		exprParser = expr.Parser()
+
+		scope = make(map[string]interface{})
+
+		reserved = map[string]bool{
+			"new": true,
+			"old": true,
+		}
+	)
+
+	// base scope with field=value(s) from new record
+	scope = r.Values.Dict(m.Fields)
+
+	// new record
+	r.SetModule(m)
+	scope["new"] = r.Dict()
+
+	if old != nil {
+		// old values on record (before update)
+		// this will not be set for new records
+		old.SetModule(m)
+		scope["old"] = old.Dict()
+	}
+
+	for _, f := range m.Fields {
+		if f.Expressions.ValueExpr == "" {
+			continue
+		}
+
+		expr := f.Expressions.ValueExpr
+
+		eval, err := exprParser.NewEvaluable(expr)
+		if err != nil {
+			rve.Push(makeInvalidExprErr(f, expr, err))
+			return
+		}
+
+		tmp, err := eval(ctx, scope)
+		if err != nil {
+			rve.Push(makeExprEvalErr(f, expr, err))
+			return
+		}
+
+		var strings []string
+		// When the expression results in null (nil) delete that record value.
+		// The below Values.Replace already does it so we simply ignore strings
+		if !reflect2.IsNil(tmp) {
+			if values, isSlice := tmp.([]interface{}); isSlice {
+				if !f.Multi {
+					rve.Push(makeValueExprIncompErr(f))
+					continue
+				}
+
+				strings = make([]string, len(values))
+				for i, value := range values {
+					strings[i] = sanitize(f, value)
+				}
+			} else {
+				if f.Multi {
+					rve.Push(makeValueExprIncompErr(f))
+					continue
+				}
+
+				strings = []string{sanitize(f, tmp)}
+			}
+		}
+
+		r.Values = r.Values.Replace(f.Name, strings...)
+
+		if !reserved[f.Name] {
+			// make sure we do not overrider reserved fields
+			scope[f.Name] = tmp
+		}
+
+		// Reset $new with updated data
+		r.SetModule(m)
+		scope["new"] = r.Dict()
+	}
+}