Added extension method to support old and new behaviour

Author: papafe

Diff for: src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs

@@ -47,8 +47,7 @@ public AutocompleteSearchDefinition(
 
         private protected override BsonDocument RenderArguments(
             RenderArgs<TDocument> args,
-            IBsonSerializer fieldSerializer) =>
-           new()
+            IBsonSerializer fieldSerializer) => new()
            {
                 { "query", _query.Render() },
                 { "tokenOrder", _tokenOrder.ToCamelCase(), _tokenOrder != SearchAutocompleteTokenOrder.Any },
@@ -139,6 +138,11 @@ private protected override BsonDocument RenderArguments(
             RenderArgs<TDocument> args,
             IBsonSerializer fieldSerializer)
         {
+            if (!_useDefaultSerialization)
+            {
+                return new BsonDocument("value", ToBsonValue(_value));
+            }
+
             var valueSerializer = fieldSerializer switch
             {
                 null => args.SerializerRegistry.GetSerializer<TValue>(),
@@ -253,6 +257,12 @@ private protected override BsonDocument RenderArguments(
             RenderArgs<TDocument> args,
             IBsonSerializer fieldSerializer)
         {
+            if (!_useDefaultSerialization)
+            {
+                var values = new BsonArray(_values.Select(ToBsonValue));
+                return new BsonDocument("value", values);
+            }
+
             var valueSerializer = fieldSerializer switch
             {
                 null => new ArraySerializer<TValue>(args.SerializerRegistry.GetSerializer<TValue>()),
@@ -386,6 +396,18 @@ private protected override BsonDocument RenderArguments(
             RenderArgs<TDocument> args,
             IBsonSerializer fieldSerializer)
         {
+            if (!_useDefaultSerialization)
+            {
+                var min = ToBsonValue(_range.Min);
+                var max = ToBsonValue(_range.Max);
+
+                return new BsonDocument
+                {
+                    { _range.IsMinInclusive ? "gte" : "gt", min, min != BsonNull.Value },
+                    { _range.IsMaxInclusive ? "lte" : "lt", max, max != BsonNull.Value },
+                };
+            }
+
             var valueSerializer = fieldSerializer switch
             {
                 null => args.SerializerRegistry.GetSerializer<TValue>(),

Diff for: src/MongoDB.Driver/Search/SearchDefinition.cs

@@ -13,6 +13,7 @@
 * limitations under the License.
 */
 
+using System;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
@@ -55,6 +56,31 @@ public static implicit operator SearchDefinition<TDocument>(string json) =>
             json != null ? new JsonSearchDefinition<TDocument>(json) : null;
     }
 
+    /// <summary>
+    /// Extensions for SearchDefinition
+    /// </summary>
+    public static class SearchDefinitionExtensions
+    {
+        /// <summary>
+        /// Sets the use of default serialization for the specified <see cref="SearchDefinition{TDocument}"/>.
+        /// When set to true, the default serializers will be used to serialize the values of certain Atlas Search operators, such as "Equals", "In" and "Range". This will become the default behaviour in version 4.0 of the library.
+        /// If not enabled, then a default conversion will be used.
+        /// </summary>
+        /// <typeparam name="TDocument">The type of the document.</typeparam>
+        /// <param name="searchDefinition">The search definition instance.</param>
+        /// <param name="useDefaultSerialization">Whether to use the default serialization or not.</param>
+        /// <returns>The same <see cref="SearchDefinition{TDocument}"/> instance with default serialization enabled.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if <paramref name="searchDefinition"/> is not of a valid type/>.</exception>
+        public static SearchDefinition<TDocument> WithDefaultSerialization<TDocument>(this SearchDefinition<TDocument> searchDefinition, bool useDefaultSerialization)
+        {
+            if (searchDefinition is not OperatorSearchDefinition<TDocument> op)
+                throw new InvalidOperationException("Default serialization cannot be used with the current SearchDefinition type");
+
+            op.SetUseDefaultSerialization(useDefaultSerialization);
+            return searchDefinition;
+        }
+    }
+
     /// <summary>
     /// A search definition based on a BSON document.
     /// </summary>
@@ -134,6 +160,8 @@ private protected enum OperatorType
         protected readonly SearchPathDefinition<TDocument> _path;
         protected readonly SearchScoreDefinition<TDocument> _score;
 
+        protected bool _useDefaultSerialization = false;
+
         private protected OperatorSearchDefinition(OperatorType operatorType)
             : this(operatorType, null)
         {
@@ -172,7 +200,36 @@ public override BsonDocument Render(RenderArgs<TDocument> args)
             return new(_operatorType.ToCamelCase(), renderedArgs);
         }
 
-        private protected virtual BsonDocument RenderArguments(RenderArgs<TDocument> args,
+        private protected virtual BsonDocument RenderArguments(
+            RenderArgs<TDocument> args,
             IBsonSerializer fieldSerializer) => new();
+
+        internal void SetUseDefaultSerialization(bool useDefaultSerialization)
+        {
+            _useDefaultSerialization = useDefaultSerialization;
+        }
+
+        protected static BsonValue ToBsonValue<T>(T value) =>
+            value switch
+            {
+                bool v => (BsonBoolean)v,
+                sbyte v => (BsonInt32)v,
+                byte v => (BsonInt32)v,
+                short v => (BsonInt32)v,
+                ushort v => (BsonInt32)v,
+                int v => (BsonInt32)v,
+                uint v => (BsonInt64)v,
+                long v => (BsonInt64)v,
+                float v => (BsonDouble)v,
+                double v => (BsonDouble)v,
+                decimal v => (BsonDecimal128)v,
+                DateTime v => (BsonDateTime)v,
+                DateTimeOffset v => (BsonDateTime)v.UtcDateTime,
+                ObjectId v => (BsonObjectId)v,
+                Guid v => new BsonBinaryData(v, GuidRepresentation.Standard),
+                string v => (BsonString)v,
+                null => BsonNull.Value,
+                _ => throw new InvalidCastException()
+            };
     }
 }