DGS-22343 Fix transformation of union of JSON refs (#2525)

* DGS-22343 Fix transformation of union of JSON refs

* Minor cleanup

Author: rayokota

src/Confluent.SchemaRegistry.Serdes.Json/JsonUtils.cs

@@ -77,7 +77,20 @@ public static async Task<object> Transform(RuleContext ctx, JsonSchema schema, s
             if (schema.AllOf.Count > 0 || schema.AnyOf.Count > 0 || schema.OneOf.Count > 0)
             {
                 JToken jsonObject = JToken.FromObject(message);
-                foreach (JsonSchema subschema in schema.AllOf)
+                ICollection<JsonSchema> subschemas;
+                if (schema.AllOf.Count > 0)
+                {
+                    subschemas = schema.AllOf;
+                }
+                else if (schema.AnyOf.Count > 0)
+                {
+                    subschemas = schema.AnyOf;
+                }
+                else
+                {
+                    subschemas = schema.OneOf;
+                }
+                foreach (JsonSchema subschema in subschemas)
                 {
                     var validator = new JsonSchemaValidator();
                     var errors = validator.Validate(jsonObject, subschema);
@@ -105,14 +118,22 @@ public static async Task<object> Transform(RuleContext ctx, JsonSchema schema, s
                     Transform(ctx, subschema, path + '[' + index + ']', elem, fieldTransform);
                 return await Utils.TransformEnumerableAsync(message, transformer).ConfigureAwait(false);
             }
-            else if (schema.IsObject)
+            else if (schema.IsObject || schema.Properties.Count > 0)
             {
                 foreach (var it in schema.Properties)
                 {
                     string fullName = path + '.' + it.Key;
                     using (ctx.EnterField(message, fullName, it.Key, GetType(it.Value), GetInlineTags(it.Value)))
                     {
-                        FieldAccessor fieldAccessor = new FieldAccessor(message.GetType(), it.Key);
+                        FieldAccessor fieldAccessor;
+                        try
+                        {
+                            fieldAccessor = new FieldAccessor(message.GetType(), it.Key);
+                        }
+                        catch (ArgumentException)
+                        {
+                            continue;
+                        }
                         object value = fieldAccessor.GetFieldValue(message);
                         object newValue = await Transform(ctx, it.Value, fullName, value, fieldTransform).ConfigureAwait(false);
                         if (ctx.Rule.Kind == RuleKind.Condition)

test/Confluent.SchemaRegistry.Serdes.UnitTests/JsonSerializeDeserialize.cs

@@ -757,6 +757,111 @@ public void CELFieldTransformWithNullable()
             Assert.Equal(user.FavoriteNumber, result.FavoriteNumber);
         }
 
+        [Fact]
+        public void CELFieldTransformWithUnionOfRefs()
+        {
+            var schemaStr = @"{
+                ""type"": ""object"",
+                ""properties"": {
+                    ""messageType"": {
+                        ""type"": ""string""
+                    },
+                    ""version"": {
+                        ""type"": ""string""
+                    },
+                    ""payload"": {
+                        ""type"": ""object"",
+                        ""oneOf"": [
+                            {
+                                ""$ref"": ""#/$defs/authentication_request""
+                            },
+                            {
+                                ""$ref"": ""#/$defs/authentication_status""
+                            }
+                        ]
+                    }
+                },
+                ""required"": [
+                    ""payload"",
+                    ""messageType"",
+                    ""version""
+                ],
+                ""$defs"": {
+                    ""authentication_request"": {
+                        ""properties"": {
+                            ""messageId"": {
+                                ""type"": ""string"",
+                                ""confluent:tags"": [""PII""]
+                            },
+                            ""timestamp"": {
+                                ""type"": ""integer"",
+                                ""minimum"": 0
+                            },
+                            ""requestId"": {
+                                ""type"": ""string""
+                            }
+                        },
+                        ""required"": [
+                            ""messageId"",
+                            ""timestamp""
+                        ]
+                    },
+                    ""authentication_status"": {
+                        ""properties"": {
+                            ""messageId"": {
+                                ""type"": ""string"",
+                                ""confluent:tags"": [""PII""]
+                            },
+                            ""authType"": {
+                                ""type"": [
+                                    ""string"",
+                                    ""null""
+                                ]
+                            }
+                        },
+                        ""required"": [
+                            ""messageId"",
+                            ""authType""
+                        ]
+                    }
+                }
+            }";
+            var schema = new RegisteredSchema("topic-value", 1, 1, schemaStr, SchemaType.Json, null);
+            schema.RuleSet = new RuleSet(new List<Rule>(),
+                new List<Rule>
+                {
+                    new Rule("testCEL", RuleKind.Transform, RuleMode.Write, "CEL_FIELD", null, null,
+                        "typeName == 'STRING' ; value + '-suffix'", null, null, false)
+                }
+            );
+            store[schemaStr] = 1;
+            subjectStore["topic-value"] = new List<RegisteredSchema> { schema };
+            var config = new JsonSerializerConfig
+            {
+                AutoRegisterSchemas = false,
+                UseLatestVersion = true
+            };
+            var serializer = new JsonSerializer<Message>(schemaRegistryClient, config);
+            var deserializer = new JsonDeserializer<Message>(schemaRegistryClient);
+
+            var msg = new Message
+            {
+                MessageType = "authentication_request",
+                Version = "1.0",
+                Payload = new Payload
+                {
+                    MessageId = "12345",
+                    Timestamp = 1757410647
+                }
+            };
+
+            Headers headers = new Headers();
+            var bytes = serializer.SerializeAsync(msg, new SerializationContext(MessageComponentType.Value, testTopic, headers)).Result;
+            var result = deserializer.DeserializeAsync(bytes, false, new SerializationContext(MessageComponentType.Value, testTopic, headers)).Result;
+
+            Assert.Equal("12345-suffix", result.Payload.MessageId);
+        }
+
         [Fact]
         public void CELFieldTransformWithDef()
         {
@@ -1404,4 +1509,23 @@ class Address
         public int DoorNumber { get; set; }
         public string DoorPin { get; set; }
     }
+
+    class Message
+    {
+        [JsonProperty("messageType")]
+        public string MessageType { get; set; }
+        [JsonProperty("version")]
+        public string Version { get; set; }
+        [JsonProperty("payload")]
+        public Payload Payload { get; set; }
+    }
+
+    class Payload
+    {
+        [JsonProperty("messageId")]
+        public string MessageId { get; set; }
+        [JsonProperty("timestamp")]
+        public int Timestamp { get; set; }
+    }
+
 }