#150 - Supports split database field override

matteobortolazzo · matteobortolazzo · commit e823df123913 · 2023-06-21T00:22:46.000+02:00
diff --git a/README.md b/README.md
@@ -536,6 +536,8 @@ public class MyDeathStarContext : CouchContext
 > When multiple `CouchDatabase` point to the same **database**, a `split_discriminator` field is added on document creation.
 >
 > When querying, a filter by `split_discriminator` is added automatically.
+> 
+> The field name can be overriden with the `WithDatabaseSplitDiscriminator`.
 
 If you are not using `CouchContext`, you can still use the database split feature:
 ```csharp
diff --git a/src/CouchDB.Driver/CouchClient.cs b/src/CouchDB.Driver/CouchClient.cs
@@ -23,6 +23,7 @@ namespace CouchDB.Driver
     /// </summary>
     public partial class CouchClient : ICouchClient
     {
+        public const string DefaultDatabaseSplitDiscriminator = "split_discriminator";
         private DateTime? _cookieCreationDate;
         private string? _cookieToken;
 
@@ -91,7 +92,7 @@ private IFlurlClient GetConfiguredClient() =>
             {
                 s.JsonSerializer = new NewtonsoftJsonSerializer(new JsonSerializerSettings
                 {
-                    ContractResolver = new CouchContractResolver(_options.PropertiesCase),
+                    ContractResolver = new CouchContractResolver(_options.PropertiesCase, _options.DatabaseSplitDiscriminator),
                     NullValueHandling = _options.NullValueHandling ?? NullValueHandling.Include
                 });
                 s.BeforeCallAsync = OnBeforeCallAsync;
diff --git a/src/CouchDB.Driver/Helpers/CouchContractResolver.cs b/src/CouchDB.Driver/Helpers/CouchContractResolver.cs
@@ -9,26 +9,32 @@ namespace CouchDB.Driver.Helpers
     public class CouchContractResolver : DefaultContractResolver
     {
         private readonly PropertyCaseType _propertyCaseType;
+        private readonly string? _databaseSplitDiscriminator;
 
-        internal CouchContractResolver(PropertyCaseType propertyCaseType)
+        internal CouchContractResolver(PropertyCaseType propertyCaseType, string? databaseSplitDiscriminator)
         {
             _propertyCaseType = propertyCaseType;
+            _databaseSplitDiscriminator = databaseSplitDiscriminator;
         }
 
         protected override JsonProperty? CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
         {
             Check.NotNull(member, nameof(member));
 
             JsonProperty property = base.CreateProperty(member, memberSerialization);
-            if (property != null && !property.Ignored)
+            if (property is { Ignored: false })
             {
-                var declaringNamespace = member.DeclaringType?.Namespace;
-                if (declaringNamespace != null && !declaringNamespace.Contains("CouchDB.Driver"))
+                if (member.DeclaringType!.Assembly != GetType().Assembly)
                 {
                     property.PropertyName = member.GetCouchPropertyName(_propertyCaseType);
                 }
             }
+
+            if (property.PropertyName == CouchClient.DefaultDatabaseSplitDiscriminator && !string.IsNullOrWhiteSpace(_databaseSplitDiscriminator))
+            {
+                property.PropertyName = _databaseSplitDiscriminator;
+            }
             return property;
         }
     }
-}
+}
diff --git a/src/CouchDB.Driver/Options/CouchOptions.cs b/src/CouchDB.Driver/Options/CouchOptions.cs
@@ -27,6 +27,8 @@ public abstract class CouchOptions
         internal bool PluralizeEntities { get; set; }
         internal DocumentCaseType DocumentsCaseType { get; set; }
         internal PropertyCaseType PropertiesCase { get; set; }
+        
+        internal string? DatabaseSplitDiscriminator { get; set; }
         internal NullValueHandling? NullValueHandling { get; set; }
         internal bool LogOutOnDispose { get; set; }
 
diff --git a/src/CouchDB.Driver/Options/CouchOptionsBuilder.cs b/src/CouchDB.Driver/Options/CouchOptionsBuilder.cs
@@ -193,6 +193,17 @@ public virtual CouchOptionsBuilder SetPropertyCase(PropertyCaseType type)
             return this;
         }
 
+        /// <summary>
+        /// Set the field to use to identify document types. Default: <c>split_discriminator</c>.
+        /// </summary>
+        /// <param name="databaseSplitDiscriminator">The document field to use as discriminator.</param>
+        /// <returns>Return the current instance to chain calls.</returns>
+        public virtual CouchOptionsBuilder WithDatabaseSplitDiscriminator(string databaseSplitDiscriminator)
+        {
+            Options.DatabaseSplitDiscriminator = databaseSplitDiscriminator;
+            return this;
+        }
+
         /// <summary>
         /// Sets how to handle null values during serialization.
         /// </summary>
diff --git a/src/CouchDB.Driver/Options/CouchOptionsBuilder`.cs b/src/CouchDB.Driver/Options/CouchOptionsBuilder`.cs
@@ -129,6 +129,14 @@ public CouchOptionsBuilder(CouchOptions<TContext> options) : base(options) { }
         /// <returns>Return the current instance to chain calls.</returns>
         public new virtual CouchOptionsBuilder<TContext> SetPropertyCase(PropertyCaseType type)
             => (CouchOptionsBuilder<TContext>)base.SetPropertyCase(type);
+        
+        /// <summary>
+        /// Set the field to use to identify document types. Default: <c>split_discriminator</c>.
+        /// </summary>
+        /// <param name="databaseSplitDiscriminator">The document field to use as discriminator.</param>
+        /// <returns>Return the current instance to chain calls.</returns>
+        public new virtual CouchOptionsBuilder<TContext> WithDatabaseSplitDiscriminator(string databaseSplitDiscriminator)
+            => (CouchOptionsBuilder<TContext>)base.WithDatabaseSplitDiscriminator(databaseSplitDiscriminator);
 
         /// <summary>
         /// Sets how to handle null values during serialization.
diff --git a/src/CouchDB.Driver/Query/QueryOptimizer.cs b/src/CouchDB.Driver/Query/QueryOptimizer.cs
@@ -16,7 +16,7 @@ namespace CouchDB.Driver.Query
     /// </summary>
     internal class QueryOptimizer : ExpressionVisitor, IQueryOptimizer
     {
-        private static readonly MethodInfo WrapInWhereGenericMethod
+        private static readonly MethodInfo WrapInDiscriminatorFilterGenericMethod
                = typeof(MethodCallExpressionBuilder).GetMethod(nameof(MethodCallExpressionBuilder.WrapInDiscriminatorFilter));
         private bool _isVisitingWhereMethodOrChild;
         private readonly Queue<MethodCallExpression> _nextWhereCalls;
@@ -33,13 +33,13 @@ public Expression Optimize(Expression e, string? discriminator)
                 if (e.Type.IsGenericType)
                 {
                     Type? sourceType = e.Type.GetGenericArguments()[0];
-                    MethodInfo wrapInWhere = WrapInWhereGenericMethod.MakeGenericMethod(sourceType);
+                    MethodInfo wrapInWhere = WrapInDiscriminatorFilterGenericMethod.MakeGenericMethod(sourceType);
                     e = (Expression)wrapInWhere.Invoke(null, new object[] { e, discriminator });
                 }
                 else
                 {
                     Type sourceType = e.Type;
-                    MethodInfo wrapInWhere = WrapInWhereGenericMethod.MakeGenericMethod(sourceType);
+                    MethodInfo wrapInWhere = WrapInDiscriminatorFilterGenericMethod.MakeGenericMethod(sourceType);
 
                     var rootMethodCallExpression = e as MethodCallExpression;
                     Expression source = rootMethodCallExpression!.Arguments[0];
diff --git a/src/CouchDB.Driver/Query/Translators/MemberExpressionTranslator.cs b/src/CouchDB.Driver/Query/Translators/MemberExpressionTranslator.cs
@@ -1,14 +1,23 @@
 ﻿using System.Linq.Expressions;
 using CouchDB.Driver.Extensions;
+using CouchDB.Driver.Types;
 
 namespace CouchDB.Driver.Query
 {
     internal partial class QueryTranslator
     {
         protected override Expression VisitMember(MemberExpression m)
         {
+            // Override database split if needed
+            if (m.Member.DeclaringType == typeof(CouchDocument) &&
+                m.Member.Name == nameof(CouchDocument.SplitDiscriminator) &&
+                !string.IsNullOrWhiteSpace(_options.DatabaseSplitDiscriminator))
+            {
+                _sb.Append($"\"{_options.DatabaseSplitDiscriminator}\"");
+                return m;
+            }
+            
             var propName = m.GetPropertyName(_options);
-
             _sb.Append($"\"{propName}\"");
             return m;
         }
diff --git a/src/CouchDB.Driver/Types/CouchDocument.cs b/src/CouchDB.Driver/Types/CouchDocument.cs
@@ -111,7 +111,7 @@ protected CouchDocument()
         /// Used for database splitting
         /// </summary>
         [DataMember]
-        [JsonProperty("split_discriminator", NullValueHandling = NullValueHandling.Ignore)]
+        [JsonProperty(CouchClient.DefaultDatabaseSplitDiscriminator, NullValueHandling = NullValueHandling.Ignore)]
         internal string SplitDiscriminator { get; set; }
 
         [OnDeserialized]
diff --git a/tests/CouchDB.Driver.E2ETests/Client_Tests.cs b/tests/CouchDB.Driver.E2ETests/Client_Tests.cs
@@ -5,10 +5,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 using CouchDB.Driver.E2ETests;
-using CouchDB.Driver.E2ETests._Models;
+using CouchDB.Driver.E2ETests.Models;
 using CouchDB.Driver.Extensions;
 using CouchDB.Driver.Local;
-using E2ETests.Models;
 using Xunit;
 
 namespace CouchDB.Driver.E2E
diff --git a/tests/CouchDB.Driver.E2ETests/MyDeathStarContext.cs b/tests/CouchDB.Driver.E2ETests/MyDeathStarContext.cs
@@ -1,5 +1,5 @@
-﻿using CouchDB.Driver.Options;
-using E2ETests.Models;
+﻿using CouchDB.Driver.E2ETests.Models;
+using CouchDB.Driver.Options;
 
 namespace CouchDB.Driver.E2ETests
 {
diff --git a/tests/CouchDB.Driver.E2ETests/_Models/Rebel.cs b/tests/CouchDB.Driver.E2ETests/_Models/Rebel.cs
@@ -1,7 +1,7 @@
 ﻿using System.Collections.Generic;
 using CouchDB.Driver.Types;
 
-namespace E2ETests.Models
+namespace CouchDB.Driver.E2ETests.Models
 {
     public class Rebel : CouchDocument
     {
diff --git a/tests/CouchDB.Driver.E2ETests/_Models/RebelSettings.cs b/tests/CouchDB.Driver.E2ETests/_Models/RebelSettings.cs
@@ -1,6 +1,6 @@
 ﻿using CouchDB.Driver.Types;
 
-namespace CouchDB.Driver.E2ETests._Models
+namespace CouchDB.Driver.E2ETests.Models
 {
     public class RebelSettings: CouchDocument
     {
diff --git a/tests/CouchDB.Driver.UnitTests/CouchDbContext_Tests.cs b/tests/CouchDB.Driver.UnitTests/CouchDbContext_Tests.cs
@@ -35,6 +35,31 @@ protected override void OnDatabaseCreating(CouchDatabaseBuilder databaseBuilder)
                     .ToDatabase("shared-rebels");
             }
         }
+        
+        private class MyDeathStarContextCustomSplit: CouchContext
+        {
+            public CouchDatabase<OtherRebel> OtherRebels { get; set; }
+            public CouchDatabase<SimpleRebel> SimpleRebels { get; set; }
+
+            protected override void OnConfiguring(CouchOptionsBuilder optionsBuilder)
+            {
+                optionsBuilder
+                    .UseEndpoint("http://localhost:5984/")
+                    .UseBasicAuthentication("admin", "admin")
+                    .WithDatabaseSplitDiscriminator("docType");
+            }
+
+            protected override void OnDatabaseCreating(CouchDatabaseBuilder databaseBuilder)
+            {
+                databaseBuilder
+                    .Document<OtherRebel>()
+                    .ToDatabase("shared-rebels");
+
+                databaseBuilder
+                    .Document<SimpleRebel>()
+                    .ToDatabase("shared-rebels");
+            }
+        }
 
         [Fact]
         public async Task Context_Query()
@@ -111,6 +136,50 @@ await context.OtherRebels.AddAsync(new OtherRebel
             Assert.Equal(@"{""selector"":{""split_discriminator"":""OtherRebel""}}", httpTest.CallLog[2].RequestBody);
         }
 
+        [Fact]
+        public async Task Context_Query_Discriminator_Override()
+        {
+            using var httpTest = new HttpTest();
+            httpTest.RespondWithJson(new
+            {
+                Id = "176694",
+                Ok = true,
+                Rev = "1-54f8e950cc338d2385d9b0cda2fd918e"
+            });
+            httpTest.RespondWithJson(new
+            {
+                Id = "173694",
+                Ok = true,
+                Rev = "1-54f8e950cc338d2385d9b0cda2fd918e"
+            });
+            httpTest.RespondWithJson(new
+            {
+                docs = new object[] {
+                    new {
+                        Id = "176694",
+                        Rev = "1-54f8e950cc338d2385d9b0cda2fd918e",
+                        Name = "Luke"
+                    }
+                }
+            });
+
+            await using var context = new MyDeathStarContextCustomSplit();
+            await context.SimpleRebels.AddAsync(new SimpleRebel
+            {
+                Name = "Leia"
+            });
+            await context.OtherRebels.AddAsync(new OtherRebel
+            {
+                Name = "Luke"
+            });
+            var result = await context.OtherRebels.ToListAsync();
+            Assert.NotEmpty(result);
+            Assert.Equal("Luke", result[0].Name);
+            Assert.Equal(@"{""name"":""Leia"",""age"":0,""docType"":""SimpleRebel"",""_attachments"":{}}", httpTest.CallLog[0].RequestBody);
+            Assert.Equal(@"{""rebel_bith_date"":""0001-01-01T00:00:00"",""name"":""Luke"",""age"":0,""isJedi"":false,""species"":0,""guid"":""00000000-0000-0000-0000-000000000000"",""docType"":""OtherRebel"",""_attachments"":{}}", httpTest.CallLog[1].RequestBody);
+            Assert.Equal(@"{""selector"":{""docType"":""OtherRebel""}}", httpTest.CallLog[2].RequestBody);
+        }
+        
         [Fact]
         public async Task Context_Query_MultiThread()
         {

Original file line number	Diff line number	Diff line change
`@@ -536,6 +536,8 @@ public class MyDeathStarContext : CouchContext`
`536`	`536`	> When multiple `CouchDatabase` point to the same database, a `split_discriminator` field is added on document creation.
`537`	`537`	`>`
`538`	`538`	> When querying, a filter by `split_discriminator` is added automatically.
	`539`	`+>`
	`540`	+> The field name can be overriden with the `WithDatabaseSplitDiscriminator`.
`539`	`541`
`540`	`542`	If you are not using `CouchContext`, you can still use the database split feature:
`541`	`543`	```csharp
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ namespace CouchDB.Driver`
`23`	`23`	`/// </summary>`
`24`	`24`	`public partial class CouchClient : ICouchClient`
`25`	`25`	`{`
	`26`	`+ public const string DefaultDatabaseSplitDiscriminator = "split_discriminator";`
`26`	`27`	`private DateTime? _cookieCreationDate;`
`27`	`28`	`private string? _cookieToken;`
`28`	`29`
`@@ -91,7 +92,7 @@ private IFlurlClient GetConfiguredClient() =>`
`91`	`92`	`{`
`92`	`93`	`s.JsonSerializer = new NewtonsoftJsonSerializer(new JsonSerializerSettings`
`93`	`94`	`{`
`94`		`- ContractResolver = new CouchContractResolver(_options.PropertiesCase),`
	`95`	`+ ContractResolver = new CouchContractResolver(_options.PropertiesCase, _options.DatabaseSplitDiscriminator),`
`95`	`96`	`NullValueHandling = _options.NullValueHandling ?? NullValueHandling.Include`
`96`	`97`	`});`
`97`	`98`	`s.BeforeCallAsync = OnBeforeCallAsync;`
Original file line number	Diff line number	Diff line change
`@@ -9,26 +9,32 @@ namespace CouchDB.Driver.Helpers`
`9`	`9`	`public class CouchContractResolver : DefaultContractResolver`
`10`	`10`	`{`
`11`	`11`	`private readonly PropertyCaseType _propertyCaseType;`
	`12`	`+ private readonly string? _databaseSplitDiscriminator;`
`12`	`13`
`13`		`- internal CouchContractResolver(PropertyCaseType propertyCaseType)`
	`14`	`+ internal CouchContractResolver(PropertyCaseType propertyCaseType, string? databaseSplitDiscriminator)`
`14`	`15`	`{`
`15`	`16`	`_propertyCaseType = propertyCaseType;`
	`17`	`+ _databaseSplitDiscriminator = databaseSplitDiscriminator;`
`16`	`18`	`}`
`17`	`19`
`18`	`20`	`protected override JsonProperty? CreateProperty(MemberInfo member, MemberSerialization memberSerialization)`
`19`	`21`	`{`
`20`	`22`	`Check.NotNull(member, nameof(member));`
`21`	`23`
`22`	`24`	`JsonProperty property = base.CreateProperty(member, memberSerialization);`
`23`		`- if (property != null && !property.Ignored)`
	`25`	`+ if (property is { Ignored: false })`
`24`	`26`	`{`
`25`		`- var declaringNamespace = member.DeclaringType?.Namespace;`
`26`		`- if (declaringNamespace != null && !declaringNamespace.Contains("CouchDB.Driver"))`
	`27`	`+ if (member.DeclaringType!.Assembly != GetType().Assembly)`
`27`	`28`	`{`
`28`	`29`	`property.PropertyName = member.GetCouchPropertyName(_propertyCaseType);`
`29`	`30`	`}`
`30`	`31`	`}`
	`32`	`+`
	`33`	`+ if (property.PropertyName == CouchClient.DefaultDatabaseSplitDiscriminator && !string.IsNullOrWhiteSpace(_databaseSplitDiscriminator))`
	`34`	`+ {`
	`35`	`+ property.PropertyName = _databaseSplitDiscriminator;`
	`36`	`+ }`
`31`	`37`	`return property;`
`32`	`38`	`}`
`33`	`39`	`}`
`34`		`-}`
	`40`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ namespace CouchDB.Driver.Query`
`16`	`16`	`/// </summary>`
`17`	`17`	`internal class QueryOptimizer : ExpressionVisitor, IQueryOptimizer`
`18`	`18`	`{`
`19`		`- private static readonly MethodInfo WrapInWhereGenericMethod`
	`19`	`+ private static readonly MethodInfo WrapInDiscriminatorFilterGenericMethod`
`20`	`20`	`= typeof(MethodCallExpressionBuilder).GetMethod(nameof(MethodCallExpressionBuilder.WrapInDiscriminatorFilter));`
`21`	`21`	`private bool _isVisitingWhereMethodOrChild;`
`22`	`22`	`private readonly Queue<MethodCallExpression> _nextWhereCalls;`
`@@ -33,13 +33,13 @@ public Expression Optimize(Expression e, string? discriminator)`
`33`	`33`	`if (e.Type.IsGenericType)`
`34`	`34`	`{`
`35`	`35`	`Type? sourceType = e.Type.GetGenericArguments()[0];`
`36`		`- MethodInfo wrapInWhere = WrapInWhereGenericMethod.MakeGenericMethod(sourceType);`
	`36`	`+ MethodInfo wrapInWhere = WrapInDiscriminatorFilterGenericMethod.MakeGenericMethod(sourceType);`
`37`	`37`	`e = (Expression)wrapInWhere.Invoke(null, new object[] { e, discriminator });`
`38`	`38`	`}`
`39`	`39`	`else`
`40`	`40`	`{`
`41`	`41`	`Type sourceType = e.Type;`
`42`		`- MethodInfo wrapInWhere = WrapInWhereGenericMethod.MakeGenericMethod(sourceType);`
	`42`	`+ MethodInfo wrapInWhere = WrapInDiscriminatorFilterGenericMethod.MakeGenericMethod(sourceType);`
`43`	`43`
`44`	`44`	`var rootMethodCallExpression = e as MethodCallExpression;`
`45`	`45`	`Expression source = rootMethodCallExpression!.Arguments[0];`
Original file line number	Diff line number	Diff line change
`@@ -1,14 +1,23 @@`
`1`	`1`	`using System.Linq.Expressions;`
`2`	`2`	`using CouchDB.Driver.Extensions;`
	`3`	`+using CouchDB.Driver.Types;`
`3`	`4`
`4`	`5`	`namespace CouchDB.Driver.Query`
`5`	`6`	`{`
`6`	`7`	`internal partial class QueryTranslator`
`7`	`8`	`{`
`8`	`9`	`protected override Expression VisitMember(MemberExpression m)`
`9`	`10`	`{`
	`11`	`+ // Override database split if needed`
	`12`	`+ if (m.Member.DeclaringType == typeof(CouchDocument) &&`
	`13`	`+ m.Member.Name == nameof(CouchDocument.SplitDiscriminator) &&`
	`14`	`+ !string.IsNullOrWhiteSpace(_options.DatabaseSplitDiscriminator))`
	`15`	`+ {`
	`16`	`+ _sb.Append($"\"{_options.DatabaseSplitDiscriminator}\"");`
	`17`	`+ return m;`
	`18`	`+ }`
	`19`	`+`
`10`	`20`	`var propName = m.GetPropertyName(_options);`
`11`		`-`
`12`	`21`	`_sb.Append($"\"{propName}\"");`
`13`	`22`	`return m;`
`14`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`		`-using CouchDB.Driver.Options;`
`2`		`-using E2ETests.Models;`
	`1`	`+using CouchDB.Driver.E2ETests.Models;`
	`2`	`+using CouchDB.Driver.Options;`
`3`	`3`
`4`	`4`	`namespace CouchDB.Driver.E2ETests`
`5`	`5`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using CouchDB.Driver.Types;`
`3`	`3`
`4`		`-namespace E2ETests.Models`
	`4`	`+namespace CouchDB.Driver.E2ETests.Models`
`5`	`5`	`{`
`6`	`6`	`public class Rebel : CouchDocument`
`7`	`7`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`using CouchDB.Driver.Types;`
`2`	`2`
`3`		`-namespace CouchDB.Driver.E2ETests._Models`
	`3`	`+namespace CouchDB.Driver.E2ETests.Models`
`4`	`4`	`{`
`5`	`5`	`public class RebelSettings: CouchDocument`
`6`	`6`	`{`