Cue: List constraints (#1060)

Author: spinillos

internal/ast/types.go

@@ -65,6 +65,9 @@ const (
 	GreaterThanEqualOp Op = ">="
 	RegexMatchOp       Op = "=~"
 	NotRegexMatchOp    Op = "!~"
+	MinItemsOp         Op = "minItems"
+	MaxItemsOp         Op = "maxItems"
+	UniqueItemsOp      Op = "uniqueItems"
 )
 
 type TypeConstraint struct {
@@ -732,17 +735,22 @@ func (t DisjunctionType) DeepCopy() DisjunctionType {
 }
 
 type ArrayType struct {
-	ValueType Type `yaml:"value_type"`
+	ValueType   Type             `yaml:"value_type"`
+	Constraints []TypeConstraint `json:",omitempty"`
 }
 
 func (t *ArrayType) AcceptsValue(value any) bool {
 	return t.ValueType.AcceptsValue(value)
 }
 
 func (t ArrayType) DeepCopy() ArrayType {
-	return ArrayType{
+	newT := ArrayType{
 		ValueType: t.ValueType.DeepCopy(),
 	}
+	for _, c := range t.Constraints {
+		newT.Constraints = append(newT.Constraints, c.DeepCopy())
+	}
+	return newT
 }
 
 func (t ArrayType) IsArrayOf(acceptedKinds ...Kind) bool {

internal/jennies/golang/templates/types/struct_validation_method.tmpl

@@ -26,13 +26,41 @@ func (resource {{ .def.Name|formatObjectName }}) Validate() error {
 		{{- if $needsDereference }}
 		if {{ .SelfName }} != nil {
 		{{- end }}
+		{{- range (resolveRefs .Type).Array.Constraints }}
+			{{- if eq .Op "minItems" }}
+			{{- $errors := importStdPkg "errors" }}
+		if len({{ $dereference }}{{ $.SelfName }}) < {{ .Args | first }} {
+			errs = append(errs, cog.MakeBuildErrors("{{ $.ConstraintPath }}", errors.New("must have at least {{ .Args | first }} items"))...)
+		}
+			{{- else if eq .Op "maxItems" }}
+			{{- $errors := importStdPkg "errors" }}
+		if len({{ $dereference }}{{ $.SelfName }}) > {{ .Args | first }} {
+			errs = append(errs, cog.MakeBuildErrors("{{ $.ConstraintPath }}", errors.New("must have at most {{ .Args | first }} items"))...)
+		}
+			{{- else if eq .Op "uniqueItems" }}
+			{{- $errors := importStdPkg "errors" }}
+			{{- $seen := importStdPkg "fmt" }}
+			{{- $seenVar := print "seen" ($.ConstraintPath | toGoIdent) }}
+		{{ $seenVar }} := make(map[string]struct{})
+		for _, item{{ $depth }} := range {{ $dereference }}{{ $.SelfName }} {
+			key{{ $depth }} := fmt.Sprintf("%v", item{{ $depth }})
+			if _, exists{{ $depth }} := {{ $seenVar }}[key{{ $depth }}]; exists{{ $depth }} {
+				errs = append(errs, cog.MakeBuildErrors("{{ $.ConstraintPath }}", errors.New("must have unique items"))...)
+				break
+			}
+			{{ $seenVar }}[key{{ $depth }}] = struct{}{}
+		}
+			{{- end }}
+		{{- end }}
+		{{- if resolvesToConstraints (resolveRefs .Type).Array.ValueType }}
 
 		for i{{ $depth }} := range {{ $dereference }}{{ .SelfName }} {
 			{{- $selfKey := print (ternary (print "(*" .SelfName ")") .SelfName $needsDereference) "[i" $depth "]" }}
 			{{- $constraintPath := print .ConstraintPath "[\"+strconv.Itoa(i" $depth ")+\"]" }}
 			{{- $strconv := importStdPkg "strconv" -}}
 			{{- template "type_validate_check" (dict "ConstraintPath" $constraintPath "Type" (resolveRefs .Type).Array.ValueType "Nullable" (resolveRefs .Type).Array.ValueType.Nullable "Dereference" false "SelfName" $selfKey "Depth" (add1 $depth)) }}
 		}
+		{{- end }}
 		{{- if $needsDereference }}}{{ end }}
 	{{- else if resolvesToMap .Type }}
 		{{- $needsDereference := and .Type.IsRef .Type.Nullable }}
@@ -88,11 +116,11 @@ func (resource {{ .def.Name|formatObjectName }}) Validate() error {
 
 {{- define "type_constraints" }}
 	{{- $dereference := ternary "*" "" .Type.Nullable }}
-	{{- $errors := importStdPkg "errors" -}}
 	{{- range .Constraints }}
 		{{- $leftOperand := print $dereference $.SelfName }}
 		{{- $rightOperand := .Args | first }}
 		{{- $operator := .Op }}
+		{{- $errors := importStdPkg "errors" -}}
 		{{- if eq .Op "minLength" }}
 			{{- $leftOperand = print "len([]rune(" $leftOperand "))" }}
 			{{- $operator = ">=" }}

internal/jennies/golang/tmpl.go

@@ -64,6 +64,9 @@ func initTemplates(config Config, apiRefCollector *common.APIReferenceCollector)
 			"resolvesToConstraints": func(_ ast.Type) string {
 				panic("resolvesToConstraints() needs to be overridden by a jenny")
 			},
+			"toGoIdent": func(_ string) string {
+				panic("toGoIdent() needs to be overridden by a jenny")
+			},
 			"formatValue": func(destinationType ast.Type, value any) string {
 				panic("formatValue() needs to be overridden by a jenny")
 			},

internal/jennies/golang/validation.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"slices"
 	"strings"
+	"unicode"
 
 	"github.com/grafana/cog/internal/ast"
 	"github.com/grafana/cog/internal/jennies/common"
@@ -67,7 +68,7 @@ func (jenny validationMethods) generateForObject(buffer *strings.Builder, contex
 		}
 
 		if typeDef.IsArray() {
-			return resolvesToConstraints(typeDef.AsArray().ValueType)
+			return len(typeDef.AsArray().Constraints) != 0 || resolvesToConstraints(typeDef.AsArray().ValueType)
 		}
 
 		if typeDef.IsConstantRef() {
@@ -94,6 +95,15 @@ func (jenny validationMethods) generateForObject(buffer *strings.Builder, contex
 			"importStdPkg": func(pkg string) string {
 				return imports.Add(pkg, pkg)
 			},
+			"toGoIdent": func(s string) string {
+				var b strings.Builder
+				for _, r := range s {
+					if unicode.IsLetter(r) || unicode.IsDigit(r) {
+						b.WriteRune(r)
+					}
+				}
+				return b.String()
+			},
 		})
 
 	rendered, err := tmpl.Render("types/struct_validation_method.tmpl", map[string]any{

internal/jennies/jsonschema/schema.go

@@ -337,10 +337,24 @@ func (jenny Schema) formatArray(typeDef ast.Type) Definition {
 
 	definition.Set("type", "array")
 	definition.Set("items", jenny.formatType(typeDef.AsArray().ValueType))
+	jenny.addArrayConstraints(definition, typeDef)
 
 	return definition
 }
 
+func (jenny Schema) addArrayConstraints(definition *orderedmap.Map[string, any], typeDef ast.Type) {
+	for _, constraint := range typeDef.AsArray().Constraints {
+		switch constraint.Op {
+		case ast.MinItemsOp:
+			definition.Set("minItems", constraint.Args[0])
+		case ast.MaxItemsOp:
+			definition.Set("maxItems", constraint.Args[0])
+		case ast.UniqueItemsOp:
+			definition.Set("uniqueItems", true)
+		}
+	}
+}
+
 func (jenny Schema) formatMap(typeDef ast.Type) Definition {
 	definition := orderedmap.New[string, any]()
 

internal/jennies/terraform/types.go

@@ -230,6 +230,7 @@ func (formatter *typeFormatter) formatArrayAttributes(def ast.Type) string {
 		formatter.packageMapper("github.com/hashicorp/terraform-plugin-framework/attr")
 		defVal = fmt.Sprintf("Default: listdefault.StaticValue(%s),\n", formatter.parseArrayOrMapDefaults(def.AsArray().ValueType, def.Default, ListDefault))
 	}
+	arrayValidator := formatter.validators.arrayConstraintValidator(def.AsArray().Constraints)
 	validator := formatter.validators.validateList(def.AsArray().ValueType)
 
 	switch def.AsArray().ValueType.Kind {
@@ -264,7 +265,9 @@ func (formatter *typeFormatter) formatArrayAttributes(def ast.Type) string {
 			buffer.WriteString(defVal)
 		}
 
-		if validator != "" {
+		if arrayValidator != "" {
+			buffer.WriteString(fmt.Sprintf("Validators: %s", arrayValidator))
+		} else if validator != "" {
 			buffer.WriteString(fmt.Sprintf("Validators: %s", validator))
 		}
 
@@ -278,6 +281,9 @@ func (formatter *typeFormatter) formatArrayAttributes(def ast.Type) string {
 		if defVal != "" {
 			buffer.WriteString(defVal)
 		}
+		if arrayValidator != "" {
+			buffer.WriteString(fmt.Sprintf("Validators: %s", arrayValidator))
+		}
 	}
 	buffer.WriteString(fmt.Sprintf("},\n"))
 

internal/jennies/terraform/validators.go

@@ -169,6 +169,29 @@ func (v *validators) constraints(validator scalarValidator, constraints []ast.Ty
 	return buffer.String()
 }
 
+func (v *validators) arrayConstraintValidator(constraints []ast.TypeConstraint) string {
+	if len(constraints) == 0 {
+		return ""
+	}
+
+	var buffer strings.Builder
+	v.typeFormatter.packageMapper("github.com/hashicorp/terraform-plugin-framework/schema/validator")
+	v.typeFormatter.packageMapper("github.com/hashicorp/terraform-plugin-framework-validators/listvalidator")
+	buffer.WriteString("[]validator.List{\n")
+	for _, c := range constraints {
+		switch c.Op {
+		case ast.MinItemsOp:
+			buffer.WriteString(fmt.Sprintf("listvalidator.SizeAtLeast(%s),\n", formatScalar(c.Args[0])))
+		case ast.MaxItemsOp:
+			buffer.WriteString(fmt.Sprintf("listvalidator.SizeAtMost(%s),\n", formatScalar(c.Args[0])))
+		case ast.UniqueItemsOp:
+			buffer.WriteString("listvalidator.UniqueValues(),\n")
+		}
+	}
+	buffer.WriteString("},\n")
+	return buffer.String()
+}
+
 func (v *validators) validateList(def ast.Type) string {
 	var buffer strings.Builder
 	switch def.Kind {

internal/simplecue/generator.go

@@ -961,6 +961,53 @@ func extractNumber(e cueast.Expr) (string, bool) {
 	return "", false
 }
 
+func (g *generator) declareListConstraints(v cue.Value) ([]ast.TypeConstraint, error) {
+	conjuncts := appendSplit(nil, cue.AndOp, v)
+
+	if len(conjuncts) == 1 {
+		return nil, nil
+	}
+
+	var constraints []ast.TypeConstraint
+
+	for _, conjunct := range conjuncts {
+		op, args := conjunct.Expr()
+		if op != cue.CallOp {
+			continue
+		}
+
+		switch fmt.Sprint(args[0]) {
+		case "list.MinItems":
+			scalar, err := cueConcreteToScalar(args[1])
+			if err != nil {
+				return nil, err
+			}
+			constraints = append(constraints, ast.TypeConstraint{
+				Op:   ast.MinItemsOp,
+				Args: []any{scalar},
+			})
+
+		case "list.MaxItems":
+			scalar, err := cueConcreteToScalar(args[1])
+			if err != nil {
+				return nil, err
+			}
+			constraints = append(constraints, ast.TypeConstraint{
+				Op:   ast.MaxItemsOp,
+				Args: []any{scalar},
+			})
+
+		case "list.UniqueItems":
+			constraints = append(constraints, ast.TypeConstraint{
+				Op:   ast.UniqueItemsOp,
+				Args: nil,
+			})
+		}
+	}
+
+	return constraints, nil
+}
+
 func (g *generator) declareList(v cue.Value, defVal any, hints ast.JenniesHints) (ast.Type, error) {
 	typeDef := ast.NewArray(ast.Any(), ast.Hints(hints), ast.Default(defVal))
 
@@ -982,6 +1029,12 @@ func (g *generator) declareList(v cue.Value, defVal any, hints ast.JenniesHints)
 		v = dvals[0]
 	}
 
+	constraints, err := g.declareListConstraints(v)
+	if err != nil {
+		return ast.Type{}, err
+	}
+	typeDef.Array.Constraints = constraints
+
 	e := v.LookupPath(cue.MakePath(cue.AnyIndex))
 	if !e.Exists() {
 		// unreachable?

schemas/compiler_passes.json

@@ -7,6 +7,12 @@
       "properties": {
         "value_type": {
           "$ref": "#/$defs/AstType"
+        },
+        "constraints": {
+          "items": {
+            "$ref": "#/$defs/AstTypeConstraint"
+          },
+          "type": "array"
         }
       },
       "additionalProperties": false,

schemas/pipeline.json

@@ -528,6 +528,17 @@
         "package_root": {
           "type": "string",
           "description": "Root path for imports.\nEx: github.com/grafana/cog/generated"
+        },
+        "overrides_templates": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array",
+          "description": "OverridesTemplatesDirectories holds a list of directories containing templates\ndefining blocks used to override parts of builders/types/...."
+        },
+        "skip_post_formatting": {
+          "type": "boolean",
+          "description": "SkipPostFormatting disables formatting of Go files done with go imports\nafter code generation."
         }
       },
       "additionalProperties": false,