#106 - Implement discriminator in CouchContext

Author: matteobortolazzo

README.md

@@ -104,6 +104,7 @@ The produced Mango JSON:
 * [Indexing](#indexing)
   * [Index Options](#index-options)
   * [Partial Indexes](#partial-indexes)
+* [Database Splitting](#database-splitting)
 * [Local (non-replicating) Documents](#local-(non-replicating)-documents)
 * [Bookmark and Execution stats](#bookmark-and-execution-stats)
 * [Users](#users)
@@ -487,16 +488,7 @@ public class MyDeathStarContext : CouchContext
 {
     public CouchDatabase<Rebel> Rebels { get; set; }
 
-    protected override void OnConfiguring(CouchOptionsBuilder optionsBuilder)
-    {
-        optionsBuilder
-          .UseEndpoint("http://localhost:5984/")
-          .UseBasicAuthentication("admin", "admin")
-          // If it finds a index with the same name and ddoc (or null)
-          // but with different fields and/or sort order,
-          // it will override the index
-          .OverrideExistingIndexes(); 
-    }
+    // OnConfiguring(CouchOptionsBuilder optionsBuilder) { ... }
 
     protected override void OnDatabaseCreating(CouchDatabaseBuilder databaseBuilder)
     {
@@ -506,6 +498,34 @@ public class MyDeathStarContext : CouchContext
 }
 ```
 
+## Database Splitting
+
+It is possible to use the same database for multiple types:
+```csharp
+public class MyDeathStarContext : CouchContext
+{
+    public CouchDatabase<Rebel> Rebels { get; set; }
+    public CouchDatabase<Vehicle> Vehicles { get; set; }
+
+    // OnConfiguring(CouchOptionsBuilder optionsBuilder) { ... }
+
+    protected override void OnDatabaseCreating(CouchDatabaseBuilder databaseBuilder)
+    {
+        databaseBuilder.Document<Rebel>().ToDatabase("troups");
+        databaseBuilder.Document<Vehicle>().ToDatabase("troups");
+    }
+}
+```
+> When multiple `CouchDatabase` point to the same **database**, a `_discriminator` field is added on documents creation.
+>
+> When querying, a filter by `discriminator` is added automatically.
+
+If you are not using `CouchContext`, you can still use the database slit feature:
+```csharp
+var rebels = client.GetDatabase<Rebel>("troups", nameof(Rebel));
+var vehicles = client.GetDatabase<Vehicle>("troups", nameof(Vehicle));
+```
+
 ## Local (non-replicating) Documents
 
 The Local (non-replicating) document interface allows you to create local documents that are not replicated to other databases.

src/CouchDB.Driver/CouchClient.cs

@@ -361,6 +361,12 @@ protected virtual async Task DisposeAsync(bool disposing)
         private string GetClassName<TSource>()
         {
             Type type = typeof(TSource);
+            return GetClassName(type);
+        }
+
+        public string GetClassName(Type type)
+        {
+            Check.NotNull(type, nameof(type));
             return type.GetName(_options);
         }
     }

src/CouchDB.Driver/CouchContext.cs

@@ -18,7 +18,7 @@ protected virtual void OnDatabaseCreating(CouchDatabaseBuilder databaseBuilder)
 
         private static readonly MethodInfo InitDatabasesGenericMethod
             = typeof(CouchContext).GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
-                .Single(mi => mi.Name == nameof(InitDatabasesAsync));
+                .Single(mi => mi.Name == nameof(InitDatabaseAsync));
 
         private static readonly MethodInfo ApplyDatabaseChangesGenericMethod
             = typeof(CouchContext).GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
@@ -39,20 +39,9 @@ protected CouchContext(CouchOptions options)
 #pragma warning restore CA2214 // Do not call overridable methods in constructors
 
             Client = new CouchClient(options);
-            IEnumerable<PropertyInfo> databasePropertyInfos = GetDatabaseProperties();
 
-            foreach (PropertyInfo dbProperty in databasePropertyInfos)
-            {
-                Type documentType = dbProperty.PropertyType.GetGenericArguments()[0];
-
-                var initDatabasesTask = (Task)InitDatabasesGenericMethod.MakeGenericMethod(documentType)
-                    .Invoke(this, new object[] {dbProperty, options});
-                initDatabasesTask.ConfigureAwait(false).GetAwaiter().GetResult();
-
-                var applyDatabaseChangesTask = (Task)ApplyDatabaseChangesGenericMethod.MakeGenericMethod(documentType)
-                    .Invoke(this, new object[] { dbProperty, options, databaseBuilder });
-                applyDatabaseChangesTask.ConfigureAwait(false).GetAwaiter().GetResult();
-            }
+            SetupDiscriminators(databaseBuilder);
+            InitializeDatabases(options, databaseBuilder);
         }
 
         public async ValueTask DisposeAsync()
@@ -69,26 +58,76 @@ protected virtual async Task DisposeAsync(bool disposing)
             }
         }
 
-        private async Task InitDatabasesAsync<TSource>(PropertyInfo propertyInfo, CouchOptions options)
+        private static void SetupDiscriminators(CouchDatabaseBuilder databaseBuilder)
+        {
+            // Get all options that share the database with another one
+            IEnumerable<KeyValuePair<Type, CouchDocumentBuilder>>? sharedDatabase = databaseBuilder.DocumentBuilders
+                .Where(opt => opt.Value.Database != null)
+                .GroupBy(v => v.Value.Database)
+                .Where(g => g.Count() > 1)
+                .SelectMany(g => g);
+            foreach (KeyValuePair<Type, CouchDocumentBuilder> option in sharedDatabase)
+            {
+                option.Value.Discriminator = option.Key.Name;
+            }
+        }
+
+        private void InitializeDatabases(CouchOptions options, CouchDatabaseBuilder databaseBuilder)
+        {
+            foreach (PropertyInfo dbProperty in GetDatabaseProperties())
+            {
+                Type documentType = dbProperty.PropertyType.GetGenericArguments()[0];
+
+                var initDatabasesTask = (Task)InitDatabasesGenericMethod.MakeGenericMethod(documentType)
+                    .Invoke(this, new object[] { dbProperty, options, databaseBuilder });
+                initDatabasesTask.ConfigureAwait(false).GetAwaiter().GetResult();
+
+                var applyDatabaseChangesTask = (Task)ApplyDatabaseChangesGenericMethod.MakeGenericMethod(documentType)
+                    .Invoke(this, new object[] { dbProperty, options, databaseBuilder });
+                applyDatabaseChangesTask.ConfigureAwait(false).GetAwaiter().GetResult();
+            }
+        }
+
+        private async Task InitDatabaseAsync<TSource>(PropertyInfo propertyInfo, CouchOptions options, CouchDatabaseBuilder databaseBuilder)
             where TSource : CouchDocument
         {
-            ICouchDatabase<TSource> database = options.CheckDatabaseExists
-                ? await Client.GetOrCreateDatabaseAsync<TSource>().ConfigureAwait(false)
-                : Client.GetDatabase<TSource>();
+            ICouchDatabase<TSource> database;
+            Type documentType = typeof(TSource);
+
+            if (databaseBuilder.DocumentBuilders.ContainsKey(documentType))
+            {
+                var documentBuilder = (CouchDocumentBuilder<TSource>)databaseBuilder.DocumentBuilders[documentType];
+                var databaseName = documentBuilder.Database ?? Client.GetClassName(documentType);
+                database = options.CheckDatabaseExists
+                    ? await Client.GetOrCreateDatabaseAsync<TSource>(databaseName, documentBuilder.Shards, documentBuilder.Replicas, documentBuilder.Discriminator).ConfigureAwait(false)
+                    : Client.GetDatabase<TSource>(databaseName, documentBuilder.Discriminator);
+            }
+            else
+            {
+                database = options.CheckDatabaseExists
+                    ? await Client.GetOrCreateDatabaseAsync<TSource>().ConfigureAwait(false)
+                    : Client.GetDatabase<TSource>();
+            }
 
             propertyInfo.SetValue(this, database);
         }
 
         private async Task ApplyDatabaseChangesAsync<TSource>(PropertyInfo propertyInfo, CouchOptions options, CouchDatabaseBuilder databaseBuilder)
-            where TSource: CouchDocument
+            where TSource : CouchDocument
         {
-            if (!databaseBuilder.DocumentBuilders.ContainsKey(typeof(TSource)))
+            Type documentType = typeof(TSource);
+            if (!databaseBuilder.DocumentBuilders.ContainsKey(documentType))
             {
                 return;
             }
 
             var database = (CouchDatabase<TSource>)propertyInfo.GetValue(this);
-            var documentBuilder = (CouchDocumentBuilder<TSource>)databaseBuilder.DocumentBuilders[typeof(TSource)];
+            var documentBuilder = (CouchDocumentBuilder<TSource>)databaseBuilder.DocumentBuilders[documentType];
+
+            if (!documentBuilder.IndexDefinitions.Any())
+            {
+                return;
+            }
 
             List<IndexInfo> indexes = await database.GetIndexesAsync().ConfigureAwait(false);
 
@@ -125,7 +164,7 @@ await database.CreateIndexAsync(
             {
                 return;
             }
-            
+
             IndexDefinition indexDefinition = database.NewIndexBuilder(indexSetup.IndexBuilderAction).Build();
             if (!AreFieldsEqual(currentIndex.Fields, indexDefinition.Fields))
             {

src/CouchDB.Driver/CouchDB.Driver.csproj

@@ -39,7 +39,6 @@
 
   <ItemGroup>
     <Folder Include="License\" />
-    <Folder Include="Attributes\" />
   </ItemGroup>
 
 </Project>

src/CouchDB.Driver/ICouchClient.cs

@@ -160,6 +160,13 @@ Task<ICouchDatabase<TSource>> GetOrCreateDatabaseAsync<TSource>(int? shards = nu
         /// <returns>A task that represents the asynchronous operation. The task result contains the sequence of all active tasks.</returns>
         Task<IEnumerable<CouchActiveTask>> GetActiveTasksAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Get the database name for the given type.
+        /// </summary>
+        /// <param name="type">The type of database documents.</param>
+        /// <returns></returns>
+        string GetClassName(Type type);
+
         /// <summary>
         /// URI of the CouchDB endpoint.
         /// </summary>

src/CouchDB.Driver/Options/CouchDatabaseBuilder.cs

@@ -6,11 +6,11 @@ namespace CouchDB.Driver.Options
 {
     public class CouchDatabaseBuilder
     {
-        internal readonly Dictionary<Type, object> DocumentBuilders;
+        internal readonly Dictionary<Type, CouchDocumentBuilder> DocumentBuilders;
 
         internal CouchDatabaseBuilder()
         {
-            DocumentBuilders = new Dictionary<Type, object>();
+            DocumentBuilders = new Dictionary<Type, CouchDocumentBuilder>();
         }
 
         public CouchDocumentBuilder<TSource> Document<TSource>()

src/CouchDB.Driver/Options/CouchDocumentBuilder.cs

@@ -1,26 +1,10 @@
-using System;
-using System.Collections.Generic;
-using CouchDB.Driver.Indexes;
-using CouchDB.Driver.Types;
-
-namespace CouchDB.Driver.Options
+namespace CouchDB.Driver.Options
 {
-    public class CouchDocumentBuilder<TSource>
-        where TSource : CouchDocument
+    public abstract class CouchDocumentBuilder
     {
-        internal List<IndexSetupDefinition<TSource>> IndexDefinitions { get; }
-
-        internal CouchDocumentBuilder()
-        {
-            IndexDefinitions = new List<IndexSetupDefinition<TSource>>();
-        }
-
-        public CouchDocumentBuilder<TSource> HasIndex(string name, Action<IIndexBuilder<TSource>> indexBuilderAction,
-            IndexOptions? options = null)
-        {
-            var indexDefinition = new IndexSetupDefinition<TSource>(name, indexBuilderAction, options);
-            IndexDefinitions.Add(indexDefinition);
-            return this;
-        }
-    }
+        internal string? Database { get; set; }
+        internal int? Shards { get; set; }
+        internal int? Replicas { get; set; }
+        internal string? Discriminator { get; set; }
+    }    
 }

src/CouchDB.Driver/Options/CouchDocumentBuilder`.cs

@@ -0,0 +1,44 @@
+using CouchDB.Driver.Indexes;
+using CouchDB.Driver.Types;
+using System;
+using System.Collections.Generic;
+
+namespace CouchDB.Driver.Options
+{
+    public class CouchDocumentBuilder<TSource> : CouchDocumentBuilder
+        where TSource : CouchDocument
+    {
+        internal List<IndexSetupDefinition<TSource>> IndexDefinitions { get; }
+
+        internal CouchDocumentBuilder()
+        {
+            IndexDefinitions = new List<IndexSetupDefinition<TSource>>();
+        }
+
+        public CouchDocumentBuilder<TSource> ToDatabase(string database)
+        {
+            Database = database;
+            return this;
+        }
+
+        public CouchDocumentBuilder<TSource> WithShards(int shards)
+        {
+            Shards = shards;
+            return this;
+        }
+
+        public CouchDocumentBuilder<TSource> WithReplicas(int replicas)
+        {
+            Replicas = replicas;
+            return this;
+        }
+
+        public CouchDocumentBuilder<TSource> HasIndex(string name, Action<IIndexBuilder<TSource>> indexBuilderAction,
+            IndexOptions? options = null)
+        {
+            var indexDefinition = new IndexSetupDefinition<TSource>(name, indexBuilderAction, options);
+            IndexDefinitions.Add(indexDefinition);
+            return this;
+        }
+    }
+}

src/CouchDB.Driver/Query/QueryOptimizer.cs

@@ -15,6 +15,8 @@ namespace CouchDB.Driver.Query
     /// </summary>
     internal class QueryOptimizer : ExpressionVisitor, IQueryOptimizer
     {
+        private static readonly MethodInfo WrapInWhereGenericMethod
+               = typeof(MethodCallExpressionBuilder).GetMethod(nameof(MethodCallExpressionBuilder.WrapInDiscriminatorFilter));
         private bool _isVisitingWhereMethodOrChild;
         private readonly Queue<MethodCallExpression> _nextWhereCalls;
 
@@ -28,10 +30,7 @@ public Expression Optimize(Expression e, string? discriminator)
             if (discriminator is not null)
             {
                 Type? sourceType = e.Type.GetGenericArguments()[0];
-                MethodInfo? wrapInWhere = typeof(MethodCallExpressionBuilder)
-                .GetMethod(nameof(MethodCallExpressionBuilder.WrapInDiscriminatorFilter))
-                .MakeGenericMethod(new[] { sourceType });
-
+                MethodInfo? wrapInWhere = WrapInWhereGenericMethod.MakeGenericMethod(new[] { sourceType });
                 e = (Expression)wrapInWhere.Invoke(null, new object[] { e, discriminator });
             }