[codegen] Support non-string selectable fields of types (#825)

Support non-string selectable fields of types `int` (including `int32`
and `int64`), `bool`, and `time.Time`. Field type determination is a bit
messy for now.

Previously, codegen created non-compiling go code for the
`_schema_gen.go` file for a kind if a selectable field type was not a
string. This behavior is supported in CRDs, so should also be supported
in the API server code created in `_schema_gen.go` for the field. This
PR adds a slightly-guesstimating-way of determining the type of each
field in the selectable field list, and then formatting that type to a
string in the resultant go code.

Resolves #809

---------

Co-authored-by: Costa Alexoglou <konsalexee@gmail.com>

Author: IfSentient

codegen/jennies/schema.go

@@ -77,8 +77,8 @@ func (s *SchemaGenerator) Generate(kind codegen.Kind) (codejen.Files, error) {
 	return files, nil
 }
 
-func (*SchemaGenerator) getSelectableFields(ver *codegen.KindVersion) ([]templates.SchemaMetadataSeletableField, error) {
-	fields := make([]templates.SchemaMetadataSeletableField, 0)
+func (*SchemaGenerator) getSelectableFields(ver *codegen.KindVersion) ([]templates.SchemaMetadataSelectableField, error) {
+	fields := make([]templates.SchemaMetadataSelectableField, 0)
 	if len(ver.SelectableFields) == 0 {
 		return fields, nil
 	}
@@ -101,14 +101,24 @@ func (*SchemaGenerator) getSelectableFields(ver *codegen.KindVersion) ([]templat
 		if val := ver.Schema.LookupPath(cue.MakePath(path...).Optional()); val.Err() == nil {
 			// Simplest way to check if it's an optional field is to try to look it up as non-optional, then try optional
 			if lookup := val.LookupPath(cue.MakePath(cue.Str(field))); lookup.Exists() {
-				fields = append(fields, templates.SchemaMetadataSeletableField{
+				typ, err := getCUEValueKindString(val, cue.MakePath(cue.Str(field)))
+				if err != nil {
+					return nil, fmt.Errorf("invalid selectable field '%s': %w", s, err)
+				}
+				fields = append(fields, templates.SchemaMetadataSelectableField{
 					Field:    s,
 					Optional: false,
+					Type:     typ,
 				})
 			} else if optional := val.LookupPath(cue.MakePath(cue.Str(field).Optional())); optional.Exists() {
-				fields = append(fields, templates.SchemaMetadataSeletableField{
+				typ, err := getCUEValueKindString(val, cue.MakePath(cue.Str(field).Optional()))
+				if err != nil {
+					return nil, fmt.Errorf("invalid selectable field '%s': %w", s, err)
+				}
+				fields = append(fields, templates.SchemaMetadataSelectableField{
 					Field:    s,
 					Optional: true,
+					Type:     typ,
 				})
 			} else {
 				return nil, fmt.Errorf("invalid selectable field path: %s", fieldPath)
@@ -117,3 +127,19 @@ func (*SchemaGenerator) getSelectableFields(ver *codegen.KindVersion) ([]templat
 	}
 	return fields, nil
 }
+
+func getCUEValueKindString(v cue.Value, path cue.Path) (string, error) {
+	// This is a kind of messy way of guessing type without having to actually parse the AST
+	roughType := CUEValueToString(v.LookupPath(path))
+	switch {
+	case strings.Contains(roughType, "time.Time"):
+		return "time", nil
+	case strings.Contains(roughType, "string"):
+		return "string", nil
+	case strings.Contains(roughType, "bool"):
+		return "bool", nil
+	case strings.Contains(roughType, "int"):
+		return "int", nil
+	}
+	return "", fmt.Errorf("unsupported type %s, supported types are string, bool, int and time.Time", v.Kind())
+}

codegen/templates/schema.tmpl

@@ -22,9 +22,13 @@ var (
                 }{{ if .Optional }}
                 if cast.{{$root.ToObjectPath .Field}} == nil {
                     return "", nil
-                }
-                return *cast.{{$root.ToObjectPath .Field}}, nil{{ else }}
-                return cast.{{$root.ToObjectPath .Field}}, nil{{ end }}
+                }{{ if eq .Type "string" }}
+                return *cast.{{$root.ToObjectPath .Field}}, nil{{ else if eq .Type "int" }}
+                return fmt.Sprintf("%d", *cast.{{$root.ToObjectPath .Field}}), nil{{ else }}
+                return fmt.Sprintf("%v", *cast.{{$root.ToObjectPath .Field}}), nil{{ end }}{{ else }}{{ if eq .Type "string" }}
+                return cast.{{$root.ToObjectPath .Field}}, nil{{ else if eq .Type "int" }}
+                return fmt.Sprintf("%d", cast.{{$root.ToObjectPath .Field}}), nil{{ else }}
+                return fmt.Sprintf("%v", cast.{{$root.ToObjectPath .Field}}), nil{{ end }}{{ end }}
             },
         },
         {{ end }} }){{ end }})

codegen/templates/templates.go

@@ -122,13 +122,14 @@ type SchemaMetadata struct {
 	Kind             string
 	Plural           string
 	Scope            string
-	SelectableFields []SchemaMetadataSeletableField
+	SelectableFields []SchemaMetadataSelectableField
 	FuncPrefix       string
 }
 
-type SchemaMetadataSeletableField struct {
+type SchemaMetadataSelectableField struct {
 	Field    string
 	Optional bool
+	Type     string
 }
 
 func (SchemaMetadata) ToObjectPath(s string) string {