Add support in YAML decoders for module field expr

pkg/envoy/yaml/compose_module.go

@@ -2,7 +2,6 @@ package yaml
 
 import (
 	"fmt"
-
 	"github.com/cortezaproject/corteza-server/compose/types"
 	"github.com/cortezaproject/corteza-server/pkg/envoy"
 	"github.com/cortezaproject/corteza-server/pkg/envoy/resource"
@@ -37,6 +36,16 @@ type (
 		rbac rbacRuleSet
 	}
 	composeModuleFieldSet []*composeModuleField
+
+	// aux struct to help us with decoding of module field
+	composeModuleFieldAux struct {
+		*types.ModuleField
+
+		Expressions *composeModuleFieldExprAux
+	}
+
+	// aux struct for decoding module field expressions
+	composeModuleFieldExprAux types.ModuleFieldExpr
 )
 
 func (wset *composeModuleSet) UnmarshalYAML(n *yaml.Node) error {
@@ -267,10 +276,20 @@ func (wrap *composeModuleField) UnmarshalYAML(n *yaml.Node) (err error) {
 		wrap.res = &types.ModuleField{}
 	}
 
-	if err = n.Decode(&wrap.res); err != nil {
+	// cast existing field expressions struct to aux struct
+	exprAux := composeModuleFieldExprAux(wrap.res.Expressions)
+
+	// construct field aux struct from resource and aux expr struct
+	// this way yaml pkg can help us with field unmarshalling but
+	// we catch expressions and do our own magic
+	aux := &composeModuleFieldAux{ModuleField: wrap.res, Expressions: &exprAux}
+	if err = n.Decode(aux); err != nil {
 		return
 	}
 
+	// cast unmarshalled expressions back to original type
+	wrap.res.Expressions = types.ModuleFieldExpr(exprAux)
+
 	if wrap.rbac, err = decodeRbac(n); err != nil {
 		return
 	}
@@ -299,3 +318,50 @@ func (wrap *composeModuleField) UnmarshalYAML(n *yaml.Node) (err error) {
 		return nil
 	})
 }
+
+func (aux *composeModuleFieldExprAux) UnmarshalYAML(n *yaml.Node) (err error) {
+	return eachMap(n, func(k *yaml.Node, v *yaml.Node) error {
+		switch k.Value {
+		case "valueExpr", "value":
+			aux.ValueExpr = v.Value
+			return nil
+		case "sanitizer":
+			aux.Sanitizers = []string{v.Value}
+			return nil
+		case "sanitizers":
+			return eachSeq(v, func(san *yaml.Node) error {
+				aux.Sanitizers = append(aux.Sanitizers, san.Value)
+				return nil
+			})
+		case "validator", "validators":
+			return each(v, func(k *yaml.Node, v *yaml.Node) error {
+				vld := &types.ModuleFieldValidator{}
+				if isKind(v, yaml.MappingNode) {
+					if err := v.Decode(vld); err != nil {
+						return err
+					}
+				} else {
+					vld.Test = k.Value
+					vld.Error = v.Value
+				}
+
+				aux.Validators = append(aux.Validators, *vld)
+				return nil
+			})
+		case "disableDefaultValidators":
+			return v.Decode(&aux.DisableDefaultValidators)
+		case "formatter":
+			aux.Formatters = []string{v.Value}
+			return nil
+		case "formatters":
+			return eachSeq(v, func(fmt *yaml.Node) error {
+				aux.Formatters = append(aux.Formatters, fmt.Value)
+				return nil
+			})
+		case "disableDefaultFormatters":
+			return v.Decode(&aux.DisableDefaultFormatters)
+		}
+
+		return nil
+	})
+}

pkg/envoy/yaml/compose_module_test.go

@@ -59,12 +59,41 @@ func TestComposeModule_UnmarshalYAML(t *testing.T) {
 		req.NotNil(doc.compose)
 		req.Len(doc.compose.Modules, 3)
 		req.Equal(30, len(doc.compose.Modules[0].res.Fields))
+		req.NotNil(doc.compose.Modules[0].res.Fields.FindByName("AccountSource"))
 		req.Equal(21, len(doc.compose.Modules[1].res.Fields))
+		req.NotNil(doc.compose.Modules[1].res.Fields.FindByName("NumberOfConvertedLeads"))
 		req.Equal(23, len(doc.compose.Modules[2].res.Fields))
 		req.NotNil(doc.compose.Modules[0].rbac)
 		req.NotEmpty(doc.compose.Modules[0].rbac)
 	})
 
+	t.Run("doc 2", func(t *testing.T) {
+		req := require.New(t)
+
+		doc, err := parseDocument("compose_module_2")
+		req.NoError(err)
+		req.NotNil(doc)
+		req.NotNil(doc.compose)
+		req.Len(doc.compose.Modules, 1)
+		req.Len(doc.compose.Modules[0].res.Fields, 2)
+
+		full := doc.compose.Modules[0].res.Fields.FindByName("full")
+		vaKV := doc.compose.Modules[0].res.Fields.FindByName("validatorKV")
+
+		req.Equal("a > b", full.Expressions.ValueExpr)
+		req.Len(full.Expressions.Sanitizers, 1)
+		req.Contains(full.Expressions.Sanitizers, "trim(value)")
+		req.Len(full.Expressions.Validators, 1)
+		req.Equal(`a == ""`, full.Expressions.Validators[0].Test)
+		req.Equal("Value should not be empty", full.Expressions.Validators[0].Error)
+		req.True(full.Expressions.DisableDefaultValidators)
+
+		req.Len(vaKV.Expressions.Validators, 1)
+		req.Equal(`value == ""`, vaKV.Expressions.Validators[0].Test)
+		req.Equal("Value should be filled", vaKV.Expressions.Validators[0].Error)
+
+	})
+
 	t.Run("doc rbac", func(t *testing.T) {
 		req := require.New(t)
 

pkg/envoy/yaml/testdata/compose_module_2.yaml

+namespace: crm
+modules:
+  Account:
+    name: Expressions
+    fields:
+      full:
+        expressions:
+          valueExpr: "a > b"
+          sanitizers: [ "trim(value)" ]
+          validators:
+            - test: 'a == ""'
+              error: Value should not be empty
+          disableDefaultValidators: true
+      validatorKV:
+        expressions:
+          validators:
+            'value == ""': Value should be filled