Allow describing an index from a given Type.

src/Directory.Build.props

@@ -3,7 +3,7 @@
     <PropertyGroup>
         <Copyright>Sebastien Ros</Copyright>
         <Authors>Sebastien Ros</Authors>
-        <TargetFrameworks>net6.0</TargetFrameworks>
+        <TargetFrameworks>net7.0</TargetFrameworks>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
         <DebugType>portable</DebugType>
         <PackageProjectUrl>https://github.com/sebastienros/yessql</PackageProjectUrl>

src/YesSql.Abstractions/IConfiguration.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
+using YesSql.Indexes;
 
 namespace YesSql
 {
@@ -90,6 +91,13 @@ public interface IConfiguration
         /// Gets or sets the identity column size. Default is <see cref="IdentityColumnSize.Int32"/>.
         /// </summary>
         IdentityColumnSize IdentityColumnSize { get; set; }
+
+        /// <summary>
+        /// Index type cache provider 
+        /// This interface needs to be reimplemented when dynamic type and multi-tenant scenarios are used,
+        /// using tenant separated cache media insteadexTypeCacheProvider 
+        /// </summary>
+        IndexTypeCacheProvider IndexTypeCacheProvider { get; set; }
     }
 
     public static class ConfigurationExtensions

src/YesSql.Abstractions/IContentSerializer.cs

@@ -22,12 +22,5 @@ public interface IContentSerializer
         /// <param name="type">The type of the object to deserialize.</param>
         /// <returns>The deserialized object.</returns>
         object Deserialize(string content, Type type);
-
-        /// <summary>
-        /// Deserializes an object to a <c>dynamic</c> instance.
-        /// </summary>
-        /// <param name="content">The <see cref="String" /> instance representing the object to deserialize.</param>
-        /// <returns>The deserialized object.</returns>
-        dynamic DeserializeDynamic(string content);
     }
 }

src/YesSql.Abstractions/Indexes/DescribeContext.cs

@@ -6,7 +6,7 @@ namespace YesSql.Indexes
 {
     public class DescribeContext<T> : IDescriptor
     {
-        private readonly Dictionary<Type, List<IDescribeFor>> _describes = new Dictionary<Type, List<IDescribeFor>>();
+        private readonly Dictionary<Type, List<IDescribeFor>> _describes = [];
 
         public IEnumerable<IndexDescriptor> Describe(params Type[] types)
         {
@@ -25,21 +25,31 @@ public IEnumerable<IndexDescriptor> Describe(params Type[] types)
                 });
         }
 
+        public IMapFor<T, IIndex> For(Type indexType) => For<IIndex, object>(indexType);
+
         public IMapFor<T, TIndex> For<TIndex>() where TIndex : IIndex
         {
-            return For<TIndex, object>();
+            return For<TIndex, object>(typeof(TIndex));
         }
 
-        public IMapFor<T, TIndex> For<TIndex, TKey>() where TIndex : IIndex
+        public IMapFor<T, TIndex> For<TIndex, TKey>() where TIndex : IIndex => For<TIndex, object>(typeof(TIndex));
+
+        public IMapFor<T, TIndex> For<TIndex, TKey>(Type indexType) where TIndex : IIndex
         {
+            ArgumentNullException.ThrowIfNull(indexType, nameof(indexType));
+
             List<IDescribeFor> descriptors;
 
             if (!_describes.TryGetValue(typeof(T), out descriptors))
             {
-                descriptors = _describes[typeof(T)] = new List<IDescribeFor>();
+                descriptors = _describes[typeof(T)] = [];
             }
 
-            var describeFor = new IndexDescriptor<T, TIndex, TKey>();
+            var describeFor = new IndexDescriptor<T, TIndex, TKey>()
+            {
+                IndexType = indexType,
+            };
+
             descriptors.Add(describeFor);
 
             return describeFor;

src/YesSql.Abstractions/Indexes/DescribeFor.cs

@@ -51,8 +51,9 @@ public class IndexDescriptor<T, TIndex, TKey> : IDescribeFor, IMapFor<T, TIndex>
         private Func<object, bool> _filter;
 
         public PropertyInfo GroupProperty { get; set; }
-        public Type IndexType { get { return typeof(TIndex); } }
 
+        public Type IndexType { get; internal set; } = typeof(TIndex);
+
         public Func<object, bool> Filter => _filter;
 
         public IGroupFor<TIndex> Map(Func<T, IEnumerable<TIndex>> map)

src/YesSql.Abstractions/Indexes/IndexTypeCacheProvider.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using YesSql.Serialization;
+
+namespace YesSql.Indexes
+{
+    public class IndexTypeCacheProvider
+    {
+        private static readonly ConcurrentDictionary<PropertyInfo, PropertyInfoAccessor> PropertyAccessors = new();
+        private static readonly ConcurrentDictionary<string, PropertyInfo[]> TypeProperties = new();
+
+        public virtual PropertyInfoAccessor GetPropertyAccessor(PropertyInfo property) => PropertyAccessors.GetOrAdd(property, p => new PropertyInfoAccessor(p));
+
+        public virtual PropertyInfo[] GetTypeProperties(Type type)
+        {
+            if (TypeProperties.TryGetValue(type.FullName, out var pis))
+            {
+                return pis;
+            }
+
+            var properties = type.GetProperties().Where(IsWriteable).ToArray();
+            TypeProperties[type.FullName] = properties;
+
+            return properties;
+        }
+
+        public virtual void UpdateCachedType(Type type)
+        {
+            if (TypeProperties.TryRemove(type.FullName, out var pis))
+            {
+                foreach (var prop in pis)
+                {
+                    PropertyAccessors.TryRemove(prop, out _);
+                }
+            }
+
+            var properties = type.GetProperties().Where(IsWriteable).ToArray();
+            TypeProperties[type.FullName] = properties;
+        }
+
+        protected bool IsWriteable(PropertyInfo pi)
+        {
+            return
+                pi.Name != nameof(IIndex.Id) &&
+                // don't read DocumentId when on a MapIndex as it might be used to 
+                // read the DocumentId directly from an Index query
+                pi.Name != "DocumentId"
+                ;
+        }
+    }
+}

src/YesSql.Core/Commands/IndexCommand.cs

@@ -15,16 +15,15 @@ namespace YesSql.Commands
 {
     public abstract class IndexCommand : IIndexCommand
     {
+        private const string _separator = ", ";
         protected const string ParameterSuffix = "_$$$";
 
-        protected readonly IStore _store;
+        private static IndexTypeCacheProvider IndexTypeCacheProvider;
+        protected static PropertyInfo[] KeysProperties = [typeof(IIndex).GetProperty("Id")];
 
-        private static readonly ConcurrentDictionary<PropertyInfo, PropertyInfoAccessor> PropertyAccessors = new();
-        private static readonly ConcurrentDictionary<string, PropertyInfo[]> TypeProperties = new();
         private static readonly ConcurrentDictionary<CompoundKey, string> InsertsList = new();
         private static readonly ConcurrentDictionary<CompoundKey, string> UpdatesList = new();
-
-        protected static PropertyInfo[] KeysProperties = new[] { typeof(IIndex).GetProperty("Id") };
+        protected readonly IStore _store;
 
         public abstract int ExecutionOrder { get; }
 
@@ -33,6 +32,7 @@ public IndexCommand(IIndex index, IStore store, string collection)
             Index = index;
             _store = store;
             Collection = collection;
+            IndexTypeCacheProvider = store.Configuration.IndexTypeCacheProvider;
         }
 
         public IIndex Index { get; }
@@ -47,13 +47,13 @@ public static void ResetQueryCache()
             UpdatesList.Clear();
         }
 
-        protected static void GetProperties(DbCommand command, object item, string suffix, ISqlDialect dialect)
+        protected void GetProperties(DbCommand command, object item, string suffix, ISqlDialect dialect)
         {
             var type = item.GetType();
 
             foreach (var property in TypePropertiesCache(type))
             {
-                var accessor = PropertyAccessors.GetOrAdd(property, p => new PropertyInfoAccessor(p));
+                var accessor = IndexTypeCacheProvider.GetPropertyAccessor(property);
 
                 var value = accessor.Get(item);
 
@@ -65,16 +65,9 @@ protected static void GetProperties(DbCommand command, object item, string suffi
             }
         }
 
-        protected static PropertyInfo[] TypePropertiesCache(Type type)
+        protected PropertyInfo[] TypePropertiesCache(Type type)
         {
-            if (TypeProperties.TryGetValue(type.FullName, out var pis))
-            {
-                return pis;
-            }
-
-            var properties = type.GetProperties().Where(IsWriteable).ToArray();
-            TypeProperties[type.FullName] = properties;
-            return properties;
+            return IndexTypeCacheProvider.GetTypeProperties(type);
         }
 
         protected string Inserts(Type type, ISqlDialect dialect)
@@ -102,7 +95,7 @@ protected string Inserts(Type type, ISqlDialect dialect)
                         sbColumnList.Append(dialect.QuoteForColumnName(property.Name));
                         if (i < allProperties.Length - 1)
                         {
-                            sbColumnList.Append(", ");
+                            sbColumnList.Append(_separator);
                         }
                     }
 
@@ -113,14 +106,14 @@ protected string Inserts(Type type, ISqlDialect dialect)
                         sbParameterList.Append("@").Append(property.Name).Append(ParameterSuffix);
                         if (i < allProperties.Length - 1)
                         {
-                            sbParameterList.Append(", ");
+                            sbParameterList.Append(_separator);
                         }
                     }
 
                     if (typeof(MapIndex).IsAssignableFrom(type))
                     {
                         // We can set the document id 
-                        sbColumnList.Append(", ").Append(dialect.QuoteForColumnName("DocumentId"));
+                        sbColumnList.Append(_separator).Append(dialect.QuoteForColumnName("DocumentId"));
                         sbParameterList.Append(", @DocumentId").Append(ParameterSuffix);
                     }
 
@@ -164,7 +157,7 @@ protected string Updates(Type type, ISqlDialect dialect)
                     values.Append(dialect.QuoteForColumnName(property.Name) + " = @" + property.Name + ParameterSuffix);
                     if (i < allProperties.Length - 1)
                     {
-                        values.Append(", ");
+                        values.Append(_separator);
                     }
                 }
 
@@ -174,16 +167,6 @@ protected string Updates(Type type, ISqlDialect dialect)
             return result;
         }
 
-        private static bool IsWriteable(PropertyInfo pi)
-        {
-            return
-                pi.Name != nameof(IIndex.Id) &&
-                // don't read DocumentId when on a MapIndex as it might be used to 
-                // read the DocumentId directly from an Index query
-                pi.Name != "DocumentId"
-                ;
-        }
-
         public abstract bool AddToBatch(ISqlDialect dialect, List<string> queries, DbCommand batchCommand, List<Action<DbDataReader>> actions, int index);
 
         private record CompoundKey(string Dialect, string Type, string Schema, string Prefix, string Collection);

src/YesSql.Core/Configuration.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Data;
 using YesSql.Data;
+using YesSql.Indexes;
 using YesSql.Serialization;
 using YesSql.Services;
 
@@ -15,7 +16,7 @@ public Configuration()
         {
             IdentifierAccessorFactory = new PropertyAccessorFactory("Id");
             VersionAccessorFactory = new PropertyAccessorFactory("Version");
-            ContentSerializer = new JsonContentSerializer();
+            ContentSerializer = new DefaultContentSerializer();
             IdGenerator = new DefaultIdGenerator();
             IsolationLevel = IsolationLevel.ReadCommitted;
             TablePrefix = "";
@@ -24,6 +25,7 @@ public Configuration()
             Logger = NullLogger.Instance;
             ConcurrentTypes = new HashSet<Type>();
             TableNameConvention = new DefaultTableNameConvention();
+            IndexTypeCacheProvider = new IndexTypeCacheProvider();
         }
 
         public IAccessorFactory IdentifierAccessorFactory { get; set; }
@@ -42,5 +44,6 @@ public Configuration()
         public ICommandInterpreter CommandInterpreter { get; set; }
         public ISqlDialect SqlDialect { get; set; }
         public IdentityColumnSize IdentityColumnSize { get; set; } = IdentityColumnSize.Int32;
+        public IndexTypeCacheProvider IndexTypeCacheProvider { get; set; }
     }
 }

src/YesSql.Core/Provider/ServiceCollectionExtensions.cs

@@ -21,7 +21,7 @@ public static IServiceCollection AddDbProvider(
 
             var config = new Configuration();
             setupAction.Invoke(config);
-            services.AddSingleton<IStore>(StoreFactory.CreateAndInitializeAsync(config).GetAwaiter().GetResult());
+            services.AddSingleton(StoreFactory.CreateAndInitializeAsync(config).GetAwaiter().GetResult());
 
             return services;
         }

src/YesSql.Core/Serialization/DefaultContentSerializer.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace YesSql.Serialization
+{
+    public class DefaultContentSerializer : IContentSerializer
+    {
+        private readonly JsonSerializerOptions _options;
+
+        public DefaultContentSerializer()
+        {
+            _options = new();
+            _options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
+            _options.Converters.Add(UtcDateTimeJsonConverter.Instance);
+            _options.Converters.Add(DynamicJsonConverter.Instance);
+        }
+
+        public DefaultContentSerializer(JsonSerializerOptions options)
+        {
+            _options = options;
+        }
+
+        public object Deserialize(string content, Type type)
+        {
+            return JsonSerializer.Deserialize(content, type, _options);
+        }
+
+        public string Serialize(object item)
+        {
+            return JsonSerializer.Serialize(item, _options);
+        }
+    }
+}