From 2fd8ee4c5c0ff61f5d64a752ae3b07dccfa99b9c Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Fri, 13 Mar 2026 11:27:28 -0700 Subject: [PATCH 1/7] Add support for parsing DateTime values --- src/Core/Services/ExecutionHelper.cs | 65 ++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 79bdc6af9c..3b896ca993 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -395,9 +395,74 @@ private static bool TryGetPropertyFromParent( SupportedHotChocolateTypes.SINGLE_TYPE => value is IntValueNode intValueNode ? intValueNode.ToSingle() : ((FloatValueNode)value).ToSingle(), SupportedHotChocolateTypes.FLOAT_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDouble() : ((FloatValueNode)value).ToDouble(), SupportedHotChocolateTypes.DECIMAL_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDecimal() : ((FloatValueNode)value).ToDecimal(), + SupportedHotChocolateTypes.DATETIME_TYPE => ParseDateTimeValue(value.Value), + SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE => ParseDateTimeOffsetValue(value.Value), SupportedHotChocolateTypes.UUID_TYPE => Guid.TryParse(value.Value!.ToString(), out Guid guidValue) ? guidValue : value.Value, _ => value.Value }; + + static object? ParseDateTimeValue(object? raw) + { + if (raw is null) + { + return null; + } + + if (raw is DateTime dt) + { + return dt; + } + + if (raw is DateTimeOffset dto) + { + return dto.UtcDateTime; + } + + if (raw is string s) + { + // HotChocolate DateTime inputs are supplied as strings; parse them so DB providers + // (notably PostgreSQL) receive a typed parameter instead of text. + if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) + { + return parsedDto.UtcDateTime; + } + + if (DateTime.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTime parsedDt)) + { + return parsedDt; + } + } + + return raw; + } + + static object? ParseDateTimeOffsetValue(object? raw) + { + if (raw is null) + { + return null; + } + + if (raw is DateTimeOffset dto) + { + return dto; + } + + if (raw is DateTime dt) + { + return new DateTimeOffset(dt); + } + + if (raw is string s) + { + if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) + { + return parsedDto; + } + } + + return raw; + } } /// From 135897540a418014a0b8d67e964f67ffc62c1c62 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Tue, 21 Apr 2026 08:52:32 -0700 Subject: [PATCH 2/7] Update parsing to reflect that only support (for now) is for DATETIME_TYPE and ensure that timezone is configured to UTC for standardization --- src/Core/Resolvers/PostgreSqlExecutor.cs | 5 +++ src/Core/Services/ExecutionHelper.cs | 51 ++++++------------------ 2 files changed, 18 insertions(+), 38 deletions(-) diff --git a/src/Core/Resolvers/PostgreSqlExecutor.cs b/src/Core/Resolvers/PostgreSqlExecutor.cs index 70fa0f1079..3c525329c7 100644 --- a/src/Core/Resolvers/PostgreSqlExecutor.cs +++ b/src/Core/Resolvers/PostgreSqlExecutor.cs @@ -84,6 +84,11 @@ private void ConfigurePostgreSqlQueryExecutor() { NpgsqlConnectionStringBuilder builder = new(dataSource.ConnectionString); + if (string.IsNullOrEmpty(builder.Timezone)) + { + builder.Timezone = "UTC"; + } + if (_runtimeConfigProvider.IsLateConfigured) { builder.SslMode = SslMode.VerifyFull; diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 3b896ca993..f3d605e36c 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -63,7 +63,7 @@ public async ValueTask ExecuteQueryAsync(IMiddlewareContext context) IQueryEngine queryEngine = _queryEngineFactory.GetQueryEngine(ds.DatabaseType); IDictionary parameters = GetParametersFromContext(context); - + if (context.Selection.Type.IsListType()) { Tuple, IMetadata?> result = @@ -396,7 +396,6 @@ private static bool TryGetPropertyFromParent( SupportedHotChocolateTypes.FLOAT_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDouble() : ((FloatValueNode)value).ToDouble(), SupportedHotChocolateTypes.DECIMAL_TYPE => value is IntValueNode intValueNode ? intValueNode.ToDecimal() : ((FloatValueNode)value).ToDecimal(), SupportedHotChocolateTypes.DATETIME_TYPE => ParseDateTimeValue(value.Value), - SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE => ParseDateTimeOffsetValue(value.Value), SupportedHotChocolateTypes.UUID_TYPE => Guid.TryParse(value.Value!.ToString(), out Guid guidValue) ? guidValue : value.Value, _ => value.Value }; @@ -410,7 +409,12 @@ private static bool TryGetPropertyFromParent( if (raw is DateTime dt) { - return dt; + return dt.Kind switch + { + DateTimeKind.Utc => dt, + DateTimeKind.Unspecified => DateTime.SpecifyKind(dt, DateTimeKind.Utc), + _ => dt.ToUniversalTime() + }; } if (raw is DateTimeOffset dto) @@ -421,44 +425,15 @@ private static bool TryGetPropertyFromParent( if (raw is string s) { // HotChocolate DateTime inputs are supplied as strings; parse them so DB providers - // (notably PostgreSQL) receive a typed parameter instead of text. - if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) + // (notably PostgreSQL) receive a typed UTC parameter instead of text. + if (DateTimeOffset.TryParse( + s, + CultureInfo.InvariantCulture, + DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, + out DateTimeOffset parsedDto)) { return parsedDto.UtcDateTime; } - - if (DateTime.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTime parsedDt)) - { - return parsedDt; - } - } - - return raw; - } - - static object? ParseDateTimeOffsetValue(object? raw) - { - if (raw is null) - { - return null; - } - - if (raw is DateTimeOffset dto) - { - return dto; - } - - if (raw is DateTime dt) - { - return new DateTimeOffset(dt); - } - - if (raw is string s) - { - if (DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTimeOffset parsedDto)) - { - return parsedDto; - } } return raw; From 18d4f90d8881412dc4fd25b809abac3a3e09fb12 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 22 Apr 2026 12:29:30 -0700 Subject: [PATCH 3/7] Unit tests to verify correctness --- .../UnitTests/ExecutionHelperUnitTests.cs | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs diff --git a/src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs b/src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs new file mode 100644 index 0000000000..5c1547cb25 --- /dev/null +++ b/src/Service.Tests/UnitTests/ExecutionHelperUnitTests.cs @@ -0,0 +1,60 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System; +using Azure.DataApiBuilder.Service.Services; +using HotChocolate.Execution; +using HotChocolate.Language; +using HotChocolate.Types; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Moq; + +namespace Azure.DataApiBuilder.Service.Tests.UnitTests; + +[TestClass] +public class ExecutionHelperUnitTests +{ + [TestMethod] + public void ExtractValueFromIValueNode_DateTimeLiteral_ReturnsUtcDateTime() + { + Mock argumentSchema = CreateArgumentSchema(new DateTimeType()); + Mock variables = new(); + + object result = ExecutionHelper.ExtractValueFromIValueNode( + new StringValueNode("2026-04-22T10:15:30-07:00"), + argumentSchema.Object, + variables.Object); + + Assert.IsInstanceOfType(result); + Assert.AreEqual( + new DateTime(2026, 4, 22, 17, 15, 30, DateTimeKind.Utc), + (DateTime)result); + } + + [TestMethod] + public void ExtractValueFromIValueNode_DateTimeVariable_ReturnsUtcDateTime() + { + Mock argumentSchema = CreateArgumentSchema(new DateTimeType()); + Mock variables = new(); + variables + .Setup(v => v.GetValue("createdAt")) + .Returns(new StringValueNode("2026-04-22T10:15:30Z")); + + object result = ExecutionHelper.ExtractValueFromIValueNode( + new VariableNode("createdAt"), + argumentSchema.Object, + variables.Object); + + Assert.IsInstanceOfType(result); + Assert.AreEqual( + new DateTime(2026, 4, 22, 10, 15, 30, DateTimeKind.Utc), + (DateTime)result); + } + + private static Mock CreateArgumentSchema(IInputType type) + { + Mock argumentSchema = new(); + argumentSchema.SetupGet(a => a.Type).Returns(type); + return argumentSchema; + } +} \ No newline at end of file From ecd6403b58c2b97c22289dd485875c878abbbe50 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 22 Apr 2026 12:30:19 -0700 Subject: [PATCH 4/7] Remove unnecessary call to DateTimeStyles.AdjustToUniversal because we are anyways returning UtcDateTime --- src/Core/Services/ExecutionHelper.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index f3d605e36c..2932886966 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -429,7 +429,7 @@ private static bool TryGetPropertyFromParent( if (DateTimeOffset.TryParse( s, CultureInfo.InvariantCulture, - DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, + DateTimeStyles.AssumeUniversal, out DateTimeOffset parsedDto)) { return parsedDto.UtcDateTime; From 648b7b4e729fb38126caaf8bba7959d5798054a6 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Wed, 22 Apr 2026 14:45:43 -0700 Subject: [PATCH 5/7] Add a TODO comment to look into support for SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE --- src/Core/Services/ExecutionHelper.cs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 2932886966..06d92405d9 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -386,6 +386,9 @@ private static bool TryGetPropertyFromParent( return value.Value; } + // TODO: Look into why there is no support for SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE translation in argumentSchema. + // This is more of a semantic issue than a logical one because we can still do appropriate parsing even if every date/time + // (with offset or not) is treated as SupportedHotChocolateTypes.DATETIME_TYPE but it is worth looking into regardless. return argumentSchema.Type.TypeName() switch { SupportedHotChocolateTypes.BYTE_TYPE => ((IntValueNode)value).ToByte(), From 030ed45b2ce2eefeacb7af4c57b17799b4ac7d56 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Thu, 23 Apr 2026 11:21:28 -0700 Subject: [PATCH 6/7] Add integration tests to test end-to-end flow Co-authored-by: Copilot --- .../PostgreSqlGQLSupportedTypesTests.cs | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs index 8b6e399d45..aaf19246d5 100644 --- a/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs +++ b/src/Service.Tests/SqlTests/GraphQLSupportedTypesTests/PostgreSqlGQLSupportedTypesTests.cs @@ -86,6 +86,29 @@ public async Task PGSQL_real_graphql_in_filter_expectedValues( await QueryTypeColumnFilterAndOrderBy(type, "in", sqlValue, gqlValue, "IN"); } + /// + /// PostgreSQL datetime filter tests with timezone offsets. + /// Verifies that GraphQL datetime arguments are normalized to UTC before filtering. + /// + [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", "=", + DisplayName = "DateTime filter eq converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "gte", "'1999-01-08 10:23:54'", "\"1999-01-08T05:23:54-05:00\"", ">=", + DisplayName = "DateTime filter gte converts -05:00 offset to UTC.")] + [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T15:53:54+05:30\"", "=", + DisplayName = "DateTime filter eq converts +05:30 offset to UTC.")] + [DataRow(DATETIME_TYPE, "eq", "'1999-01-08 10:23:54'", "\"1999-01-08T10:23:54Z\"", "=", + DisplayName = "DateTime filter eq preserves UTC input.")] + [DataTestMethod] + public async Task PGSQL_real_graphql_datetime_filter_offset_expectedValues( + string type, + string filterOperator, + string sqlValue, + string gqlValue, + string queryOperator) + { + await QueryTypeColumnFilterAndOrderBy(type, filterOperator, sqlValue, gqlValue, queryOperator); + } + protected override string MakeQueryOnTypeTable(List queryFields, int id) { return MakeQueryOnTypeTable(queryFields, filterValue: id.ToString(), filterField: "id"); From 80c52c541356fca1f061970d94743f49d0f5e668 Mon Sep 17 00:00:00 2001 From: Arjun Narendra Date: Sun, 26 Apr 2026 16:06:38 -0700 Subject: [PATCH 7/7] Remove todo comment --- src/Core/Services/ExecutionHelper.cs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/Core/Services/ExecutionHelper.cs b/src/Core/Services/ExecutionHelper.cs index 06d92405d9..2932886966 100644 --- a/src/Core/Services/ExecutionHelper.cs +++ b/src/Core/Services/ExecutionHelper.cs @@ -386,9 +386,6 @@ private static bool TryGetPropertyFromParent( return value.Value; } - // TODO: Look into why there is no support for SupportedHotChocolateTypes.DATETIMEOFFSET_TYPE translation in argumentSchema. - // This is more of a semantic issue than a logical one because we can still do appropriate parsing even if every date/time - // (with offset or not) is treated as SupportedHotChocolateTypes.DATETIME_TYPE but it is worth looking into regardless. return argumentSchema.Type.TypeName() switch { SupportedHotChocolateTypes.BYTE_TYPE => ((IntValueNode)value).ToByte(),