Replace polymorphic json attributes with a custom GraphUnionTypeConverter json converter

This change fixes a bug which prevented the deserialization of union types into their union cases due to the internal types used by ShopifySharp to hold the union case values (e.g. `CommentEventEmbedCustomer`, `CommentEventEmbedOrder`). The polymorphic attributes weren't able to determine how to deserialize into and out of those internal types (due to the `.Value` property on those internal types holding the actual value of the union case).

To fix this, the GraphUnionTypeConverter has been introduced and replaces the `JsonDerivedType` and `JsonPolymorphic` attributes. It handles deserialization and serialization of the union type, moving values into and out of the internal wrappers behind the scenes. It may even stand to reason that we don't need the internal wrappers at all with this converter – something to explore in the future.

Fixes #1213

type: fix
scope: generated-graphql

Author: codebyhuman

ShopifySharp.GraphQL.Parser/Writer.fs

@@ -220,6 +220,8 @@ let private writeNamespaceAndUsings (writer: Writer) : ValueTask =
         do! NewLine
         do! "using System.Collections.Generic;"
         do! NewLine
+        do! "using ShopifySharp.Infrastructure.Serialization.Json;"
+        do! NewLine
     }
 
 let private writeSummary  indentation (summary: string[]) writer : ValueTask =
@@ -271,15 +273,10 @@ let private writeDateOnlyJsonConverterAttribute (fieldType: FieldType) writer: V
     }
 
 
-let private writeJsonDerivedTypeAttributes unionTypeName (typeNames: string[]) writer: ValueTask =
+let private writeGraphUnionTypeConverterAttribute unionTypeName writer: ValueTask =
     pipeWriter writer {
-        do! "[JsonPolymorphic(TypeDiscriminatorPropertyName = \"__typename\")]"
+        do! $"[JsonConverter(typeof(GraphUnionTypeConverter<{unionTypeName}>))]"
         do! NewLine
-
-        for typeName in typeNames do
-            let wrapperTypeName = toUnionCaseWrapperName unionTypeName typeName
-            do! $"""[JsonDerivedType(typeof({wrapperTypeName}), typeDiscriminator: "{typeName}")]"""
-            do! NewLine
     }
 
 let private writeJsonDerivedTypeAttributes2 interfaceName (classNames: string[]) writer: ValueTask =
@@ -559,7 +556,7 @@ let private writeUnionType (unionType: UnionType) (_: IParsedContext) (writer: W
     pipeWriter writer {
         yield! writeSummary Outdented unionType.XmlSummary
         yield! writeDeprecationAttribute Outdented unionType.Deprecation
-        yield! writeJsonDerivedTypeAttributes unionType.Name unionType.Types
+        yield! writeGraphUnionTypeConverterAttribute unionType.Name
 
         do! $"public record {unionType.Name}: GraphQLObject<{unionType.Name}>, IGraphQLUnionType"
 

ShopifySharp/Infrastructure/Serialization/Json/GraphUnionTypeConverter.cs

@@ -0,0 +1,105 @@
+#nullable enable
+using System;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace ShopifySharp.Infrastructure.Serialization.Json;
+
+/// <summary>
+/// A JSON converter for GraphQL union base types that handles polymorphic deserialization
+/// by directly deserializing to concrete types that inherit from the union base.
+/// </summary>
+/// <typeparam name="TUnion">The union base type (e.g., CustomerPaymentInstrument)</typeparam>
+internal class GraphUnionTypeConverter<TUnion> : JsonConverter<TUnion>
+    where TUnion : class
+{
+    private static IJsonSerializer ResolveSerializer(JsonSerializerOptions options, IServiceProvider? serviceProvider = null)
+    {
+        return InternalServiceResolver.GetServiceOrDefault<IJsonSerializer>(serviceProvider, () => new SystemJsonSerializer(options));
+    }
+
+    public override TUnion? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        using var doc = JsonDocument.ParseValue(ref reader);
+        var rootElement = new SystemJsonElement(doc.RootElement, doc);
+
+        // Get __typename to determine the correct concrete type
+        if (!rootElement.TryGetProperty("__typename", out var typenameElement))
+            return null;
+
+        if (typenameElement.ValueType != JsonValueType.String)
+            return null;
+
+        var typename = ((JsonElement) typenameElement.GetRawObject()).GetString();
+        if (string.IsNullOrEmpty(typename))
+            return null;
+
+        // Find the wrapper type for this union type and typename
+        var wrapperTypeName = $"{typeToConvert.Name}{typename}";
+        var wrapperType = typeToConvert.Assembly.GetTypes()
+            .FirstOrDefault(t => t.Name == wrapperTypeName && t.IsSubclassOf(typeToConvert));
+
+        if (wrapperType == null)
+            return null;
+
+        // Get the Value property type (the concrete type we need to deserialize to)
+        var valueProperty = wrapperType.GetProperty("Value");
+        if (valueProperty == null)
+            return null;
+
+        var concreteType = valueProperty.PropertyType;
+
+        // Create a new options instance without this converter to avoid infinite recursion
+        var newOptions = new JsonSerializerOptions(options);
+        var convertersToRemove = newOptions.Converters
+            .Where(c => c.GetType().IsGenericType &&
+                c.GetType().GetGenericTypeDefinition() == typeof(GraphUnionTypeConverter<>))
+            .ToList();
+
+        foreach (var converter in convertersToRemove)
+            newOptions.Converters.Remove(converter);
+
+        // Deserialize to the concrete type
+        var serializer = ResolveSerializer(newOptions);
+        var concreteObject = serializer.Deserialize(rootElement, concreteType);
+        //JsonSerializer.Deserialize(rootElement.GetRawText(), concreteType, newOptions);
+        if (concreteObject == null)
+            return null;
+
+        // Create the wrapper using its constructor
+        var constructor = wrapperType.GetConstructor([concreteType]);
+        if (constructor == null)
+            return null;
+
+        return (TUnion)constructor.Invoke([concreteObject]);
+    }
+
+    public override void Write(Utf8JsonWriter writer, TUnion? value, JsonSerializerOptions options)
+    {
+        if (value == null)
+        {
+            writer.WriteNullValue();
+            return;
+        }
+
+        var serializer = ResolveSerializer(options);
+
+        // Get the Value property from the wrapper and serialize it
+        var valueProperty = value.GetType().GetProperty("Value");
+        if (valueProperty != null)
+        {
+            var wrappedValue = valueProperty.GetValue(value);
+            if (wrappedValue != null)
+            {
+                serializer.Serialize(wrappedValue);
+                //JsonSerializer.Serialize(writer, wrappedValue, options);
+                return;
+            }
+        }
+
+        // Fallback to direct serialization
+        //JsonSerializer.Serialize(writer, value, value.GetType(), options);
+        serializer.Serialize(value);
+    }
+}