Improve serialization compatibility with new component types (#1620)

* Improve serialization compatibility with new component types

Author: grvillic

src/Microsoft.ComponentDetection.Contracts/BcdeModels/TypedComponentConverter.cs

@@ -2,35 +2,12 @@
 namespace Microsoft.ComponentDetection.Contracts.BcdeModels;
 
 using System;
-using System.Collections.Generic;
 using Microsoft.ComponentDetection.Contracts.TypedComponent;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 public class TypedComponentConverter : JsonConverter
 {
-    private readonly Dictionary<ComponentType, Type> componentTypesToTypes = new Dictionary<ComponentType, Type>
-    {
-        { ComponentType.Other, typeof(OtherComponent) },
-        { ComponentType.NuGet, typeof(NuGetComponent) },
-        { ComponentType.Npm, typeof(NpmComponent) },
-        { ComponentType.Maven, typeof(MavenComponent) },
-        { ComponentType.Git, typeof(GitComponent) },
-        { ComponentType.RubyGems, typeof(RubyGemsComponent) },
-        { ComponentType.Cargo, typeof(CargoComponent) },
-        { ComponentType.Conan, typeof(ConanComponent) },
-        { ComponentType.Pip, typeof(PipComponent) },
-        { ComponentType.Go, typeof(GoComponent) },
-        { ComponentType.DockerImage, typeof(DockerImageComponent) },
-        { ComponentType.Pod, typeof(PodComponent) },
-        { ComponentType.Linux, typeof(LinuxComponent) },
-        { ComponentType.Conda, typeof(CondaComponent) },
-        { ComponentType.DockerReference, typeof(DockerReferenceComponent) },
-        { ComponentType.Vcpkg, typeof(VcpkgComponent) },
-        { ComponentType.Spdx, typeof(SpdxComponent) },
-        { ComponentType.DotNet, typeof(DotNetComponent) },
-    };
-
     public override bool CanWrite
     {
         get { return false; }
@@ -46,8 +23,14 @@ public override object ReadJson(
     {
         var jo = JToken.Load(reader);
 
-        var value = (ComponentType)Enum.Parse(typeof(ComponentType), (string)jo["type"]);
-        var targetType = this.componentTypesToTypes[value];
+        var typeString = (string)jo["type"];
+        if (!TypedComponentMapping.TryGetType(typeString, out var targetType))
+        {
+            // Unknown component type - return null to allow forward compatibility
+            // when new component types are added but downstream clients haven't updated yet
+            return null;
+        }
+
         var instanceOfTypedComponent = Activator.CreateInstance(targetType, true);
         serializer.Populate(jo.CreateReader(), instanceOfTypedComponent);
 

src/Microsoft.ComponentDetection.Contracts/BcdeModels/TypedComponentMapping.cs

@@ -0,0 +1,57 @@
+#nullable disable
+namespace Microsoft.ComponentDetection.Contracts.BcdeModels;
+
+using System;
+using System.Collections.Generic;
+using Microsoft.ComponentDetection.Contracts.TypedComponent;
+
+/// <summary>
+/// Provides a shared mapping between component type discriminator strings and their corresponding concrete TypedComponent types.
+/// This mapping is used by both Newtonsoft.Json and System.Text.Json converters for polymorphic serialization.
+/// </summary>
+internal static class TypedComponentMapping
+{
+    /// <summary>
+    /// Gets the dictionary mapping type discriminator strings to their corresponding concrete types.
+    /// The keys are case-insensitive to handle variations in JSON serialization.
+    /// </summary>
+    public static IReadOnlyDictionary<string, Type> TypeDiscriminatorToType { get; } = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)
+    {
+        { nameof(ComponentType.Other), typeof(OtherComponent) },
+        { nameof(ComponentType.NuGet), typeof(NuGetComponent) },
+        { nameof(ComponentType.Npm), typeof(NpmComponent) },
+        { nameof(ComponentType.Maven), typeof(MavenComponent) },
+        { nameof(ComponentType.Git), typeof(GitComponent) },
+        { nameof(ComponentType.RubyGems), typeof(RubyGemsComponent) },
+        { nameof(ComponentType.Cargo), typeof(CargoComponent) },
+        { nameof(ComponentType.Conan), typeof(ConanComponent) },
+        { nameof(ComponentType.Pip), typeof(PipComponent) },
+        { nameof(ComponentType.Go), typeof(GoComponent) },
+        { nameof(ComponentType.DockerImage), typeof(DockerImageComponent) },
+        { nameof(ComponentType.Pod), typeof(PodComponent) },
+        { nameof(ComponentType.Linux), typeof(LinuxComponent) },
+        { nameof(ComponentType.Conda), typeof(CondaComponent) },
+        { nameof(ComponentType.DockerReference), typeof(DockerReferenceComponent) },
+        { nameof(ComponentType.Vcpkg), typeof(VcpkgComponent) },
+        { nameof(ComponentType.Spdx), typeof(SpdxComponent) },
+        { nameof(ComponentType.DotNet), typeof(DotNetComponent) },
+        { nameof(ComponentType.Swift), typeof(SwiftComponent) },
+    };
+
+    /// <summary>
+    /// Tries to get the concrete type for a given type discriminator string.
+    /// </summary>
+    /// <param name="typeDiscriminator">The type discriminator string from JSON.</param>
+    /// <param name="targetType">When successful, contains the concrete type; otherwise null.</param>
+    /// <returns>True if the type discriminator was recognized; otherwise false.</returns>
+    public static bool TryGetType(string typeDiscriminator, out Type targetType)
+    {
+        if (string.IsNullOrWhiteSpace(typeDiscriminator))
+        {
+            targetType = null;
+            return false;
+        }
+
+        return TypeDiscriminatorToType.TryGetValue(typeDiscriminator, out targetType);
+    }
+}

src/Microsoft.ComponentDetection.Contracts/BcdeModels/TypedComponentSystemTextJsonConverter.cs

@@ -0,0 +1,68 @@
+#nullable disable
+namespace Microsoft.ComponentDetection.Contracts.BcdeModels;
+
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using TypedComponentClass = Microsoft.ComponentDetection.Contracts.TypedComponent.TypedComponent;
+
+/// <summary>
+/// A System.Text.Json converter for TypedComponent that handles unknown component types gracefully.
+/// When an unknown component type is encountered, it returns null instead of throwing an exception.
+/// This enables forward compatibility when new component types are added but downstream clients haven't updated yet.
+/// </summary>
+public class TypedComponentSystemTextJsonConverter : JsonConverter<TypedComponentClass>
+{
+    private const string TypePropertyNameCamelCase = "type";
+    private const string TypePropertyNamePascalCase = "Type";
+
+    public override TypedComponentClass Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+
+        // Parse the JSON into a document so we can inspect it
+        using var doc = JsonDocument.ParseValue(ref reader);
+        var root = doc.RootElement;
+
+        // Extract the type discriminator
+        // Check both camelCase and PascalCase property names
+        if (!root.TryGetProperty(TypePropertyNameCamelCase, out var typeProperty) &&
+            !root.TryGetProperty(TypePropertyNamePascalCase, out typeProperty))
+        {
+            return null;
+        }
+
+        var typeDiscriminator = typeProperty.GetString();
+        if (!TypedComponentMapping.TryGetType(typeDiscriminator, out var targetType))
+        {
+            // Unknown component type - return null for forward compatibility
+            return null;
+        }
+
+        // Deserialize to the specific concrete type using default serialization
+        return (TypedComponentClass)root.Deserialize(targetType, options);
+    }
+
+    public override void Write(Utf8JsonWriter writer, TypedComponentClass value, JsonSerializerOptions options)
+    {
+        // Serialize to a document first to get all properties
+        using var doc = JsonSerializer.SerializeToDocument(value, value.GetType(), options);
+
+        writer.WriteStartObject();
+
+        // Write the type discriminator first (using camelCase as the standard output format)
+        writer.WriteString(TypePropertyNameCamelCase, value.Type.ToString());
+
+        // Write all other properties from the serialized document
+        foreach (var property in doc.RootElement.EnumerateObject())
+        {
+            property.WriteTo(writer);
+        }
+
+        writer.WriteEndObject();
+    }
+}

src/Microsoft.ComponentDetection.Contracts/Microsoft.ComponentDetection.Contracts.csproj

@@ -4,6 +4,10 @@
         <TargetFramework>netstandard2.0</TargetFramework>
     </PropertyGroup>
 
+    <ItemGroup>
+        <InternalsVisibleTo Include="Microsoft.ComponentDetection.Contracts.Tests" />
+    </ItemGroup>
+
     <ItemGroup>
         <PackageReference Include="Microsoft.Extensions.Logging" />
         <PackageReference Include="Newtonsoft.Json" />

src/Microsoft.ComponentDetection.Contracts/TypedComponent/TypedComponent.cs

@@ -4,42 +4,23 @@ namespace Microsoft.ComponentDetection.Contracts.TypedComponent;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Text.Json.Serialization;
 using Microsoft.ComponentDetection.Contracts.BcdeModels;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 using PackageUrl;
 using JsonConverterAttribute = Newtonsoft.Json.JsonConverterAttribute;
 using JsonIgnoreAttribute = Newtonsoft.Json.JsonIgnoreAttribute;
+using SystemTextJson = System.Text.Json.Serialization;
 
 [JsonObject(MemberSerialization.OptOut, NamingStrategyType = typeof(CamelCaseNamingStrategy))]
-[JsonConverter(typeof(TypedComponentConverter))]
+[JsonConverter(typeof(TypedComponentConverter))] // Newtonsoft.Json
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
-[JsonPolymorphic(TypeDiscriminatorPropertyName = "type")]
-[JsonDerivedType(typeof(CargoComponent), typeDiscriminator: nameof(ComponentType.Cargo))]
-[JsonDerivedType(typeof(ConanComponent), typeDiscriminator: nameof(ComponentType.Conan))]
-[JsonDerivedType(typeof(CondaComponent), typeDiscriminator: nameof(ComponentType.Conda))]
-[JsonDerivedType(typeof(DockerImageComponent), typeDiscriminator: nameof(ComponentType.DockerImage))]
-[JsonDerivedType(typeof(DockerReferenceComponent), typeDiscriminator: nameof(ComponentType.DockerReference))]
-[JsonDerivedType(typeof(DotNetComponent), typeDiscriminator: nameof(ComponentType.DotNet))]
-[JsonDerivedType(typeof(GitComponent), typeDiscriminator: nameof(ComponentType.Git))]
-[JsonDerivedType(typeof(GoComponent), typeDiscriminator: nameof(ComponentType.Go))]
-[JsonDerivedType(typeof(LinuxComponent), typeDiscriminator: nameof(ComponentType.Linux))]
-[JsonDerivedType(typeof(MavenComponent), typeDiscriminator: nameof(ComponentType.Maven))]
-[JsonDerivedType(typeof(NpmComponent), typeDiscriminator: nameof(ComponentType.Npm))]
-[JsonDerivedType(typeof(NuGetComponent), typeDiscriminator: nameof(ComponentType.NuGet))]
-[JsonDerivedType(typeof(OtherComponent), typeDiscriminator: nameof(ComponentType.Other))]
-[JsonDerivedType(typeof(PipComponent), typeDiscriminator: nameof(ComponentType.Pip))]
-[JsonDerivedType(typeof(PodComponent), typeDiscriminator: nameof(ComponentType.Pod))]
-[JsonDerivedType(typeof(RubyGemsComponent), typeDiscriminator: nameof(ComponentType.RubyGems))]
-[JsonDerivedType(typeof(SpdxComponent), typeDiscriminator: nameof(ComponentType.Spdx))]
-[JsonDerivedType(typeof(SwiftComponent), typeDiscriminator: nameof(ComponentType.Swift))]
-[JsonDerivedType(typeof(VcpkgComponent), typeDiscriminator: nameof(ComponentType.Vcpkg))]
+[SystemTextJson.JsonConverter(typeof(TypedComponentSystemTextJsonConverter))] // System.Text.Json
 public abstract class TypedComponent
 {
     [JsonIgnore] // Newtonsoft.Json
-    [System.Text.Json.Serialization.JsonIgnore] // System.Text.Json
+    [SystemTextJson.JsonIgnore] // System.Text.Json
     private string id;
 
     internal TypedComponent()
@@ -50,19 +31,19 @@ internal TypedComponent()
     /// <summary>Gets the type of the component, must be well known.</summary>
     [JsonConverter(typeof(StringEnumConverter))] // Newtonsoft.Json
     [JsonProperty("type", Order = int.MinValue)] // Newtonsoft.Json
-    [System.Text.Json.Serialization.JsonIgnore] // System.Text.Json - type is handled by [JsonPolymorphic] discriminator
+    [SystemTextJson.JsonIgnore] // System.Text.Json - type is handled by TypedComponentSystemTextJsonConverter
     public abstract ComponentType Type { get; }
 
     /// <summary>Gets the id of the component.</summary>
     [JsonProperty("id")] // Newtonsoft.Json
-    [JsonPropertyName("id")] // System.Text.Json
+    [SystemTextJson.JsonPropertyName("id")] // System.Text.Json
     public string Id => this.id ??= this.ComputeId();
 
-    [JsonPropertyName("packageUrl")]
+    [SystemTextJson.JsonPropertyName("packageUrl")]
     public virtual PackageURL PackageUrl { get; }
 
     [JsonIgnore] // Newtonsoft.Json
-    [System.Text.Json.Serialization.JsonIgnore] // System.Text.Json
+    [SystemTextJson.JsonIgnore] // System.Text.Json
     internal string DebuggerDisplay => $"{this.Id}";
 
     protected string ValidateRequiredInput(string input, string fieldName, string componentType)

src/Microsoft.ComponentDetection.Orchestrator/Services/DetectorProcessingService.cs

@@ -31,15 +31,18 @@ public class DetectorProcessingService : IDetectorProcessingService
     private readonly IObservableDirectoryWalkerFactory scanner;
     private readonly ILogger<DetectorProcessingService> logger;
     private readonly IExperimentService experimentService;
+    private readonly IAnsiConsole console;
 
     public DetectorProcessingService(
         IObservableDirectoryWalkerFactory scanner,
         IExperimentService experimentService,
-        ILogger<DetectorProcessingService> logger)
+        ILogger<DetectorProcessingService> logger,
+        IAnsiConsole console = null)
     {
         this.scanner = scanner;
         this.experimentService = experimentService;
         this.logger = logger;
+        this.console = console ?? AnsiConsole.Console;
     }
 
     /// <inheritdoc/>
@@ -384,7 +387,7 @@ private void LogTabularOutput(ConcurrentDictionary<string, DetectorRunResult> pr
             providerElapsedTime.Sum(x => x.Value.ComponentsFoundCount).ToString(),
             providerElapsedTime.Sum(x => x.Value.ExplicitlyReferencedComponentCount).ToString());
 
-        AnsiConsole.Write(table);
+        this.console.Write(table);
 
         var tsf = new TabularStringFormat(
         [