feat: support custom type recursive reference

Author: Alessio.Diamanti

cmd/controller/__debug_bin4030145734

@@ -0,0 +1,59 @@
+# kro recursive custom type reference example
+
+This example creates a ResourceGraphDefinition called `CompanyConfig` with three custom types referencing mong each other
+
+### Create ResourceGraphDefinition called CompanyConfig
+
+Apply the RGD to your cluster:
+
+```
+kubectl apply -f rg.yaml
+```
+
+Validate the RGD status is Active:
+
+```
+kubectl get rgd company.kro.run
+```
+
+Expected result:
+
+```
+NAME              APIVERSION   KIND            STATE    AGE
+company.kro.run   v1alpha1     CompanyConfig   Active   XXX
+```
+
+### Create an Instance of kind App
+
+Apply the provided instance.yaml
+
+```
+kubectl apply -f instance.yaml
+```
+
+Validate instance status:
+
+```
+kubectl get companyconfigs my-company-config
+```
+
+Expected result:
+
+```
+NAME                STATE    SYNCED   AGE
+my-company-config   ACTIVE   True     XXX
+```
+
+### Clean up
+
+Remove the instance:
+
+```
+kubectl delete companyconfigs my-company-config
+```
+
+Remove the resourcegraphdefinition:
+
+```
+kubectl delete rgd company.kro.run
+```

examples/kubernetes/recursive-custom-types/Readme.md

@@ -0,0 +1,51 @@
+---
+apiVersion: kro.run/v1alpha1
+kind: CompanyConfig
+metadata:
+  name: my-company-config
+spec:
+  name: my-company-cm
+  namespace: default
+  roles:
+    - name: CEO
+      seniority: Senior
+    - name: CFO
+      seniority: Senior
+    - name: Engineer
+      seniority: Senior
+    - name: Intern
+      seniority: Junior
+    - name: Marketer
+      seniority: Mid
+    - name: Social Media Manager
+      seniority: Mid
+  management:
+    - name: Mario
+      role:
+        name: CEO
+        seniority: Senior
+    - name: Luigi
+      role:
+        name: CFO
+        seniority: Senior
+  divisions:
+    - name: Engineering
+      employees:
+        - name: Peach
+          role:
+            name: Engineer
+            seniority: Senior
+        - name: Toad
+          role:
+            name: Intern
+            seniority: Junior
+    - name: Marketing
+      employees:
+        - name: Yoshi
+          role:
+            name: Marketer
+            seniority: Mid
+        - name: Donkey Kong
+          role:
+            name: Social Media Manager
+            seniority: Mid

examples/kubernetes/recursive-custom-types/instance.yaml

@@ -0,0 +1,42 @@
+---
+apiVersion: kro.run/v1alpha1
+kind: ResourceGraphDefinition
+metadata:
+  name: company.kro.run
+spec:
+  schema:
+    types:
+      Person:
+        name: string
+        role: "Role"
+      Division:
+        name: string
+        employees: "[]Person"
+      Role:
+        name: string
+        seniority: string
+    spec:
+      name: string
+      namespace: string | default=default
+      management: "[]Person"
+      divisions: "[]Division"
+      roles: "[]Role"
+    apiVersion: v1alpha1
+    kind: CompanyConfig
+  resources:
+    - id: configmap
+      template:
+        apiVersion: v1
+        kind: ConfigMap
+        metadata:
+          name: ${schema.spec.name}
+          namespace: ${schema.spec.namespace}
+          labels:
+            app.kubernetes.io/name: ${schema.spec.name}
+        data:
+          management: |
+            ${schema.spec.management.map(e, e.name + " (" + e.role.name + ")").join(", ")}
+          divisions: |
+            ${schema.spec.divisions.map(d, d.name + ": " + d.employees.map(e, e.name).join(", ")).join("\n")}
+          roles: |
+            ${schema.spec.roles.map(r, r.name + " (" + r.seniority + ")").join(", ")}

examples/kubernetes/recursive-custom-types/rg.yaml

@@ -21,6 +21,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/kubernetes-sigs/kro/pkg/graph/dag"
 	extv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/utils/ptr"
 )
@@ -57,27 +58,130 @@ func newTransformer() *transformer {
 
 // loadPreDefinedTypes loads pre-defined types into the transformer.
 // The pre-defined types are used to resolve references in the schema.
-//
+// Types are loaded one by one so that each type can reference one of the
+// other custom types.
+// Cyclic dependencies are detected and reported as errors.
 // As of today, kro doesn't support custom types in the schema - do
 // not use this function.
 func (t *transformer) loadPreDefinedTypes(obj map[string]interface{}) error {
+
+	//Constructs a dag of the dependencies between the types
+	//If there is a cycle in the graph, then there is a cyclic dependency between the types
+	//and we cannot load the types
+	dagInstance := dag.NewDirectedAcyclicGraph[string]()
 	t.preDefinedTypes = make(map[string]predefinedType)
 
-	jsonSchemaProps, err := t.buildOpenAPISchema(obj)
+	for k := range obj {
+		if err := dagInstance.AddVertex(k, 0); err != nil {
+			return err
+		}
+	}
+
+	// Build dependencies and construct the schema
+	for k, v := range obj {
+		dependencies := extractDependenciesFromMap(v)
+
+		// Add dependencies to the DAG and check for cycles
+		err := dagInstance.AddDependencies(k, dependencies)
+		if err != nil {
+			if cycleErr, isCycle := err.(*dag.CycleError[string]); isCycle {
+				return fmt.Errorf("failed to load type %s due to cyclic dependency. Please remove the cyclic dependency: %w", k, cycleErr)
+			}
+			return err
+		}
+	}
+
+	// Perform a topological sort of the DAG to get the order of the types
+	// to be processed
+	orderedVertexes, err := dagInstance.TopologicalSort()
 	if err != nil {
-		return fmt.Errorf("failed to build pre-defined types schema: %w", err)
+		return fmt.Errorf("failed to sort DAG: %w", err)
 	}
 
-	for k, properties := range jsonSchemaProps.Properties {
-		required := false
-		if slices.Contains(jsonSchemaProps.Required, k) {
-			required = true
+	// Build the pre-defined types from the sorted DAG
+	for _, vertex := range orderedVertexes {
+		objValueAtKey, ok := obj[vertex]
+		if !ok {
+			return fmt.Errorf("failed to assert type for vertex %s", vertex)
+		}
+		objMap := map[string]interface{}{
+			vertex: objValueAtKey,
+		}
+		if schemaProps, err := t.buildOpenAPISchema(objMap); err == nil {
+			for propKey, properties := range schemaProps.Properties {
+				required := false
+				if slices.Contains(schemaProps.Required, propKey) {
+					required = true
+				}
+				t.preDefinedTypes[propKey] = predefinedType{Schema: properties, Required: required}
+			}
+		} else {
+			return fmt.Errorf("failed to build schema props for %s: %w", vertex, err)
 		}
-		t.preDefinedTypes[k] = predefinedType{Schema: properties, Required: required}
 	}
+
 	return nil
 }
 
+// Define the set of basic types as
+// defined in https://kro.run/docs/concepts/simple-schema#basic-types
+var excludedTypes = map[string]struct{}{
+	"string":  {},
+	"integer": {},
+	"bool":    {},
+	"float":   {},
+	"object":  {},
+}
+
+func extractDependenciesFromMap(obj interface{}) []string {
+	var dependencies []string
+
+	// Use a recursive helper function to traverse the map and extract dependencies
+	var parseMap func(map[string]interface{})
+	parseMap = func(m map[string]interface{}) {
+		for _, value := range m {
+			switch v := value.(type) {
+			case string:
+				// Strip array prefixes like "[]"
+				trimmed := strings.TrimPrefix(v, "[]")
+
+				// Filter out primitive types
+				if _, isExcluded := excludedTypes[trimmed]; !isExcluded {
+					dependencies = append(dependencies, trimmed)
+				}
+			case map[string]interface{}:
+				// Recursively parse nested maps
+				parseMap(v)
+			case []interface{}:
+				// Handle slices of types (e.g., []string or [][nested type])
+				for _, elem := range v {
+					if nestedMap, ok := elem.(map[string]interface{}); ok {
+						parseMap(nestedMap)
+					}
+				}
+			}
+		}
+	}
+
+	if rootMap, ok := obj.(map[string]interface{}); ok {
+		parseMap(rootMap)
+	}
+
+	// Remove duplicates using a set
+	dependencySet := make(map[string]struct{})
+	for _, dep := range dependencies {
+		dependencySet[dep] = struct{}{}
+	}
+
+	// Convert the set back to a slice
+	result := make([]string, 0, len(dependencySet))
+	for dep := range dependencySet {
+		result = append(result, dep)
+	}
+
+	return result
+}
+
 // buildOpenAPISchema builds an OpenAPI schema from the given object
 // of a SimpleSchema.
 func (tf *transformer) buildOpenAPISchema(obj map[string]interface{}) (*extv1.JSONSchemaProps, error) {

pkg/simpleschema/transform.go

@@ -991,7 +991,7 @@ func TestLoadPreDefinedTypes(t *testing.T) {
 		wantErr bool
 	}{
 		{
-			name: "Valid types",
+			name: "Valid types with cross-references",
 			obj: map[string]interface{}{
 				"Person": map[string]interface{}{
 					"name": "string",
@@ -1000,6 +1000,7 @@ func TestLoadPreDefinedTypes(t *testing.T) {
 						"street": "string",
 						"city":   "string",
 					},
+					"company": "Company",
 				},
 				"Company": map[string]interface{}{
 					"name":      "string",
@@ -1020,6 +1021,20 @@ func TestLoadPreDefinedTypes(t *testing.T) {
 									"city":   {Type: "string"},
 								},
 							},
+							"company": {
+								Type: "object",
+								Properties: map[string]extv1.JSONSchemaProps{
+									"name": {Type: "string"},
+									"employees": {
+										Type: "array",
+										Items: &extv1.JSONSchemaPropsOrArray{
+											Schema: &extv1.JSONSchemaProps{
+												Type: "string",
+											},
+										},
+									},
+								},
+							},
 						},
 					},
 					Required: false,
@@ -1044,6 +1059,26 @@ func TestLoadPreDefinedTypes(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "Invalid types with cyclic references",
+			obj: map[string]interface{}{
+				"Person": map[string]interface{}{
+					"name": "string",
+					"age":  "integer",
+					"address": map[string]interface{}{
+						"street": "string",
+						"city":   "string",
+					},
+					"company": "Company",
+				},
+				"Company": map[string]interface{}{
+					"name":      "string",
+					"employees": "[]Person",
+				},
+			},
+			want:    map[string]predefinedType{},
+			wantErr: true,
+		},
 		{
 			name: "Simple type alias",
 			obj: map[string]interface{}{