Fix serialization for StoredProcedureDefinition inheritance (#3045)

Alekhya-Polavarapu · Aniruddh25 · web-flow · commit 090e68e1f640 · 2026-01-13T17:41:36.000Z
## Why make this change?
- To apply correct serialization and deserialization logic for stored
procedures. With the previous changes, serialization was not working
correctly for the StoredProcedureDefinition type, which extends
SourceDefinition. When the value type was passed explicitly for
serialization, the parent type was used instead, causing some child-type
properties to be omitted.
## What is this change?
Instead of manually specifying the value type during serialization, this
change allows the library to infer the type automatically and perform
the correct serialization.

## How was this tested?
- [x] Unit Tests

---------

Co-authored-by: Aniruddh Munde &lt;anmunde@microsoft.com&gt;
diff --git a/src/Core/Services/MetadataProviders/Converters/DatabaseObjectConverter.cs b/src/Core/Services/MetadataProviders/Converters/DatabaseObjectConverter.cs
@@ -34,7 +34,7 @@ public override DatabaseObject Read(ref Utf8JsonReader reader, Type typeToConver
 
                 DatabaseObject objA = (DatabaseObject)JsonSerializer.Deserialize(document, concreteType, options)!;
 
-                foreach (PropertyInfo prop in objA.GetType().GetProperties().Where(IsSourceDefinitionProperty))
+                foreach (PropertyInfo prop in objA.GetType().GetProperties().Where(IsSourceDefinitionOrDerivedClassProperty))
                 {
                     SourceDefinition? sourceDef = (SourceDefinition?)prop.GetValue(objA);
                     if (sourceDef is not null)
@@ -73,25 +73,23 @@ public override void Write(Utf8JsonWriter writer, DatabaseObject value, JsonSeri
 
                 writer.WritePropertyName(prop.Name);
                 object? propVal = prop.GetValue(value);
-                Type propType = prop.PropertyType;
 
-                // Only escape columns for properties whose type is exactly SourceDefinition (not subclasses).
-                // This is because, we do not want unnecessary mutation of subclasses of SourceDefinition unless needed.
-                if (IsSourceDefinitionProperty(prop) && propVal is SourceDefinition sourceDef && propVal.GetType() == typeof(SourceDefinition))
+                // Only escape columns for properties whose type(derived type) is SourceDefinition.
+                if (IsSourceDefinitionOrDerivedClassProperty(prop) && propVal is SourceDefinition sourceDef)
                 {
                     EscapeDollaredColumns(sourceDef);
                 }
 
-                JsonSerializer.Serialize(writer, propVal, propType, options);
+                JsonSerializer.Serialize(writer, propVal, options);
             }
 
             writer.WriteEndObject();
         }
 
-        private static bool IsSourceDefinitionProperty(PropertyInfo prop)
+        private static bool IsSourceDefinitionOrDerivedClassProperty(PropertyInfo prop)
         {
-            // Only return true for properties whose type is exactly SourceDefinition (not subclasses)
-            return prop.PropertyType == typeof(SourceDefinition);
+            // Return true for properties whose type is SourceDefinition or any class derived from SourceDefinition
+            return typeof(SourceDefinition).IsAssignableFrom(prop.PropertyType);
         }
 
         /// <summary>
diff --git a/src/Service.Tests/UnitTests/SerializationDeserializationTests.cs b/src/Service.Tests/UnitTests/SerializationDeserializationTests.cs
@@ -299,8 +299,11 @@ public void TestDictionaryDatabaseObjectSerializationDeserialization_WithDollarC
             Dictionary<string, DatabaseObject> dict = new() { { "person", _databaseTable } };
 
             string serializedDict = JsonSerializer.Serialize(dict, _options);
-            Dictionary<string, DatabaseObject> deserializedDict = JsonSerializer.Deserialize<Dictionary<string, DatabaseObject>>(serializedDict, _options)!;
+            // Assert that the serialized JSON contains the escaped dollar sign in column name
+            Assert.IsTrue(serializedDict.Contains("DAB_ESCAPE$FirstName"),
+                "Serialized JSON should contain the dollar-prefixed column name in SourceDefinition's Columns.");
 
+            Dictionary<string, DatabaseObject> deserializedDict = JsonSerializer.Deserialize<Dictionary<string, DatabaseObject>>(serializedDict, _options)!;
             DatabaseTable deserializedDatabaseTable = (DatabaseTable)deserializedDict["person"];
 
             Assert.AreEqual(deserializedDatabaseTable.SourceType, _databaseTable.SourceType);
@@ -322,14 +325,22 @@ public void TestDatabaseViewSerializationDeserialization_WithDollarColumn()
 
             TestTypeNameChanges(_databaseView, "DatabaseView");
 
+            Dictionary<string, DatabaseObject> dict = new();
+            dict.Add("person", _databaseView);
+
             // Test to catch if there is change in number of properties/fields
             // Note: On Addition of property make sure it is added in following object creation _databaseView and include in serialization
             // and deserialization test.
             int fields = typeof(DatabaseView).GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Length;
             Assert.AreEqual(fields, 6);
 
-            string serializedDatabaseView = JsonSerializer.Serialize(_databaseView, _options);
-            DatabaseView deserializedDatabaseView = JsonSerializer.Deserialize<DatabaseView>(serializedDatabaseView, _options)!;
+            string serializedDatabaseView = JsonSerializer.Serialize(dict, _options);
+            // Assert that the serialized JSON contains the escaped dollar sign in column name
+            Assert.IsTrue(serializedDatabaseView.Contains("DAB_ESCAPE$FirstName"),
+                "Serialized JSON should contain the dollar-prefixed column name in SourceDefinition's Columns.");
+            Dictionary<string, DatabaseObject> deserializedDict = JsonSerializer.Deserialize<Dictionary<string, DatabaseObject>>(serializedDatabaseView, _options)!;
+
+            DatabaseView deserializedDatabaseView = (DatabaseView)deserializedDict["person"];
 
             Assert.AreEqual(deserializedDatabaseView.SourceType, _databaseView.SourceType);
             deserializedDatabaseView.Equals(_databaseView);
@@ -349,14 +360,21 @@ public void TestDatabaseStoredProcedureSerializationDeserialization_WithDollarCo
 
             TestTypeNameChanges(_databaseStoredProcedure, "DatabaseStoredProcedure");
 
+            Dictionary<string, DatabaseObject> dict = new();
+            dict.Add("person", _databaseStoredProcedure);
+
             // Test to catch if there is change in number of properties/fields
             // Note: On Addition of property make sure it is added in following object creation _databaseStoredProcedure and include in serialization
             // and deserialization test.
             int fields = typeof(DatabaseStoredProcedure).GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Length;
             Assert.AreEqual(fields, 6);
 
-            string serializedDatabaseSP = JsonSerializer.Serialize(_databaseStoredProcedure, _options);
-            DatabaseStoredProcedure deserializedDatabaseSP = JsonSerializer.Deserialize<DatabaseStoredProcedure>(serializedDatabaseSP, _options)!;
+            string serializedDatabaseSP = JsonSerializer.Serialize(dict, _options);
+            // Assert that the serialized JSON contains the escaped dollar sign in column name
+            Assert.IsTrue(serializedDatabaseSP.Contains("DAB_ESCAPE$FirstName"),
+                "Serialized JSON should contain the dollar-prefixed column name in SourceDefinition's Columns.");
+            Dictionary<string, DatabaseObject> deserializedDict = JsonSerializer.Deserialize<Dictionary<string, DatabaseObject>>(serializedDatabaseSP, _options)!;
+            DatabaseStoredProcedure deserializedDatabaseSP = (DatabaseStoredProcedure)deserializedDict["person"];
 
             Assert.AreEqual(deserializedDatabaseSP.SourceType, _databaseStoredProcedure.SourceType);
             deserializedDatabaseSP.Equals(_databaseStoredProcedure);

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public override DatabaseObject Read(ref Utf8JsonReader reader, Type typeToConver`
`34`	`34`
`35`	`35`	`DatabaseObject objA = (DatabaseObject)JsonSerializer.Deserialize(document, concreteType, options)!;`
`36`	`36`
`37`		`- foreach (PropertyInfo prop in objA.GetType().GetProperties().Where(IsSourceDefinitionProperty))`
	`37`	`+ foreach (PropertyInfo prop in objA.GetType().GetProperties().Where(IsSourceDefinitionOrDerivedClassProperty))`
`38`	`38`	`{`
`39`	`39`	`SourceDefinition? sourceDef = (SourceDefinition?)prop.GetValue(objA);`
`40`	`40`	`if (sourceDef is not null)`
`@@ -73,25 +73,23 @@ public override void Write(Utf8JsonWriter writer, DatabaseObject value, JsonSeri`
`73`	`73`
`74`	`74`	`writer.WritePropertyName(prop.Name);`
`75`	`75`	`object? propVal = prop.GetValue(value);`
`76`		`- Type propType = prop.PropertyType;`
`77`	`76`
`78`		`- // Only escape columns for properties whose type is exactly SourceDefinition (not subclasses).`
`79`		`- // This is because, we do not want unnecessary mutation of subclasses of SourceDefinition unless needed.`
`80`		`- if (IsSourceDefinitionProperty(prop) && propVal is SourceDefinition sourceDef && propVal.GetType() == typeof(SourceDefinition))`
	`77`	`+ // Only escape columns for properties whose type(derived type) is SourceDefinition.`
	`78`	`+ if (IsSourceDefinitionOrDerivedClassProperty(prop) && propVal is SourceDefinition sourceDef)`
`81`	`79`	`{`
`82`	`80`	`EscapeDollaredColumns(sourceDef);`
`83`	`81`	`}`
`84`	`82`
`85`		`- JsonSerializer.Serialize(writer, propVal, propType, options);`
	`83`	`+ JsonSerializer.Serialize(writer, propVal, options);`
`86`	`84`	`}`
`87`	`85`
`88`	`86`	`writer.WriteEndObject();`
`89`	`87`	`}`
`90`	`88`
`91`		`- private static bool IsSourceDefinitionProperty(PropertyInfo prop)`
	`89`	`+ private static bool IsSourceDefinitionOrDerivedClassProperty(PropertyInfo prop)`
`92`	`90`	`{`
`93`		`- // Only return true for properties whose type is exactly SourceDefinition (not subclasses)`
`94`		`- return prop.PropertyType == typeof(SourceDefinition);`
	`91`	`+ // Return true for properties whose type is SourceDefinition or any class derived from SourceDefinition`
	`92`	`+ return typeof(SourceDefinition).IsAssignableFrom(prop.PropertyType);`
`95`	`93`	`}`
`96`	`94`
`97`	`95`	`/// <summary>`