Support time data type in MsSql and fix for datetime types

src/Core/Azure.DataApiBuilder.Core.csproj

@@ -11,6 +11,7 @@
     <PackageReference Include="HotChocolate" />
     <PackageReference Include="HotChocolate.AspNetCore" />
     <PackageReference Include="HotChocolate.AspNetCore.Authorization" />
+    <PackageReference Include="HotChocolate.Types.NodaTime" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" />
     <PackageReference Include="Microsoft.Azure.Cosmos" />
     <PackageReference Include="Microsoft.Data.SqlClient" />

src/Core/Parsers/EdmModelBuilder.cs

@@ -67,30 +67,9 @@ SourceDefinition sourceDefinition
                     // each column represents a property of the current entity we are adding
                     foreach (string column in sourceDefinition.Columns.Keys)
                     {
-                        // need to convert our column system type to an Edm type
                         Type columnSystemType = sourceDefinition.Columns[column].SystemType;
-                        EdmPrimitiveTypeKind type = EdmPrimitiveTypeKind.None;
-                        if (columnSystemType.IsArray)
-                        {
-                            columnSystemType = columnSystemType.GetElementType()!;
-                        }
-
-                        type = columnSystemType.Name switch
-                        {
-                            "String" => EdmPrimitiveTypeKind.String,
-                            "Guid" => EdmPrimitiveTypeKind.Guid,
-                            "Byte" => EdmPrimitiveTypeKind.Byte,
-                            "Int16" => EdmPrimitiveTypeKind.Int16,
-                            "Int32" => EdmPrimitiveTypeKind.Int32,
-                            "Int64" => EdmPrimitiveTypeKind.Int64,
-                            "Single" => EdmPrimitiveTypeKind.Single,
-                            "Double" => EdmPrimitiveTypeKind.Double,
-                            "Decimal" => EdmPrimitiveTypeKind.Decimal,
-                            "Boolean" => EdmPrimitiveTypeKind.Boolean,
-                            "DateTime" or "DateTimeOffset" => EdmPrimitiveTypeKind.DateTimeOffset,
-                            "Date" => EdmPrimitiveTypeKind.Date,
-                            _ => throw new ArgumentException($"Column type {columnSystemType.Name} not yet supported."),
-                        };
+                        // need to convert our column system type to an Edm type
+                        EdmPrimitiveTypeKind type = TypeHelper.GetEdmPrimitiveTypeFromSystemType(columnSystemType);
 
                         // The mapped (aliased) field name defined in the runtime config is used to create a representative
                         // OData StructuralProperty. The created property is then added to the EdmEntityType.

src/Core/Parsers/ODataASTVisitor.cs

@@ -143,6 +143,8 @@ private static object GetParamWithSystemType(string param, IEdmTypeReference edm
                         return DateTimeOffset.Parse(param);
                     case EdmPrimitiveTypeKind.String:
                         return param;
+                    case EdmPrimitiveTypeKind.TimeOfDay:
+                        return TimeOnly.Parse(param);
                     default:
                         // should never happen due to the config being validated for correct types
                         throw new NotSupportedException($"{edmType} is not supported");

src/Core/Resolvers/Sql Query Structures/BaseSqlQueryStructure.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System.Data;
+using System.Globalization;
 using System.Net;
 using Azure.DataApiBuilder.Auth;
 using Azure.DataApiBuilder.Config.DatabasePrimitives;
@@ -360,10 +361,12 @@ protected static object ParseParamAsSystemType(string param, Type systemType)
                 "Double" => double.Parse(param),
                 "Decimal" => decimal.Parse(param),
                 "Boolean" => bool.Parse(param),
-                "DateTime" => DateTimeOffset.Parse(param),
-                "DateTimeOffset" => DateTimeOffset.Parse(param),
+                "DateTime" => DateTimeOffset.Parse(param, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal),
+                "DateTimeOffset" => DateTimeOffset.Parse(param, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal),
                 "Date" => DateOnly.Parse(param),
                 "Guid" => Guid.Parse(param),
+                "TimeOnly" => TimeOnly.Parse(param),
+                "TimeSpan" => TimeOnly.Parse(param),
                 _ => throw new NotSupportedException($"{systemType.Name} is not supported")
             };
         }

src/Core/Services/ResolverMiddleware.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Globalization;
 using System.Text.Json;
 using Azure.DataApiBuilder.Core.Authorization;
 using Azure.DataApiBuilder.Core.Models;
@@ -9,8 +10,10 @@
 using HotChocolate.Execution;
 using HotChocolate.Language;
 using HotChocolate.Resolvers;
+using HotChocolate.Types.NodaTime;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
+using NodaTime.Text;
 using static Azure.DataApiBuilder.Service.GraphQLBuilder.GraphQLTypes.SupportedTypes;
 
 namespace Azure.DataApiBuilder.Core.Services
@@ -196,8 +199,9 @@ private static object PreParseLeaf(IMiddlewareContext context, string leafJson)
             {
                 ByteType => byte.Parse(leafJson),
                 SingleType => Single.Parse(leafJson),
-                DateTimeType => DateTimeOffset.Parse(leafJson),
+                DateTimeType => DateTimeOffset.Parse(leafJson, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal),
                 ByteArrayType => Convert.FromBase64String(leafJson),
+                LocalTimeType => LocalTimePattern.ExtendedIso.Parse(leafJson).Value,
                 _ => leafJson
             };
         }

src/Core/Services/TypeHelper.cs

@@ -5,6 +5,7 @@
 using System.Net;
 using Azure.DataApiBuilder.Core.Services.OpenAPI;
 using Azure.DataApiBuilder.Service.Exceptions;
+using Microsoft.OData.Edm;
 
 namespace Azure.DataApiBuilder.Core.Services
 {
@@ -16,6 +17,10 @@ public static class TypeHelper
     {
         /// <summary>
         /// Maps .NET Framework types to DbType enum
+        /// Not Adding a hard mapping for System.DateTime to DbType.DateTime as 
+        /// Hotchocolate only has Hotchocolate.Types.DateTime for DbType.DateTime/DateTime2/DateTimeOffset,
+        /// which throws error when inserting/updating dateTime values due to type mismatch.
+        /// Therefore, seperate logic exists for proper mapping conversion in BaseSqlQueryStructure.
         /// </summary>
         private static Dictionary<Type, DbType> _systemTypeToDbTypeMap = new()
         {
@@ -34,21 +39,10 @@ public static class TypeHelper
             [typeof(string)] = DbType.String,
             [typeof(char)] = DbType.StringFixedLength,
             [typeof(Guid)] = DbType.Guid,
+            [typeof(DateTimeOffset)] = DbType.DateTimeOffset,
             [typeof(byte[])] = DbType.Binary,
-            [typeof(byte?)] = DbType.Byte,
-            [typeof(sbyte?)] = DbType.SByte,
-            [typeof(short?)] = DbType.Int16,
-            [typeof(ushort?)] = DbType.UInt16,
-            [typeof(int?)] = DbType.Int32,
-            [typeof(uint?)] = DbType.UInt32,
-            [typeof(long?)] = DbType.Int64,
-            [typeof(ulong?)] = DbType.UInt64,
-            [typeof(float?)] = DbType.Single,
-            [typeof(double?)] = DbType.Double,
-            [typeof(decimal?)] = DbType.Decimal,
-            [typeof(bool?)] = DbType.Boolean,
-            [typeof(char?)] = DbType.StringFixedLength,
-            [typeof(Guid?)] = DbType.Guid,
+            [typeof(TimeOnly)] = DbType.Time,
+            [typeof(TimeSpan)] = DbType.Time,
             [typeof(object)] = DbType.Object
         };
 
@@ -77,6 +71,7 @@ public static class TypeHelper
             [typeof(Guid)] = JsonDataType.String,
             [typeof(byte[])] = JsonDataType.String,
             [typeof(TimeSpan)] = JsonDataType.String,
+            [typeof(TimeOnly)] = JsonDataType.String,
             [typeof(object)] = JsonDataType.Object,
             [typeof(DateTime)] = JsonDataType.String,
             [typeof(DateTimeOffset)] = JsonDataType.String
@@ -108,14 +103,51 @@ public static class TypeHelper
             [SqlDbType.SmallInt] = typeof(short),
             [SqlDbType.SmallMoney] = typeof(decimal),
             [SqlDbType.Text] = typeof(string),
-            [SqlDbType.Time] = typeof(TimeSpan),
+            [SqlDbType.Time] = typeof(TimeOnly),
             [SqlDbType.Timestamp] = typeof(byte[]),
             [SqlDbType.TinyInt] = typeof(byte),
             [SqlDbType.UniqueIdentifier] = typeof(Guid),
             [SqlDbType.VarBinary] = typeof(byte[]),
             [SqlDbType.VarChar] = typeof(string)
         };
 
+        /// <summary>
+        /// Given the system type, returns the corresponding primitive type kind.
+        /// </summary>
+        /// <param name="columnSystemType">Type of the column.</param>
+        /// <returns>EdmPrimitiveTypeKind</returns>
+        /// <exception cref="ArgumentException">Throws when the column</exception>
+        public static EdmPrimitiveTypeKind GetEdmPrimitiveTypeFromSystemType(Type columnSystemType)
+        {
+            if (columnSystemType.IsArray)
+            {
+                columnSystemType = columnSystemType.GetElementType()!;
+            }
+
+            EdmPrimitiveTypeKind type = columnSystemType.Name switch
+            {
+                "String" => EdmPrimitiveTypeKind.String,
+                "Guid" => EdmPrimitiveTypeKind.Guid,
+                "Byte" => EdmPrimitiveTypeKind.Byte,
+                "Int16" => EdmPrimitiveTypeKind.Int16,
+                "Int32" => EdmPrimitiveTypeKind.Int32,
+                "Int64" => EdmPrimitiveTypeKind.Int64,
+                "Single" => EdmPrimitiveTypeKind.Single,
+                "Double" => EdmPrimitiveTypeKind.Double,
+                "Decimal" => EdmPrimitiveTypeKind.Decimal,
+                "Boolean" => EdmPrimitiveTypeKind.Boolean,
+                "DateTime" => EdmPrimitiveTypeKind.DateTimeOffset,
+                "DateTimeOffset" => EdmPrimitiveTypeKind.DateTimeOffset,
+                "Date" => EdmPrimitiveTypeKind.Date,
+                "TimeOnly" => EdmPrimitiveTypeKind.TimeOfDay,
+                "TimeSpan" => EdmPrimitiveTypeKind.TimeOfDay,
+                _ => throw new ArgumentException($"Column type" +
+                        $" {columnSystemType.Name} not yet supported.")
+            };
+
+            return type;
+        }
+
         /// <summary>
         /// Converts the .NET Framework (System/CLR) type to JsonDataType.
         /// Primitive data types in the OpenAPI standard (OAS) are based on the types supported
@@ -151,6 +183,15 @@ public static JsonDataType GetJsonDataTypeFromSystemType(Type type)
         /// <returns>DbType for the given system type. Null when no mapping exists.</returns>
         public static DbType? GetDbTypeFromSystemType(Type systemType)
         {
+            // Get the underlying type argument if the 'systemType' argument is a nullable type.
+            Type? nullableUnderlyingType = Nullable.GetUnderlyingType(systemType);
+
+            // Will not be null when the input argument 'systemType' is a closed generic nullable type.
+            if (nullableUnderlyingType is not null)
+            {
+                systemType = nullableUnderlyingType;
+            }
+
             if (!_systemTypeToDbTypeMap.TryGetValue(systemType, out DbType dbType))
             {
                 return null;

src/Directory.Packages.props

@@ -9,6 +9,7 @@
     <PackageVersion Include="HotChocolate" Version="12.18.0" />
     <PackageVersion Include="HotChocolate.AspNetCore" Version="12.18.0" />
     <PackageVersion Include="HotChocolate.AspNetCore.Authorization" Version="12.18.0" />
+    <PackageVersion Include="HotChocolate.Types.NodaTime" Version="12.18.0" />
     <PackageVersion Include="Humanizer" Version="2.14.1" />
     <PackageVersion Include="Humanizer.Core" Version="2.14.1" />
     <PackageVersion Include="DotNetEnv" Version="2.5.0" />
@@ -19,7 +20,7 @@
     <PackageVersion Include="Microsoft.AspNetCore.TestHost" Version="6.0.14" />
     <PackageVersion Include="Microsoft.Azure.Cosmos" Version="3.20.0" />
     <!--When updating Microsoft.Data.SqlClient, update license URL in scripts/notice-generation.ps1-->
-    <PackageVersion Include="Microsoft.Data.SqlClient" Version="5.0.1" />
+    <PackageVersion Include="Microsoft.Data.SqlClient" Version="5.1.1" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="6.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />

src/Service.GraphQLBuilder/Azure.DataApiBuilder.Service.GraphQLBuilder.csproj

@@ -20,6 +20,7 @@
   <ItemGroup>
     <PackageReference Include="HotChocolate" />
     <PackageReference Include="HotChocolate.AspNetCore.Authorization" />
+    <PackageReference Include="HotChocolate.Types.NodaTime" />
     <PackageReference Include="Humanizer" />
     <PackageReference Include="Newtonsoft.Json" />
     <PackageReference Include="StyleCop.Analyzers">

src/Service.GraphQLBuilder/GraphQLTypes/DefaultValueType.cs

@@ -3,6 +3,7 @@
 
 using Azure.DataApiBuilder.Service.GraphQLBuilder.CustomScalars;
 using HotChocolate.Types;
+using HotChocolate.Types.NodaTime;
 using static Azure.DataApiBuilder.Service.GraphQLBuilder.GraphQLTypes.SupportedTypes;
 
 namespace Azure.DataApiBuilder.Service.GraphQLBuilder.GraphQLTypes
@@ -24,6 +25,7 @@ protected override void Configure(IInputObjectTypeDescriptor descriptor)
             descriptor.Field(DECIMAL_TYPE).Type<DecimalType>();
             descriptor.Field(DATETIME_TYPE).Type<DateTimeType>();
             descriptor.Field(BYTEARRAY_TYPE).Type<ByteArrayType>();
+            descriptor.Field(LOCALTIME_TYPE).Type<LocalTimeType>();
         }
     }
 }

src/Service.GraphQLBuilder/GraphQLTypes/SupportedTypes.cs

@@ -18,8 +18,10 @@ public static class SupportedTypes
         public const string STRING_TYPE = "String";
         public const string BOOLEAN_TYPE = "Boolean";
         public const string DATETIME_TYPE = "DateTime";
-        public const string DATETIME_NONUTC_TYPE = "DateTimeNonUTC";
+        public const string DATETIMEOFFSET_TYPE = "DateTimeOffset";
         public const string BYTEARRAY_TYPE = "ByteArray";
         public const string GUID_TYPE = "Guid";
+        public const string LOCALTIME_TYPE = "LocalTime";
+        public const string TIME_TYPE = "Time";
     }
 }

src/Service.GraphQLBuilder/GraphQLUtils.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.Net;
 using Azure.DataApiBuilder.Config.DatabasePrimitives;
 using Azure.DataApiBuilder.Config.ObjectModel;
@@ -11,6 +12,8 @@
 using Azure.DataApiBuilder.Service.GraphQLBuilder.Sql;
 using HotChocolate.Language;
 using HotChocolate.Types;
+using HotChocolate.Types.NodaTime;
+using NodaTime.Text;
 using static Azure.DataApiBuilder.Service.GraphQLBuilder.GraphQLTypes.SupportedTypes;
 
 namespace Azure.DataApiBuilder.Service.GraphQLBuilder
@@ -52,7 +55,8 @@ public static bool IsBuiltInType(ITypeNode typeNode)
                 STRING_TYPE,
                 BOOLEAN_TYPE,
                 DATETIME_TYPE,
-                BYTEARRAY_TYPE
+                BYTEARRAY_TYPE,
+                LOCALTIME_TYPE
             };
             string name = typeNode.NamedType().Name.Value;
             return inBuiltTypes.Contains(name);
@@ -239,8 +243,10 @@ public static Tuple<string, IValueNode> ConvertValueToGraphQLType(string default
                     SINGLE_TYPE => new(SINGLE_TYPE, new SingleType().ParseValue(float.Parse(defaultValueFromConfig))),
                     FLOAT_TYPE => new(FLOAT_TYPE, new FloatValueNode(double.Parse(defaultValueFromConfig))),
                     DECIMAL_TYPE => new(DECIMAL_TYPE, new FloatValueNode(decimal.Parse(defaultValueFromConfig))),
-                    DATETIME_TYPE => new(DATETIME_TYPE, new DateTimeType().ParseResult(DateTime.Parse(defaultValueFromConfig))),
+                    DATETIME_TYPE => new(DATETIME_TYPE, new DateTimeType().ParseResult(
+                        DateTime.Parse(defaultValueFromConfig, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal))),
                     BYTEARRAY_TYPE => new(BYTEARRAY_TYPE, new ByteArrayType().ParseValue(Convert.FromBase64String(defaultValueFromConfig))),
+                    LOCALTIME_TYPE => new(LOCALTIME_TYPE, new LocalTimeType().ParseResult(LocalTimePattern.ExtendedIso.Parse(defaultValueFromConfig).Value)),
                     _ => throw new NotSupportedException(message: $"The {defaultValueFromConfig} parameter's value type [{paramValueType}] is not supported.")
                 };
 

src/Service.GraphQLBuilder/Queries/StandardQueryInputs.cs

@@ -4,6 +4,7 @@
 using Azure.DataApiBuilder.Service.GraphQLBuilder.CustomScalars;
 using HotChocolate.Language;
 using HotChocolate.Types;
+using HotChocolate.Types.NodaTime;
 using static Azure.DataApiBuilder.Service.GraphQLBuilder.GraphQLTypes.SupportedTypes;
 
 namespace Azure.DataApiBuilder.Service.GraphQLBuilder.Queries
@@ -201,6 +202,23 @@ public static InputObjectTypeDefinitionNode ByteArrayInputType() =>
                 }
             );
 
+        public static InputObjectTypeDefinitionNode LocalTimeInputType() =>
+            new(
+                location: null,
+                new NameNode("LocalTimeFilterInput"),
+                new StringValueNode("Input type for adding LocalTime filters"),
+                new List<DirectiveNode>(),
+                new List<InputValueDefinitionNode> {
+                            new InputValueDefinitionNode(null, new NameNode("eq"), new StringValueNode("Equals"), new LocalTimeType().ToTypeNode(), null, new List<DirectiveNode>()),
+                            new InputValueDefinitionNode(null, new NameNode("gt"), new StringValueNode("Greater Than"), new LocalTimeType().ToTypeNode(), null, new List<DirectiveNode>()),
+                            new InputValueDefinitionNode(null, new NameNode("gte"), new StringValueNode("Greater Than or Equal To"), new LocalTimeType().ToTypeNode(), null, new List<DirectiveNode>()),
+                            new InputValueDefinitionNode(null, new NameNode("lt"), new StringValueNode("Less Than"), new LocalTimeType().ToTypeNode(), null, new List<DirectiveNode>()),
+                            new InputValueDefinitionNode(null, new NameNode("lte"), new StringValueNode("Less Than or Equal To"), new LocalTimeType().ToTypeNode(), null, new List<DirectiveNode>()),
+                            new InputValueDefinitionNode(null, new NameNode("neq"), new StringValueNode("Not Equals"), new LocalTimeType().ToTypeNode(), null, new List<DirectiveNode>()),
+                            new InputValueDefinitionNode(null, new NameNode("isNull"), new StringValueNode("is null test"), new BooleanType().ToTypeNode(), null, new List<DirectiveNode>())
+                }
+            );
+
         public static Dictionary<string, InputObjectTypeDefinitionNode> InputTypes = new()
         {
             { "ID", IdInputType() },
@@ -214,7 +232,8 @@ public static InputObjectTypeDefinitionNode ByteArrayInputType() =>
             { BOOLEAN_TYPE, BooleanInputType() },
             { STRING_TYPE, StringInputType() },
             { DATETIME_TYPE, DateTimeInputType() },
-            { BYTEARRAY_TYPE, ByteArrayInputType() }
+            { BYTEARRAY_TYPE, ByteArrayInputType() },
+            { LOCALTIME_TYPE, LocalTimeInputType() },
         };
 
         /// <summary>