Added support for LocalDate/LocalDateTime/LocalTime to Strawberry Shake (#8007)

Author: glen-84

src/StrawberryShake/Client/src/Core/Serialization/BuiltInScalarNames.cs

@@ -21,6 +21,9 @@ public static class BuiltInScalarNames
     public const string Any = nameof(Any);
     public const string DateTime = nameof(DateTime);
     public const string Date = nameof(Date);
+    public const string LocalDate = nameof(LocalDate);
+    public const string LocalDateTime = nameof(LocalDateTime);
+    public const string LocalTime = nameof(LocalTime);
     public const string TimeSpan = nameof(TimeSpan);
     public const string Name = nameof(Name);
 }

src/StrawberryShake/Client/src/Core/Serialization/LocalDateSerializer.cs

@@ -0,0 +1,54 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+
+namespace StrawberryShake.Serialization;
+
+/// <summary>
+/// This serializer handles <c>LocalDate</c> scalars.
+/// </summary>
+public class LocalDateSerializer : ScalarSerializer<string, DateOnly>
+{
+    private const string _localFormat = "yyyy-MM-dd";
+
+    public LocalDateSerializer(string typeName = BuiltInScalarNames.LocalDate)
+        : base(typeName)
+    {
+    }
+
+    public override DateOnly Parse(string serializedValue)
+    {
+        if (TryDeserializeFromString(serializedValue, out var date))
+        {
+            return date.Value;
+        }
+
+        throw ThrowHelper.LocalDateSerializer_InvalidFormat(serializedValue);
+    }
+
+    protected override string Format(DateOnly runtimeValue)
+    {
+        return runtimeValue.ToString(
+            _localFormat,
+            CultureInfo.InvariantCulture);
+    }
+
+    private static bool TryDeserializeFromString(
+        string? serialized,
+        [NotNullWhen(true)] out DateOnly? value)
+    {
+        if (serialized is not null
+            && DateOnly.TryParseExact(
+                serialized,
+                _localFormat,
+                CultureInfo.InvariantCulture,
+                DateTimeStyles.None,
+                out var date))
+        {
+            value = date;
+            return true;
+        }
+
+        value = null;
+        return false;
+    }
+}

src/StrawberryShake/Client/src/Core/Serialization/LocalDateTimeSerializer.cs

@@ -0,0 +1,54 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+
+namespace StrawberryShake.Serialization;
+
+/// <summary>
+/// This serializer handles <c>LocalDateTime</c> scalars.
+/// </summary>
+public class LocalDateTimeSerializer : ScalarSerializer<string, DateTime>
+{
+    private const string _localFormat = "yyyy-MM-ddTHH\\:mm\\:ss";
+
+    public LocalDateTimeSerializer(string typeName = BuiltInScalarNames.LocalDateTime)
+        : base(typeName)
+    {
+    }
+
+    public override DateTime Parse(string serializedValue)
+    {
+        if (TryDeserializeFromString(serializedValue, out var dateTime))
+        {
+            return dateTime.Value;
+        }
+
+        throw ThrowHelper.LocalDateTimeSerializer_InvalidFormat(serializedValue);
+    }
+
+    protected override string Format(DateTime runtimeValue)
+    {
+        return runtimeValue.ToString(
+            _localFormat,
+            CultureInfo.InvariantCulture);
+    }
+
+    private static bool TryDeserializeFromString(
+        string? serialized,
+        [NotNullWhen(true)] out DateTime? value)
+    {
+        if (serialized is not null
+            && DateTime.TryParseExact(
+                serialized,
+                _localFormat,
+                CultureInfo.InvariantCulture,
+                DateTimeStyles.None,
+                out var dt))
+        {
+            value = dt;
+            return true;
+        }
+
+        value = null;
+        return false;
+    }
+}

src/StrawberryShake/Client/src/Core/Serialization/LocalTimeSerializer.cs

@@ -0,0 +1,54 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+
+namespace StrawberryShake.Serialization;
+
+/// <summary>
+/// This serializer handles <c>LocalTime</c> scalars.
+/// </summary>
+public class LocalTimeSerializer : ScalarSerializer<string, TimeOnly>
+{
+    private const string _localFormat = "HH:mm:ss";
+
+    public LocalTimeSerializer(string typeName = BuiltInScalarNames.LocalTime)
+        : base(typeName)
+    {
+    }
+
+    public override TimeOnly Parse(string serializedValue)
+    {
+        if (TryDeserializeFromString(serializedValue, out var time))
+        {
+            return time.Value;
+        }
+
+        throw ThrowHelper.LocalTimeSerializer_InvalidFormat(serializedValue);
+    }
+
+    protected override string Format(TimeOnly runtimeValue)
+    {
+        return runtimeValue.ToString(
+            _localFormat,
+            CultureInfo.InvariantCulture);
+    }
+
+    private static bool TryDeserializeFromString(
+        string? serialized,
+        [NotNullWhen(true)] out TimeOnly? value)
+    {
+        if (serialized is not null
+            && TimeOnly.TryParseExact(
+                serialized,
+                _localFormat,
+                CultureInfo.InvariantCulture,
+                DateTimeStyles.None,
+                out var time))
+        {
+            value = time;
+            return true;
+        }
+
+        value = null;
+        return false;
+    }
+}

src/StrawberryShake/Client/src/Core/ThrowHelper.cs

@@ -34,6 +34,33 @@ internal static GraphQLClientException DateSerializer_InvalidFormat(
                     { "serializedValue", serializedValue },
             }));
 
+    internal static GraphQLClientException LocalDateSerializer_InvalidFormat(
+        string serializedValue) =>
+        new(new ClientError(
+            "The serialized format for LocalDate must be `yyyy-MM-dd`.",
+            extensions: new Dictionary<string, object?>
+            {
+                { "serializedValue", serializedValue },
+            }));
+
+    internal static GraphQLClientException LocalDateTimeSerializer_InvalidFormat(
+        string serializedValue) =>
+        new(new ClientError(
+            "The serialized format for LocalDateTime must be `yyyy-MM-ddTHH:mm:ss`.",
+            extensions: new Dictionary<string, object?>
+            {
+                { "serializedValue", serializedValue },
+            }));
+
+    internal static GraphQLClientException LocalTimeSerializer_InvalidFormat(
+        string serializedValue) =>
+        new(new ClientError(
+            "The serialized format for LocalTime must be `HH:mm:ss`.",
+            extensions: new Dictionary<string, object?>
+            {
+                { "serializedValue", serializedValue },
+            }));
+
     internal static GraphQLClientException UrlFormatter_CouldNotParseUri(string value) =>
         new(new ClientError(
             $"The URL serializer could not parse value{value}. Invalid format. "));

src/StrawberryShake/Client/test/Core.Tests/Serialization/LocalDateSerializerTests.cs

@@ -0,0 +1,87 @@
+namespace StrawberryShake.Serialization;
+
+public class LocalDateSerializerTests
+{
+    private LocalDateSerializer Serializer { get; } = new();
+
+    private LocalDateSerializer CustomSerializer { get; } = new("Abc");
+
+    [Fact]
+    public void Parse()
+    {
+        // arrange
+        var value = "2011-08-30";
+
+        // act
+        var result = Serializer.Parse(value);
+
+        // assert
+        Assert.Equal(2011, result.Year);
+        Assert.Equal(8, result.Month);
+        Assert.Equal(30, result.Day);
+    }
+
+    [Fact]
+    public void Format_Null()
+    {
+        // arrange
+
+        // act
+        var result = Serializer.Format(null);
+
+        // assert
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void Format_Value()
+    {
+        // arrange
+        var value = new DateOnly(2011, 8, 30);
+
+        // act
+        var result = Serializer.Format(value);
+
+        // assert
+        Assert.Equal("2011-08-30", result);
+    }
+
+    [Fact]
+    public void Format_Exception()
+    {
+        // arrange
+        var value = 1;
+
+        // act
+        void Action() => Serializer.Format(value);
+
+        // assert
+        Assert.Equal(
+            "SS0007",
+            Assert.Throws<GraphQLClientException>(Action).Errors.Single().Code);
+    }
+
+    [Fact]
+    public void TypeName_Default()
+    {
+        // arrange
+
+        // act
+        var typeName = Serializer.TypeName;
+
+        // assert
+        Assert.Equal("LocalDate", typeName);
+    }
+
+    [Fact]
+    public void TypeName_Custom()
+    {
+        // arrange
+
+        // act
+        var typeName = CustomSerializer.TypeName;
+
+        // assert
+        Assert.Equal("Abc", typeName);
+    }
+}

src/StrawberryShake/Client/test/Core.Tests/Serialization/LocalDateTimeSerializerTests.cs

@@ -0,0 +1,90 @@
+namespace StrawberryShake.Serialization;
+
+public class LocalDateTimeSerializerTests
+{
+    private LocalDateTimeSerializer Serializer { get; } = new();
+
+    private LocalDateTimeSerializer CustomSerializer { get; } = new("Abc");
+
+    [Fact]
+    public void Parse()
+    {
+        // arrange
+        var value = "2011-08-30T13:22:53";
+
+        // act
+        var result = Serializer.Parse(value);
+
+        // assert
+        Assert.Equal(2011, result.Year);
+        Assert.Equal(8, result.Month);
+        Assert.Equal(30, result.Day);
+        Assert.Equal(13, result.Hour);
+        Assert.Equal(22, result.Minute);
+        Assert.Equal(53, result.Second);
+    }
+
+    [Fact]
+    public void Format_Null()
+    {
+        // arrange
+
+        // act
+        var result = Serializer.Format(null);
+
+        // assert
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void Format_Value()
+    {
+        // arrange
+        var value = new DateTime(2011, 8, 30, 13, 22, 53, 108);
+
+        // act
+        var result = Serializer.Format(value);
+
+        // assert
+        Assert.Equal("2011-08-30T13:22:53", result);
+    }
+
+    [Fact]
+    public void Format_Exception()
+    {
+        // arrange
+        var value = 1;
+
+        // act
+        void Action() => Serializer.Format(value);
+
+        // assert
+        Assert.Equal(
+            "SS0007",
+            Assert.Throws<GraphQLClientException>(Action).Errors.Single().Code);
+    }
+
+    [Fact]
+    public void TypeName_Default()
+    {
+        // arrange
+
+        // act
+        var typeName = Serializer.TypeName;
+
+        // assert
+        Assert.Equal("LocalDateTime", typeName);
+    }
+
+    [Fact]
+    public void TypeName_Custom()
+    {
+        // arrange
+
+        // act
+        var typeName = CustomSerializer.TypeName;
+
+        // assert
+        Assert.Equal("Abc", typeName);
+    }
+}