Fix serializer including legacy scope properties when modern properties present (#756)

* all green

* add more tests, all green

Author: harshpatel17

src/Bicep.Types.UnitTests/TypeSerializerTests.cs

@@ -8,7 +8,9 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
+using Azure.Bicep.Types;
 using Azure.Bicep.Types.Concrete;
+using Azure.Bicep.Types.Index;
 using Azure.Bicep.Types.Serialization;
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -414,6 +416,157 @@ public void ResourceType_with_legacy_unknown_scope_deserializes_as_all()
             deserializedResource.WritableScopes.Should().Be(ScopeType.All);
         }
 
+        [TestMethod]
+        public void ResourceType_with_modern_scopes_should_not_serialize_null_legacy_properties()
+        {
+            var factory = new TypeFactory(Enumerable.Empty<TypeBase>());
+            var stringType = factory.Create(() => new StringType());
+            var objectType = factory.Create(() => new ObjectType(
+                name: "request@v1",
+                properties: new Dictionary<string, ObjectTypeProperty>
+                {
+                    ["uri"] = new(factory.GetReference(stringType), ObjectTypePropertyFlags.Required, "The HTTP request URI")
+                },
+                additionalProperties: null));
+
+            // Create ResourceType with ONLY modern properties
+            var resourceType = factory.Create(() => new ResourceType(
+                name: "request@v1",
+                body: factory.GetReference(objectType),
+                functions: null,
+                writableScopes_in: ScopeType.All,
+                readableScopes_in: ScopeType.All));
+
+            // Serialize
+            string serializedJson;
+            using (var stream = new MemoryStream())
+            {
+                TypeSerializer.Serialize(stream, factory.GetTypes());
+                serializedJson = Encoding.UTF8.GetString(stream.ToArray());
+            }
+
+            var doc = JsonDocument.Parse(serializedJson);
+            var resourceElement = doc.RootElement.EnumerateArray()
+                .First(e => e.TryGetProperty("$type", out var typeVal) && typeVal.GetString() == "ResourceType");
+
+            // Check for legacy properties
+            bool hasScopeType = resourceElement.TryGetProperty("scopeType", out _);
+            bool hasReadOnlyScopes = resourceElement.TryGetProperty("readOnlyScopes", out _);
+            bool hasFlags = resourceElement.TryGetProperty("flags", out _);
+
+            // Verify modern properties are present
+            bool hasReadableScopes = resourceElement.TryGetProperty("readableScopes", out var readableVal);
+            bool hasWritableScopes = resourceElement.TryGetProperty("writableScopes", out var writableVal);
+
+            // Assert: Modern properties should be present
+            Assert.IsTrue(hasReadableScopes, "readableScopes should be present in JSON");
+            Assert.IsTrue(hasWritableScopes, "writableScopes should be present in JSON");
+            Assert.AreEqual(31, readableVal.GetInt32(), "readableScopes should be 31 (All)");
+            Assert.AreEqual(31, writableVal.GetInt32(), "writableScopes should be 31 (All)");
+
+            // Assert: Legacy properties should NOT be present (they are null and should be omitted)
+            Assert.IsFalse(hasScopeType, 
+                "scopeType should not be serialized when null (JsonIgnoreCondition.WhenWritingNull)");
+            Assert.IsFalse(hasReadOnlyScopes, 
+                "readOnlyScopes should not be serialized when null (JsonIgnoreCondition.WhenWritingNull)");
+            Assert.IsFalse(hasFlags, 
+                "flags should not be serialized when null (JsonIgnoreCondition.WhenWritingNull)");
+        }
+
+        [TestMethod]
+        public void ResourceType_with_legacy_scopes_should_serialize_and_deserialize_correctly()
+        {
+            var factory = new TypeFactory(Enumerable.Empty<TypeBase>());
+            var stringType = factory.Create(() => new StringType());
+            var objectType = factory.Create(() => new ObjectType(
+                name: "legacy@v1",
+                properties: new Dictionary<string, ObjectTypeProperty>
+                {
+                    ["id"] = new(factory.GetReference(stringType), ObjectTypePropertyFlags.Required, "Resource ID")
+                },
+                additionalProperties: null));
+
+            // Create with legacy properties
+            var resourceType = factory.Create(() => new ResourceType(
+                name: "legacy@v1",
+                body: factory.GetReference(objectType),
+                functions: null,
+                scopeType: ScopeType.ResourceGroup,
+                readOnlyScopes: null,
+                flags: ResourceFlags.None));
+
+            // Serialize
+            string serializedJson;
+            using (var stream = new MemoryStream())
+            {
+                TypeSerializer.Serialize(stream, factory.GetTypes());
+                serializedJson = Encoding.UTF8.GetString(stream.ToArray());
+            }
+
+            var doc = JsonDocument.Parse(serializedJson);
+            var resourceElement = doc.RootElement.EnumerateArray()
+                .First(e => e.TryGetProperty("$type", out var typeVal) && typeVal.GetString() == "ResourceType");
+
+            // Deserialize
+            TypeBase[] deserializedTypes;
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(serializedJson)))
+            {
+                deserializedTypes = TypeSerializer.Deserialize(stream);
+            }
+
+            var deserialized = deserializedTypes.OfType<ResourceType>().First();
+
+            Assert.AreEqual(ScopeType.ResourceGroup, deserialized.ReadableScopes);
+            Assert.AreEqual(ScopeType.ResourceGroup, deserialized.WritableScopes);
+        }
+
+        [TestMethod]
+        public void ResourceType_modern_scopes_roundtrip_preserves_values()
+        {
+            var factory = new TypeFactory(Enumerable.Empty<TypeBase>());
+            var stringType = factory.Create(() => new StringType());
+            var objectType = factory.Create(() => new ObjectType(
+                name: "roundtrip@v1",
+                properties: new Dictionary<string, ObjectTypeProperty>
+                {
+                    ["name"] = new(factory.GetReference(stringType), ObjectTypePropertyFlags.Required, "Name")
+                },
+                additionalProperties: null));
+
+            // Create with modern properties
+            var original = factory.Create(() => new ResourceType(
+                name: "roundtrip@v1",
+                body: factory.GetReference(objectType),
+                functions: null,
+                writableScopes_in: ScopeType.Subscription | ScopeType.ResourceGroup,
+                readableScopes_in: ScopeType.All));
+
+            // Serialize
+            string serializedJson;
+            using (var stream = new MemoryStream())
+            {
+                TypeSerializer.Serialize(stream, factory.GetTypes());
+                serializedJson = Encoding.UTF8.GetString(stream.ToArray());
+            }
+
+            // Deserialize
+            TypeBase[] deserializedTypes;
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(serializedJson)))
+            {
+                deserializedTypes = TypeSerializer.Deserialize(stream);
+            }
+
+            var deserialized = deserializedTypes.OfType<ResourceType>().First();
+
+            // Verify scopes match exactly
+            Assert.AreEqual(original.ReadableScopes, deserialized.ReadableScopes, 
+                "ReadableScopes should be preserved through roundtrip");
+            Assert.AreEqual(original.WritableScopes, deserialized.WritableScopes,
+                "WritableScopes should be preserved through roundtrip");
+            Assert.AreEqual(ScopeType.All, deserialized.ReadableScopes);
+            Assert.AreEqual(ScopeType.Subscription | ScopeType.ResourceGroup, deserialized.WritableScopes);
+        }
+
         private static Stream BuildStream(Action<Stream> writeFunc)
         {
             var memoryStream = new MemoryStream();

src/Bicep.Types/Serialization/TypeSerializer.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Linq;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Metadata;
 using Azure.Bicep.Types.Concrete;
 using Azure.Bicep.Types.Index;
@@ -23,6 +24,7 @@ public static JsonSerializerOptions GetSerializerOptions(TypeFactory? factory =
             },
             PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
             WriteIndented = true,
+            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
             TypeInfoResolver = TypeJsonContext.Default,
         };
     }