Support DateOnly / TimeOnly in DynamoDBContext (#3677)

* Add support for DateOnly / TimeOnly in DynamoDbContext
* Add test that saved DateOnly is successully read as DateTime
* Add fallback to non-exact format during parsing
* Add DevConfig changelog

Author: Dreamescaper

generator/.DevConfigs/3C7AB270-F926-4FBE-ABA6-B849BF35C377.json

@@ -0,0 +1,11 @@
+{
+    "services": [
+        {
+            "serviceName": "DynamoDBv2",
+            "type": "patch",
+            "changeLogMessages": [
+                "Add Support for DateOnly and TimeOnly in DynamoDB high level libraries. This support is available in .NET 8 and above."
+            ]
+        }
+    ]
+}

sdk/src/Services/DynamoDBv2/Custom/Conversion/DynamoDBEntryConversion.cs

@@ -322,7 +322,7 @@ public bool TryConvertFromEntry([DynamicallyAccessedMembers(DynamicallyAccessedM
             return converter.TryFromEntry(entry, outputType, out value);
         }
 
-#endregion
+        #endregion
 
         #region Internal members
 
@@ -378,7 +378,7 @@ internal PrimitiveList ItemsToPrimitiveList(IEnumerable items)
             return pl;
         }
 
-#endregion
+        #endregion
 
         #region Private members
 
@@ -413,6 +413,10 @@ private void SetV1Converters()
             AddConverter(new BoolConverterV1());
             AddConverter(new PrimitiveCollectionConverterV1());
             AddConverter(new DictionaryConverterV1());
+#if NET8_0_OR_GREATER
+            AddConverter(new DateOnlyConverterV1());
+            AddConverter(new TimeOnlyConverterV1());
+#endif
         }
 
         private void SetV2Converters()
@@ -438,6 +442,10 @@ private void SetV2Converters()
             AddConverter(new EnumConverterV2());
             AddConverter(new BoolConverterV2());
             AddConverter(new CollectionConverterV2());
+#if NET8_0_OR_GREATER
+            AddConverter(new DateOnlyConverterV2());
+            AddConverter(new TimeOnlyConverterV2());
+#endif
         }
 
         // Converts items to Primitives.

sdk/src/Services/DynamoDBv2/Custom/Conversion/SchemaV1.cs

@@ -36,7 +36,7 @@ internal class ByteConverterV1 : Converter<byte>
     {
         public override IEnumerable<Type> GetTargetTypes()
         {
-            return new[] { typeof(byte), typeof(Nullable<byte>) }; 
+            return new[] { typeof(byte), typeof(Nullable<byte>) };
         }
 
         protected override bool TryTo(byte value, out Primitive p)
@@ -444,7 +444,53 @@ private static Enum ConvertEnum(string s, Type targetType)
         }
     }
 
-#endregion
+#if NET8_0_OR_GREATER
+    internal class DateOnlyConverterV1 : Converter<DateOnly>
+    {
+        private const string DateOnlyFormat = "yyyy-MM-dd";
+
+        public override IEnumerable<Type> GetTargetTypes()
+        {
+            return new[] { typeof(DateOnly), typeof(DateOnly?) };
+        }
+
+        protected override bool TryTo(DateOnly value, out Primitive p)
+        {
+            p = new Primitive(value.ToString(DateOnlyFormat, CultureInfo.InvariantCulture), DynamoDBEntryType.String);
+            return true;
+        }
+
+        protected override bool TryFrom(Primitive p, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicConstructors)] Type targetType, out DateOnly result)
+        {
+            return DateOnly.TryParseExact(p.StringValue, DateOnlyFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out result)
+                || DateOnly.TryParse(p.StringValue, CultureInfo.InvariantCulture, out result);
+        }
+    }
+
+    internal class TimeOnlyConverterV1 : Converter<TimeOnly>
+    {
+        private const string TimeOnlyFormat = "HH:mm:ss.fff";
+
+        public override IEnumerable<Type> GetTargetTypes()
+        {
+            return new[] { typeof(TimeOnly), typeof(TimeOnly?) };
+        }
+
+        protected override bool TryTo(TimeOnly value, out Primitive p)
+        {
+            p = new Primitive(value.ToString(TimeOnlyFormat, CultureInfo.InvariantCulture), DynamoDBEntryType.String);
+            return true;
+        }
+
+        protected override bool TryFrom(Primitive p, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicConstructors)] Type targetType, out TimeOnly result)
+        {
+            return TimeOnly.TryParseExact(p.StringValue, TimeOnlyFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out result)
+                || TimeOnly.TryParse(p.StringValue, CultureInfo.InvariantCulture, out result);
+        }
+    }
+#endif
+
+    #endregion
 
     #region Converters supporting reading V2 DDB items, but writing V1 items
 
@@ -569,5 +615,5 @@ public override bool TryTo(object value, out Document d)
         }
     }
 
-#endregion
+    #endregion
 }

sdk/src/Services/DynamoDBv2/Custom/Conversion/SchemaV2.cs

@@ -86,6 +86,14 @@ internal class DictionaryConverterV2 : DictionaryConverterV1
     internal class EnumConverterV2 : EnumConverterV1
     { }
 
+#if NET8_0_OR_GREATER
+    internal class DateOnlyConverterV2 : DateOnlyConverterV1
+    { }
+
+    internal class TimeOnlyConverterV2 : TimeOnlyConverterV1
+    { }
+#endif
+
     #endregion
 
     /// <summary>

sdk/test/Services/DynamoDBv2/UnitTests/Custom/DynamoDBEntryConversionTests.cs

@@ -244,6 +244,59 @@ public void V2_ConvertToEntry_HashSet()
             Assert.AreEqual(expectedList, entry);
         }
 
+#if NET8_0_OR_GREATER
+        [DataTestMethod]
+        [DynamicData((nameof(DynamoDBEntryConversions)))]
+        public void ConvertToEntry_DateOnly(DynamoDBEntryConversion conversion)
+        {
+            var dateOnly = new DateOnly(2024, 07, 03);
+            var entry = conversion.ConvertToEntry(dateOnly);
+            Assert.AreEqual(new Primitive("2024-07-03", false), entry);
+        }
+
+        [DataTestMethod]
+        [DynamicData((nameof(DynamoDBEntryConversions)))]
+        public void ConvertFromEntry_DateOnly(DynamoDBEntryConversion conversion)
+        {
+            var entry = new Primitive("2024-07-03", false);
+            var actualDateOnly = conversion.ConvertFromEntry<DateOnly>(entry);
+            var expectedDateOnly = new DateOnly(2024, 07, 03);
+            Assert.AreEqual(expectedDateOnly, actualDateOnly);
+        }
+
+        [DataTestMethod]
+        [DynamicData((nameof(DynamoDBEntryConversions)))]
+        public void ConvertToEntry_TimeOnly(DynamoDBEntryConversion conversion)
+        {
+            var timeOnly = new TimeOnly(18, 31, 56, 123);
+            var entry = conversion.ConvertToEntry(timeOnly);
+            Assert.AreEqual(new Primitive("18:31:56.123", false), entry);
+        }
+
+        [DataTestMethod]
+        [DynamicData((nameof(DynamoDBEntryConversions)))]
+        public void ConvertFromEntry_TimeOnly(DynamoDBEntryConversion conversion)
+        {
+            var entry = new Primitive("18:31:56.123", false);
+            var actualTimeOnly = conversion.ConvertFromEntry<TimeOnly>(entry);
+            var expectedTimeOnly = new TimeOnly(18, 31, 56, 123);
+            Assert.AreEqual(expectedTimeOnly, actualTimeOnly);
+        }
+
+        [DataTestMethod]
+        [DynamicData((nameof(DynamoDBEntryConversions)))]
+        public void ConvertFromEntry_ShouldBeAbleToReadDateOnlyAsDateTime(DynamoDBEntryConversion conversion)
+        {
+            var dateOnly = new DateOnly(2024, 07, 03);
+            var entry = conversion.ConvertToEntry(dateOnly);
+
+            var actualDateTime = conversion.ConvertFromEntry<DateTime>(entry);
+            var expectedDateTime = new DateTime(2024, 07, 03, 0, 0, 0, DateTimeKind.Utc);
+
+            Assert.AreEqual(expectedDateTime, actualDateTime);
+        }
+#endif
+
         private void AssertAllConvertersAreRegistered(DynamoDBEntryConversion conversion, string suffix)
         {
             var converters = GetConverters(suffix);