Query: Adds support for System.Text LINQ Custom Serializer

Microsoft.Azure.Cosmos/src/Linq/ExpressionToSQL.cs

@@ -10,15 +10,19 @@ namespace Microsoft.Azure.Cosmos.Linq
     using System.Collections.ObjectModel;
     using System.Diagnostics;
     using System.Globalization;
+    using System.IO;
     using System.Linq;
     using System.Linq.Expressions;
     using System.Reflection;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
     using Microsoft.Azure.Cosmos.CosmosElements;
     using Microsoft.Azure.Cosmos.CosmosElements.Numbers;
     using Microsoft.Azure.Cosmos.Spatial;
     using Microsoft.Azure.Cosmos.SqlObjects;
     using Microsoft.Azure.Documents;
     using Newtonsoft.Json;
+    using Newtonsoft.Json.Serialization;
     using static Microsoft.Azure.Cosmos.Linq.FromParameterBindings;
 
     // ReSharper disable UnusedParameter.Local
@@ -169,7 +173,7 @@ private static Collection TranslateInput(ConstantExpression inputExpression, Tra
         }
 
         /// <summary>
-        /// Get a paramter name to be binded to the a collection from the next lambda.
+        /// Get a parameter name to be binded to the collection from the next lambda.
         /// It's merely for readability purpose. If that is not possible, use a default 
         /// parameter name.
         /// </summary>
@@ -189,7 +193,7 @@ private static string GetBindingParameterName(TranslationContext context)
                 }
             }
 
-            if (parameterName == null) parameterName = ExpressionToSql.DefaultParameterName;
+            parameterName ??= ExpressionToSql.DefaultParameterName;
 
             return parameterName;
         }
@@ -524,10 +528,10 @@ private static SqlScalarExpression ApplyCustomConverters(Expression left, SqlLit
                 // so we check both attributes and apply the same precedence rules
                 // JsonConverterAttribute doesn't allow duplicates so it's safe to
                 // use FirstOrDefault()
-                CustomAttributeData memberAttribute = memberExpression.Member.CustomAttributes.Where(ca => ca.AttributeType == typeof(JsonConverterAttribute)).FirstOrDefault();
-                CustomAttributeData typeAttribute = memberType.GetsCustomAttributes().Where(ca => ca.AttributeType == typeof(JsonConverterAttribute)).FirstOrDefault();
+                CustomAttributeData converterAttribute = memberExpression.Member.CustomAttributes.FirstOrDefault(ca => ca.AttributeType == typeof(Newtonsoft.Json.JsonConverterAttribute));
+                converterAttribute ??= memberType.GetsCustomAttributes().FirstOrDefault(ca => ca.AttributeType == typeof(Newtonsoft.Json.JsonConverterAttribute));
+                converterAttribute ??= memberExpression.Member.CustomAttributes.FirstOrDefault(ca => ca.AttributeType == typeof(System.Text.Json.Serialization.JsonConverterAttribute));
 
-                CustomAttributeData converterAttribute = memberAttribute ?? typeAttribute;
                 if (converterAttribute != null)
                 {
                     Debug.Assert(converterAttribute.ConstructorArguments.Count > 0);
@@ -538,14 +542,21 @@ private static SqlScalarExpression ApplyCustomConverters(Expression left, SqlLit
                     // Enum
                     if (memberType.IsEnum())
                     {
-                        Number64 number64 = ((SqlNumberLiteral)right.Literal).Value;
-                        if (number64.IsDouble)
+                        try
                         {
-                            value = Enum.ToObject(memberType, Number64.ToDouble(number64));
+                            Number64 number64 = ((SqlNumberLiteral)right.Literal).Value;
+                            if (number64.IsDouble)
+                            {
+                                value = Enum.ToObject(memberType, Number64.ToDouble(number64));
+                            }
+                            else
+                            {
+                                value = Enum.ToObject(memberType, Number64.ToLong(number64));
+                            }
                         }
-                        else
+                        catch
                         {
-                            value = Enum.ToObject(memberType, Number64.ToLong(number64));
+                            value = ((SqlStringLiteral)right.Literal).Value;
                         }
 
                     }
@@ -561,8 +572,19 @@ private static SqlScalarExpression ApplyCustomConverters(Expression left, SqlLit
                         string serializedValue;
 
                         if (converterType.GetConstructor(Type.EmptyTypes) != null)
-                        {
-                            serializedValue = JsonConvert.SerializeObject(value, (JsonConverter)Activator.CreateInstance(converterType));
+                        {                      
+                            if (converterAttribute.AttributeType == typeof(System.Text.Json.Serialization.JsonConverterAttribute))
+                            {
+                                // DotNet serializer
+                                JsonSerializerOptions options = new JsonSerializerOptions();
+                                options.Converters.Add(new JsonStringEnumConverter());
+                                serializedValue = System.Text.Json.JsonSerializer.Serialize(value, options);
+                            }
+                            else
+                            {
+                                // Newtonsoft serializer
+                                serializedValue = JsonConvert.SerializeObject(value, (Newtonsoft.Json.JsonConverter)Activator.CreateInstance(converterType));
+                            }
                         }
                         else
                         {
@@ -770,6 +792,39 @@ public static SqlScalarExpression VisitConstant(ConstantExpression inputExpressi
                 return SqlArrayCreateScalarExpression.Create(arrayItems.ToImmutableArray());
             }
 
+            // if ANY property is decorated with Newtonsoft JsonPropertyAttribute, we serialize all with this serializer
+            PropertyInfo[] propInfo = inputExpression.Value.GetType().GetProperties();
+            bool hasCustomAttributesNewtonsoft = propInfo.Any(property => property.GetCustomAttributes().Any(attribute => attribute.GetType() == typeof(JsonPropertyAttribute)));
+
+            bool hasCustomAttributesDataMember = inputExpression.Type.CustomAttributes != null && inputExpression.Type.CustomAttributes.Count() > 0;
+
+            if (hasCustomAttributesNewtonsoft || hasCustomAttributesDataMember )
+            {
+                JsonSerializerSettings serializerSettings = new JsonSerializerSettings();
+                if (context.linqSerializerOptions != null && context.linqSerializerOptions.PropertyNamingPolicy == CosmosPropertyNamingPolicy.CamelCase)
+                {
+                    serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
+                }
+
+                return CosmosElement.Parse(JsonConvert.SerializeObject(inputExpression.Value, serializerSettings)).Accept(CosmosElementToSqlScalarExpressionVisitor.Singleton);
+            }
+
+            // Use DotNet custom serializer if provided
+            if (context.linqSerializerOptions?.CustomCosmosSerializer != null)
+            {
+                StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);
+
+                using (Stream stream = context.linqSerializerOptions.CustomCosmosSerializer.ToStream(inputExpression.Value))
+                {
+                    using (StreamReader streamReader = new StreamReader(stream))
+                    {
+                        string propertyValue = streamReader.ReadToEnd();
+                        writer.Write(propertyValue);
+                        return CosmosElement.Parse(writer.ToString()).Accept(CosmosElementToSqlScalarExpressionVisitor.Singleton);
+                    }
+                }
+            }
+
             return CosmosElement.Parse(JsonConvert.SerializeObject(inputExpression.Value)).Accept(CosmosElementToSqlScalarExpressionVisitor.Singleton);
         }
 

Microsoft.Azure.Cosmos/src/Linq/TypeSystem.cs

@@ -11,7 +11,7 @@ namespace Microsoft.Azure.Cosmos.Linq
     using System.Reflection;
     using System.Runtime.CompilerServices;
     using System.Runtime.Serialization;
-    using Microsoft.Azure.Cosmos.Serializer;
+    using System.Text.Json.Serialization;
     using Microsoft.Azure.Documents;
     using Newtonsoft.Json;
 
@@ -27,14 +27,13 @@ public static string GetMemberName(this MemberInfo memberInfo, CosmosLinqSeriali
             string memberName = null;
 
             // Check if Newtonsoft JsonExtensionDataAttribute is present on the member, if so, return empty member name.
-            JsonExtensionDataAttribute jsonExtensionDataAttribute = memberInfo.GetCustomAttribute<JsonExtensionDataAttribute>(true);
+            Newtonsoft.Json.JsonExtensionDataAttribute jsonExtensionDataAttribute = memberInfo.GetCustomAttribute<Newtonsoft.Json.JsonExtensionDataAttribute>(true);
             if (jsonExtensionDataAttribute != null && jsonExtensionDataAttribute.ReadData)
             {
                 return null;
             }
 
-            // Json.Net honors JsonPropertyAttribute more than DataMemberAttribute
-            // So we check for JsonPropertyAttribute first.
+            // Precedence is (highest to lowest) : JsonPropertyAttribute, DataMemberAttribute, JsonPropertyNameAttribute
             JsonPropertyAttribute jsonPropertyAttribute = memberInfo.GetCustomAttribute<JsonPropertyAttribute>(true);
             if (jsonPropertyAttribute != null && !string.IsNullOrEmpty(jsonPropertyAttribute.PropertyName))
             {
@@ -51,13 +50,19 @@ public static string GetMemberName(this MemberInfo memberInfo, CosmosLinqSeriali
                         memberName = dataMemberAttribute.Name;
                     }
                 }
+                else
+                {
+                    JsonPropertyNameAttribute jsonPropertyNameAttribute = memberInfo.GetCustomAttribute<JsonPropertyNameAttribute>(true);
+                    if (jsonPropertyNameAttribute != null && !string.IsNullOrEmpty(jsonPropertyNameAttribute.Name))
+                    {
+                        memberName = jsonPropertyNameAttribute.Name;
+                    }
+                }
             }
 
-            if (memberName == null)
-            {
-                memberName = memberInfo.Name;
-            }
+            memberName ??= memberInfo.Name;
 
+            // Apply camel casing if specified
             if (linqSerializerOptions != null)
             {
                 memberName = CosmosSerializationUtil.GetStringWithPropertyNamingPolicy(linqSerializerOptions, memberName);

Microsoft.Azure.Cosmos/src/Resource/Container/ContainerCore.Items.cs

@@ -502,11 +502,14 @@ public override IOrderedQueryable<T> GetItemLinqQueryable<T>(
         {
             requestOptions ??= new QueryRequestOptions();
 
-            if (linqSerializerOptions == null && this.ClientContext.ClientOptions.SerializerOptions != null)
+            if (linqSerializerOptions == null && this.ClientContext.ClientOptions != null)
             {
                 linqSerializerOptions = new CosmosLinqSerializerOptions
                 {
-                    PropertyNamingPolicy = this.ClientContext.ClientOptions.SerializerOptions.PropertyNamingPolicy
+                    PropertyNamingPolicy = this.ClientContext.ClientOptions.SerializerOptions != null
+                                            ? this.ClientContext.ClientOptions.SerializerOptions.PropertyNamingPolicy
+                                            : CosmosPropertyNamingPolicy.Default,
+                    CustomCosmosSerializer = this.ClientContext.ClientOptions.Serializer
                 };
             }
 

Microsoft.Azure.Cosmos/src/Serializer/CosmosLinqSerializerOptions.cs

@@ -18,6 +18,15 @@ public CosmosLinqSerializerOptions()
             this.PropertyNamingPolicy = CosmosPropertyNamingPolicy.Default;
         }
 
+        /// <summary>
+        /// Gets or sets the user defined customer serializer. If no customer serializer was defined, 
+        /// then the value is set to the default value
+        /// </summary>
+        /// <remarks>
+        /// The default value is null
+        /// </remarks>
+        internal CosmosSerializer CustomCosmosSerializer { get; set; }
+
         /// <summary>
         /// Gets or sets whether the naming policy used to convert a string-based name to another format,
         /// such as a camel-casing format.

Microsoft.Azure.Cosmos/src/Serializer/CosmosSerializationUtil.cs

@@ -4,23 +4,17 @@
 
 namespace Microsoft.Azure.Cosmos
 {
-    using Microsoft.Azure.Cosmos.Serializer;
     using Newtonsoft.Json.Serialization;
 
     internal static class CosmosSerializationUtil
     {
         private static readonly CamelCaseNamingStrategy camelCaseNamingStrategy = new CamelCaseNamingStrategy();
 
-        internal static string ToCamelCase(string name)
-        {
-            return CosmosSerializationUtil.camelCaseNamingStrategy.GetPropertyName(name, false);
-        }
-
         internal static string GetStringWithPropertyNamingPolicy(CosmosLinqSerializerOptions options, string name)
         {
             if (options != null && options.PropertyNamingPolicy == CosmosPropertyNamingPolicy.CamelCase)
             {
-                return CosmosSerializationUtil.ToCamelCase(name);
+                return CosmosSerializationUtil.camelCaseNamingStrategy.GetPropertyName(name, false);
             }
 
             return name;

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/BaselineTest/TestBaseline/LinqSQLTranslationBaselineTest.ValidateSQLTranslation.xml

@@ -278,7 +278,7 @@ FROM root]]></SqlQuery>
     </Input>
     <Output>
       <SqlQuery><![CDATA[
-SELECT VALUE {"dbl": 0, "str": null, "b": false, "dblArray": null, "inside": {"x": 0, "y": 0, "id": null, "pk": null}, "id": null, "pk": null, "NetExtensionData": {"OtherTest": 1.5}, "test": 1.5} 
+SELECT VALUE {"dbl": 0, "b": false, "inside": {"x": 0, "y": 0}, "NetExtensionData": {"OtherTest": 1.5}, "test": 1.5} 
 FROM root]]></SqlQuery>
     </Output>
   </Result>

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/BaselineTest/TestBaseline/LinqTranslationWithCustomSerializerBaseline.TestMemberInitializerDataMember.xml

@@ -29,7 +29,7 @@ WHERE (root["numericFieldDataMember"] = 1)]]></SqlQuery>
       <SqlQuery><![CDATA[
 SELECT VALUE root 
 FROM root 
-WHERE (root = {"NumericFieldDataMember": 1, "StringFieldDataMember": "1", "id": null, "Pk": null})]]></SqlQuery>
+WHERE (root = {"numericFieldDataMember": 1, "stringFieldDataMember": "1", "id": null, "pk": null})]]></SqlQuery>
       <InputData><![CDATA[[
   "{\"NumericField\": 0, \"StringField\": \"0\", \"id\": \"0-True\", \"Pk\": \"Test\"}",
   "{\"NumericField\": 1, \"StringField\": \"1\", \"id\": \"1-True\", \"Pk\": \"Test\"}",
@@ -48,7 +48,7 @@ WHERE (root = {"NumericFieldDataMember": 1, "StringFieldDataMember": "1", "id":
     </Input>
     <Output>
       <SqlQuery><![CDATA[
-SELECT VALUE {"NumericFieldDataMember": 1, "StringFieldDataMember": "1", "id": null, "Pk": null} 
+SELECT VALUE {"numericFieldDataMember": 1, "stringFieldDataMember": "1", "id": null, "pk": null} 
 FROM root]]></SqlQuery>
       <InputData><![CDATA[[
   "{\"NumericField\": 0, \"StringField\": \"0\", \"id\": \"0-True\", \"Pk\": \"Test\"}",
@@ -75,7 +75,7 @@ FROM root]]></SqlQuery>
     </Input>
     <Output>
       <SqlQuery><![CDATA[
-SELECT VALUE ((root["numericFieldDataMember"] > 1) ? {"NumericFieldDataMember": 1, "StringFieldDataMember": "1", "id": null, "Pk": null} : {"NumericFieldDataMember": 1, "StringFieldDataMember": "1", "id": null, "Pk": null}) 
+SELECT VALUE ((root["numericFieldDataMember"] > 1) ? {"numericFieldDataMember": 1, "stringFieldDataMember": "1", "id": null, "pk": null} : {"numericFieldDataMember": 1, "stringFieldDataMember": "1", "id": null, "pk": null}) 
 FROM root]]></SqlQuery>
       <InputData><![CDATA[[
   "{\"NumericField\": 0, \"StringField\": \"0\", \"id\": \"0-True\", \"Pk\": \"Test\"}",