Wrap primitive/primitive collection return types in an IGraphQLObject wrapper

This change refactors how the "primitive" (i.e. string, int, bool, etc.)
return types of operations are handled. Such operations will now have
their return types wrapped in either a `GraphQLValue<T>` or
`GraphQLCollection<T>` wrapper class, which both satisfy the
`IGraphQLObject` constraint required by the `GraphQueryBuilder`.

type: feature
scope: sourcegen, graphql, parser

Author: nozzlegear

ShopifySharp.GraphQL.Parser/AstNodeMapper.fs

@@ -39,6 +39,7 @@ module AstNodeMapper =
         | NonNullableType valueType -> unwrapFieldType valueType
         | CollectionType collectionType -> unwrapFieldType collectionType
 
+    /// Maps a field type to a string representation.
     let rec mapFieldTypeToString (isNamedType: NamedType -> bool) assumeNullability (valueType: FieldType) (collectionHandling: FieldTypeCollectionHandling) =
         let maybeWriteNullability isNullable fieldStr =
             fieldStr + (if isNullable then "?" else "")
@@ -67,6 +68,40 @@ module AstNodeMapper =
 
         unwrapType false valueType
 
+    /// <summary>
+    /// Maps a field type to a string representation, wrapping primitives in <see cref="GraphQLValue<T>" /> or
+    /// <see cref="GraphQLCollection<T>" /> to ensure the type implements IGraphQLObject. Used for operation return types.
+    /// </summary>
+    let rec mapFieldTypeToStringWithPrimitiveWrapper (isNamedType: NamedType -> bool) assumeNullability (valueType: FieldType) =
+        let rec isCollectionType = function
+            | CollectionType _ -> true
+            | NonNullableType type' -> isCollectionType type'
+            | NullableType type' -> isCollectionType type'
+            | _ -> false
+
+        let rec isPrimitiveType = function
+            | ValueType valueType ->
+                match valueType with
+                | FieldValueType.GraphObjectType _ -> false
+                | _ -> true
+            | NonNullableType type' -> isPrimitiveType type'
+            | NullableType type' -> isPrimitiveType type'
+            | CollectionType type' -> isPrimitiveType type'
+
+        // Determine if we need to wrap this type
+        match valueType with
+        | _ when isCollectionType valueType && isPrimitiveType valueType ->
+            // It's a collection of primitives, wrap it in GraphQLCollection<T>
+            let elementType = mapFieldTypeToString isNamedType false valueType FieldTypeCollectionHandling.UnwrapCollection
+            $"GraphQLCollection<{elementType}>"
+        | _ when isPrimitiveType valueType ->
+            // It's a single primitive, wrap it in GraphQLValue<T>
+            let primitiveType = mapFieldTypeToString isNamedType false valueType FieldTypeCollectionHandling.KeepCollection
+            $"GraphQLValue<{primitiveType}>"
+        | _ ->
+            // It's GraphQL object, no wrapper needed. Return the base type string without a wrapper
+            mapFieldTypeToString isNamedType assumeNullability valueType FieldTypeCollectionHandling.KeepCollection
+
     let rec private mapGraphTypeToName (fieldType: GraphQLType): string =
         match fieldType with
         | :? GraphQLNamedType as namedType ->

ShopifySharp.GraphQL.Parser/QueryBuilderWriter.fs

@@ -158,7 +158,8 @@ module rec QueryBuilderWriter =
                     | ReturnType.VisitedType visitedTypes ->
                         visitedTypes.Name
                     | ReturnType.FieldType fieldType ->
-                        AstNodeMapper.mapFieldTypeToString context.IsNamedType context.AssumeNullability fieldType FieldTypeCollectionHandling.KeepCollection
+                        // Use the wrapper function to ensure primitives are wrapped in GraphQLValue<T> or GraphQLCollection<T>
+                        AstNodeMapper.mapFieldTypeToStringWithPrimitiveWrapper context.IsNamedType context.AssumeNullability fieldType
                 | x -> x.Name
 
             // Fully qualify class names that might collide with System types

ShopifySharp/Entities/GraphQL/Generated/QueryBuilders/ArticleTagsQueryBuilder.cs

@@ -9,7 +9,7 @@ namespace ShopifySharp.Services.Generated;
 using ShopifySharp.Infrastructure;
 using ShopifySharp.Infrastructure.Serialization.Json;
 
-public class ArticleTagsQueryBuilder() : GraphQueryBuilder<ICollection<string>?>("query articleTags")
+public class ArticleTagsQueryBuilder() : GraphQueryBuilder<GraphQLCollection<string>>("query articleTags")
 {
     public ArticleTagsQueryBuilder AddReturnValue()
     {
@@ -28,4 +28,4 @@ public ArticleTagsQueryBuilder AddArgumentSort(ArticleTagSort? sort)
         AddArgument("sort", sort);
         return this;
     }
-}
+}

ShopifySharp/Entities/GraphQL/GraphQLCollection.cs

@@ -0,0 +1,13 @@
+namespace ShopifySharp.GraphQL;
+
+using System.Collections.Generic;
+
+/// <summary>
+/// Wraps a collection of "primitive" values (i.e. strings, numbers, bools) returned from a GraphQL query or mutation.
+/// This allows collection return types to implement IGraphQLObject while maintaining type safety.
+/// </summary>
+/// <typeparam name="T">The type of the collection's elements</typeparam>
+public record GraphQLCollection<T> : IGraphQLObject
+{
+    public ICollection<T> Value { get; init; } = new List<T>();
+}

ShopifySharp/Entities/GraphQL/GraphQLValue.cs

@@ -0,0 +1,31 @@
+namespace ShopifySharp.GraphQL;
+
+using System.Collections.Generic;
+
+/// <summary>
+/// Wraps a "primitive" value (i.e. string, int, bool) returned from a GraphQL query or mutation.
+/// This allows primitive return types to implement IGraphQLObject while maintaining type safety.
+/// </summary>
+/// <typeparam name="T">The underlying primitive type (string, int, bool, etc.)</typeparam>
+public record GraphQLValue<T> : IGraphQLObject
+{
+    /// <summary>
+    /// The underlying primitive value.
+    /// </summary>
+    public T Value { get; init; }
+
+    public GraphQLValue(T value)
+    {
+        Value = value;
+    }
+
+    /// <summary>
+    /// Implicit conversion to the underlying type.
+    /// </summary>
+    public static implicit operator T(GraphQLValue<T> wrapper) => wrapper.Value;
+
+    /// <summary>
+    /// Implicit conversion from the underlying type.
+    /// </summary>
+    public static implicit operator GraphQLValue<T>(T value) => new(value);
+}