apply indexes to primitive type values only

src/Storage.MongoDB/MongoNonceRepository.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson.Serialization;
@@ -53,19 +54,16 @@ public MongoNonceRepository(IMongoDatabase database, MongoNonceOptions options)
         public async ValueTask InsertOneAsync(
             Token token, CancellationToken cancellationToken)
         {
-            await _collection.InsertOneAsync(token, cancellationToken: cancellationToken);
+            token.ExtraProperties = token.ExtraProperties ?? new Dictionary<string, object>();
 
-            if (token.ExtraProperties != null)
-            {
-                var indexOptions = new CreateIndexOptions { Background = true };
+            IReadOnlySet<string> propertyNamesWithPrimitiveValueType =
+                GetPropertyNamesWithPrimitiveValueType(token.ExtraProperties);
 
-                foreach (KeyValuePair<string, object> extraProperty in token.ExtraProperties)
-                {
-                    _collection.Indexes.CreateOne(new CreateIndexModel<Token>(
-                        Builders<Token>.IndexKeys.Ascending(
-                            $"{nameof(token.ExtraProperties)}.{extraProperty.Key}"), indexOptions));
-                }
-            }
+            SetJsonStringValue(token.ExtraProperties, propertyNamesWithPrimitiveValueType);
+
+            await _collection.InsertOneAsync(token, cancellationToken: cancellationToken);
+
+            CreateIndexes(propertyNamesWithPrimitiveValueType);
         }
 
         public async ValueTask<Token?> TakeOneAsync(
@@ -105,5 +103,52 @@ public static void Initialize()
         {
             //ensure static constructor is called
         }
+
+        private void CreateIndexes(IEnumerable<string> extraPropertyNames)
+        {
+            var indexOptions = new CreateIndexOptions { Background = true };
+
+            foreach (string extraPropertyName in extraPropertyNames)
+            {
+                _collection.Indexes.CreateOne(new CreateIndexModel<Token>(
+                    Builders<Token>.IndexKeys.Ascending(
+                        $"{nameof(Token.ExtraProperties)}.{extraPropertyName}"), indexOptions));
+            }
+        }
+
+        private IReadOnlySet<string> GetPropertyNamesWithPrimitiveValueType(
+            Dictionary<string, object> extraProperties)
+        {
+            HashSet<string> names = new HashSet<string>();
+
+            foreach (KeyValuePair<string, object> keyValue in extraProperties)
+            {
+                if (keyValue.Value == null)
+                {
+                    continue;
+                }
+
+                if (TypeChecker.IsPrimitiveType(keyValue.Value.GetType()))
+                {
+                    names.Add(keyValue.Key);
+                }
+            }
+
+            return names;
+        }
+
+        private void SetJsonStringValue(
+            Dictionary<string, object> extraProperties, IReadOnlySet<string> namesToSkip)
+        {
+            foreach(string name in extraProperties.Keys)
+            {
+                if (namesToSkip.Contains(name))
+                {
+                    continue;
+                }
+
+                extraProperties[name] = JsonSerializer.Serialize(extraProperties[name]);
+            }
+        }
     }
 }

src/Storage.MongoDB/TypeChecker.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson;
+
+#nullable enable
+
+namespace Bewit.Storage.MongoDB
+{
+    public static class TypeChecker
+    {
+        private static readonly HashSet<Type> PrimitiveTypes = new HashSet<Type>
+        {
+            typeof(string),
+            typeof(bool),
+            typeof(byte),
+            typeof(sbyte),
+            typeof(char),
+            typeof(decimal),
+            typeof(double),
+            typeof(float),
+            typeof(int),
+            typeof(uint),
+            typeof(long),
+            typeof(ulong),
+            typeof(short),
+            typeof(ushort),
+            typeof(DateTime),
+            typeof(DateTimeOffset),
+            typeof(TimeSpan),
+            typeof(DateOnly),
+            typeof(TimeOnly),
+            typeof(Guid),
+            typeof(ObjectId),
+            typeof(BsonObjectId),
+            typeof(BsonDateTime)
+        };
+
+        public static bool IsPrimitiveType(object value)
+        {
+            if (value == null)
+                return false;
+
+            Type type = value.GetType();
+            return IsPrimitiveType(type);
+        }
+
+        public static bool IsPrimitiveType(Type type)
+        {
+            Type underlyingType = Nullable.GetUnderlyingType(type) ?? type;
+
+            return PrimitiveTypes.Contains(underlyingType) ||
+                   underlyingType.IsEnum;
+        }
+    }
+}

test/IntegrationTests/HotChocolateServer/HCServerHelper.cs

@@ -70,7 +70,12 @@ internal static TestServer CreateHotChocolateServer(
                                 .Resolve(ctx =>
                                 {
                                     ctx.AddBewitTokenExtraProperties(
-                                        new Dictionary<string, object> { ["foo"] = "bar" });
+                                        new Dictionary<string, object>
+                                        {
+                                            ["foo"] = "bar",
+                                            ["customType"] = new{},
+                                            ["nullValue"] = null
+                                        });
 
                                     return "http://foo.bar/api/dummy/WithBewitProtection?foo=bar&baz=qux";
                                 })