fix: add structural compatibility for map-to-struct and struct-to-map conversions

Includes test cases and implementation for validating map-to-struct and struct-to-map conversions, ensuring structural compatibility of keys and fields.

Signed-off-by: Jakob Möller <[email protected]>

Author: jakobmoellerdev

pkg/cel/compatibility.go

@@ -37,6 +37,7 @@ const (
 // - For lists: recursively checks element type compatibility
 // - For maps: recursively checks key and value type compatibility
 // - For structs: uses DeclTypeProvider to introspect fields and check all required fields exist with compatible types
+// - For map → struct and struct → map compatibility if fields/keys are structurally compatible
 //
 // The provider is required for introspecting struct field information.
 // Returns true if types are compatible, false otherwise. If false, the error describes why.
@@ -50,23 +51,28 @@ func AreTypesStructurallyCompatible(output, expected *cel.Type, provider *DeclTy
 		return true, nil
 	}
 
+	// Unwrap optional output if available
 	if output.Kind() == cel.OpaqueKind && output.TypeName() == "optional_type" {
 		return AreTypesStructurallyCompatible(output.Parameters()[0], expected, provider)
 	}
 
-	switch expected.Kind() {
-	case cel.ListKind:
+	switch {
+	case expected.Kind() == cel.StructKind && output.Kind() == cel.MapKind:
+		return areMapTypesAssignableToStruct(output, expected, provider)
+	case expected.Kind() == cel.MapKind && output.Kind() == cel.StructKind:
+		return areStructTypesAssignableToMap(output, expected, provider)
+	case expected.Kind() == cel.ListKind:
 		return areListTypesCompatible(output, expected, provider)
-	case cel.MapKind:
+	case expected.Kind() == cel.MapKind:
 		return areMapTypesCompatible(output, expected, provider)
-	case cel.StructKind:
+	case expected.Kind() == cel.StructKind:
 		return areStructTypesCompatible(output, expected, provider)
 	default:
-		// Kinds must match
+		// Kinds must match otherwise
 		if output.Kind() != expected.Kind() {
 			return false, fmt.Errorf("type kind mismatch: got %q, expected %q", output.String(), expected.String())
 		}
-		// For primitives (int, string, bool, etc.), kind equality is enough
+		// primitives: kind equality already checked
 		return true, nil
 	}
 }
@@ -275,3 +281,70 @@ func areStructFieldsCompatible(output, expected *apiservercel.DeclType, provider
 
 	return true, nil
 }
+
+func areMapTypesAssignableToStruct(outputMap, expectedStruct *cel.Type, provider *DeclTypeProvider) (bool, error) {
+	expectedDecl := resolveDeclTypeFromPath(expectedStruct.String(), provider)
+	if expectedDecl == nil || expectedDecl.Fields == nil {
+		return true, nil
+	}
+
+	// map parameters are [keyType, valueType]
+	params := outputMap.Parameters()
+	if len(params) < 2 {
+		return false, fmt.Errorf("map must have key and value types")
+	}
+
+	keyType := params[0]
+	valType := params[1]
+
+	// keys must be strings to match struct field names
+	if keyType.Kind() != cel.StringKind {
+		return false, fmt.Errorf("map keys must be strings to assign to struct")
+	}
+
+	for fieldName, expectedField := range expectedDecl.Fields {
+		expectedFieldCEL := expectedField.Type.CelType()
+		if expectedFieldCEL == nil {
+			continue
+		}
+		compatible, err := AreTypesStructurallyCompatible(valType, expectedFieldCEL, provider)
+		if !compatible {
+			return false, fmt.Errorf("map value incompatible with struct field %q: %w", fieldName, err)
+		}
+	}
+
+	return true, nil
+}
+
+func areStructTypesAssignableToMap(outputStruct, expectedMap *cel.Type, provider *DeclTypeProvider) (bool, error) {
+	outputDecl := resolveDeclTypeFromPath(outputStruct.String(), provider)
+	if outputDecl == nil || outputDecl.Fields == nil {
+		return true, nil
+	}
+
+	params := expectedMap.Parameters()
+	if len(params) < 2 {
+		return false, fmt.Errorf("expected map must have key and value types")
+	}
+	keyType := params[0]
+	valType := params[1]
+
+	// struct field names map to string keys
+	if keyType.Kind() != cel.StringKind {
+		return false, fmt.Errorf("map key type must be string when assigning struct → map")
+	}
+
+	for fieldName, outputField := range outputDecl.Fields {
+		outputCEL := outputField.Type.CelType()
+		if outputCEL == nil {
+			continue
+		}
+
+		compatible, err := AreTypesStructurallyCompatible(outputCEL, valType, provider)
+		if !compatible {
+			return false, fmt.Errorf("struct field %q incompatible with map value type: %w", fieldName, err)
+		}
+	}
+
+	return true, nil
+}

pkg/cel/compatibility_test.go

@@ -438,6 +438,158 @@ func TestNestedTypes(t *testing.T) {
 	}
 }
 
+func TestMapToStructCompatibility(t *testing.T) {
+	// homogeneous struct: {a:int, b:int}
+	intStructFields := map[string]*apiservercel.DeclField{
+		"a": apiservercel.NewDeclField("a", apiservercel.IntType, true, nil, nil),
+		"b": apiservercel.NewDeclField("b", apiservercel.IntType, false, nil, nil),
+	}
+	intStruct := apiservercel.NewObjectType(TypeNamePrefix+"intStruct", intStructFields)
+
+	// homogeneous struct: {x:string, y:string}
+	stringStructFields := map[string]*apiservercel.DeclField{
+		"x": apiservercel.NewDeclField("x", apiservercel.StringType, true, nil, nil),
+		"y": apiservercel.NewDeclField("y", apiservercel.StringType, true, nil, nil),
+	}
+	stringStruct := apiservercel.NewObjectType(TypeNamePrefix+"stringStruct", stringStructFields)
+
+	provider := NewDeclTypeProvider(intStruct, stringStruct)
+
+	tests := []struct {
+		name        string
+		output      *cel.Type
+		expected    *cel.Type
+		compatible  bool
+		errContains string
+	}{
+		{
+			name:       "map[string]int → struct{a:int, b:int} OK",
+			output:     cel.MapType(cel.StringType, cel.IntType),
+			expected:   intStruct.CelType(),
+			compatible: true,
+		},
+		{
+			name:       "map[string]optional<int> → struct{a:int, b:int} OK",
+			output:     cel.MapType(cel.StringType, cel.OptionalType(cel.IntType)),
+			expected:   intStruct.CelType(),
+			compatible: true,
+		},
+		{
+			name:       "map[string]string → struct{x:string, y:string} OK",
+			output:     cel.MapType(cel.StringType, cel.StringType),
+			expected:   stringStruct.CelType(),
+			compatible: true,
+		},
+		{
+			name:       "map[string]dyn → struct{x:string, y:string} OK",
+			output:     cel.MapType(cel.StringType, cel.DynType),
+			expected:   stringStruct.CelType(),
+			compatible: true,
+		},
+		{
+			name:        "map[int]string → struct{x:string,y:string} invalid (key type)",
+			output:      cel.MapType(cel.IntType, cel.StringType),
+			expected:    stringStruct.CelType(),
+			compatible:  false,
+			errContains: "keys must be strings",
+		},
+		{
+			name:        "map[string]int → struct{x:string,y:string} incompatible",
+			output:      cel.MapType(cel.StringType, cel.IntType),
+			expected:    stringStruct.CelType(),
+			compatible:  false,
+			errContains: "incompatible",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			compatible, err := AreTypesStructurallyCompatible(tt.output, tt.expected, provider)
+			assert.Equal(t, tt.compatible, compatible)
+			if tt.compatible {
+				assert.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				if tt.errContains != "" {
+					assert.Contains(t, err.Error(), tt.errContains)
+				}
+			}
+		})
+	}
+}
+
+func TestStructToMapCompatibility(t *testing.T) {
+	intStructFields := map[string]*apiservercel.DeclField{
+		"a": apiservercel.NewDeclField("a", apiservercel.IntType, true, nil, nil),
+		"b": apiservercel.NewDeclField("b", apiservercel.IntType, false, nil, nil),
+	}
+	intStruct := apiservercel.NewObjectType(TypeNamePrefix+"intStruct", intStructFields)
+
+	stringStructFields := map[string]*apiservercel.DeclField{
+		"x": apiservercel.NewDeclField("x", apiservercel.StringType, true, nil, nil),
+		"y": apiservercel.NewDeclField("y", apiservercel.StringType, true, nil, nil),
+	}
+	stringStruct := apiservercel.NewObjectType(TypeNamePrefix+"stringStruct", stringStructFields)
+
+	provider := NewDeclTypeProvider(intStruct, stringStruct)
+
+	tests := []struct {
+		name        string
+		output      *cel.Type
+		expected    *cel.Type
+		compatible  bool
+		errContains string
+	}{
+		{
+			name:       "struct{a:int,b:int} → map[string]int OK",
+			output:     intStruct.CelType(),
+			expected:   cel.MapType(cel.StringType, cel.IntType),
+			compatible: true,
+		},
+		{
+			name:       "struct{x:string,y:string} → map[string]string OK",
+			output:     stringStruct.CelType(),
+			expected:   cel.MapType(cel.StringType, cel.StringType),
+			compatible: true,
+		},
+		{
+			name:       "struct{x:string,y:string} → map[string]dyn OK",
+			output:     stringStruct.CelType(),
+			expected:   cel.MapType(cel.StringType, cel.DynType),
+			compatible: true,
+		},
+		{
+			name:        "struct{x:string,y:string} → map[int]string invalid (bad key)",
+			output:      stringStruct.CelType(),
+			expected:    cel.MapType(cel.IntType, cel.StringType),
+			compatible:  false,
+			errContains: "key type must be string",
+		},
+		{
+			name:        "struct{x:string,y:string} → map[string]int incompatible",
+			output:      stringStruct.CelType(),
+			expected:    cel.MapType(cel.StringType, cel.IntType),
+			compatible:  false,
+			errContains: "incompatible",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			compatible, err := AreTypesStructurallyCompatible(tt.output, tt.expected, provider)
+			assert.Equal(t, tt.compatible, compatible)
+			if tt.compatible {
+				assert.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				if tt.errContains != "" {
+					assert.Contains(t, err.Error(), tt.errContains)
+				}
+			}
+		})
+	}
+}
+
 func TestOptionalPrimitive(t *testing.T) {
 	optionalString := cel.OpaqueType("optional_type", cel.StringType)
 	optionalInt := cel.OpaqueType("optional_type", cel.IntType)