Add support for named clients in mongo collection (#187)

Author: Yalpe

README.md

@@ -224,6 +224,18 @@ public class PersonDocument : IMongoDocument
 }
 ```
 
+For multiple clusters setup, you can specify which named client owns the collection using `ClientName`. This will have the following effect:
+* The injection of `IMongoCollection<TDocument>` will resolve the collection from the named client instead of the default client
+* The index creation from `UpdateIndexesAsync` will route each document type to its declared cluster automatically when scanning an assembly (no need to call `UpdateIndexesAsync` once per client)
+
+```csharp
+[MongoCollection("people", ClientName = "anotherCluster", DatabaseName = "foo")]
+public class PersonDocument : IMongoDocument
+{
+    // [...]
+}
+```
+
 ### With Configuration
 
 In certain scenarios, like in Domain Driven Design (DDD), one would like to persist their Domain Aggregates as is in the Document Database. These Domain objects are not aware of how they are persisted. They cannot be decorated with Persistence level attributes (ie `[MongoCollection()]`), nor can they implement `IMongoDocument`.
@@ -240,9 +252,10 @@ public sealed class Person
 ```csharp
 internal sealed class PersonConfiguration: IMongoCollectionConfiguration<Person>
 {
-    public void Configure(IMongoCollectionBuilder<Person> builder) 
+    public void Configure(IMongoCollectionBuilder<Person> builder)
     {
         builder.CollectionName("people");
+        builder.ClientName("anotherCluster"); // optional, not calling this will use the default client
         builder.DatabaseName("foo"); // optional, not calling this will use the default database
     }
 }

src/Workleap.Extensions.Mongo.Abstractions/IMongoCollectionBuilder.cs

@@ -7,6 +7,8 @@ public interface IMongoCollectionBuilder<TDocument>
 {
     IMongoCollectionBuilder<TDocument> CollectionName(string collectionName);
 
+    IMongoCollectionBuilder<TDocument> ClientName(string clientName);
+
     IMongoCollectionBuilder<TDocument> DatabaseName(string databaseName);
 
     IMongoCollectionBuilder<TDocument> IndexProvider<TIndexProvider>()

src/Workleap.Extensions.Mongo.Abstractions/MongoCollectionAttribute.cs

@@ -14,6 +14,8 @@ public MongoCollectionAttribute(string name)
 
     public string Name { get; }
 
+    public string? ClientName { get; set; }
+
     public string? DatabaseName { get; set; }
 
     public Type? IndexProviderType { get; set; }

src/Workleap.Extensions.Mongo.Abstractions/MongoCollectionInformationCache.cs

@@ -36,37 +36,40 @@ public static MongoCollectionInformation GetCollectionInformation(Type documentT
         {
             if (documentType.GetCustomAttribute<MongoCollectionAttribute>() is { } attribute)
             {
-                return new MongoCollectionInformation(documentType, attribute.Name, attribute.DatabaseName, isRegisteredByConfiguration: false);
+                return new MongoCollectionInformation(documentType, attribute.Name, attribute.ClientName, attribute.DatabaseName, isRegisteredByConfiguration: false);
             }
 
             throw new ArgumentException(documentType + " must be decorated with " + nameof(MongoCollectionAttribute) + " or be registered by a " + typeof(IMongoCollectionConfiguration<>).MakeGenericType(documentType).Name);
         });
     }
 
-    internal static void SetCollectionInformation(Type documentType, string collectionName, string? databaseName)
+    internal static void SetCollectionInformation(Type documentType, string collectionName, string? clientName, string? databaseName)
     {
-        if (!CollectionInfos.TryAdd(documentType, new MongoCollectionInformation(documentType, collectionName, databaseName, isRegisteredByConfiguration: true)))
+        if (!CollectionInfos.TryAdd(documentType, new MongoCollectionInformation(documentType, collectionName, clientName, databaseName, isRegisteredByConfiguration: true)))
         {
             throw new ArgumentException($"Collection name for {documentType} already set.");
         }
     }
 
     public sealed class MongoCollectionInformation
     {
-        public MongoCollectionInformation(Type documentType, string collectionName, string? databaseName, bool isRegisteredByConfiguration)
+        public MongoCollectionInformation(Type documentType, string collectionName, string? clientName, string? databaseName, bool isRegisteredByConfiguration)
         {
             this.CollectionName = collectionName;
+            this.ClientName = clientName;
             this.DatabaseName = databaseName;
             this.DocumentType = documentType;
             this.IsRegisteredByConfiguration = isRegisteredByConfiguration;
         }
 
         public string CollectionName { get; }
 
+        public string? ClientName { get; }
+
         public string? DatabaseName { get; }
 
         public Type DocumentType { get; }
 
         public bool IsRegisteredByConfiguration { get; }
     }
-}
+}

src/Workleap.Extensions.Mongo.Abstractions/PublicAPI.Shipped.txt

@@ -8,6 +8,8 @@ Workleap.Extensions.Mongo.IndexedByAttribute
 Workleap.Extensions.Mongo.IndexedByAttribute.IndexedByAttribute(params string![]! indexes) -> void
 Workleap.Extensions.Mongo.IndexedByAttribute.Indexes.get -> string![]!
 Workleap.Extensions.Mongo.MongoCollectionAttribute
+Workleap.Extensions.Mongo.MongoCollectionAttribute.ClientName.get -> string?
+Workleap.Extensions.Mongo.MongoCollectionAttribute.ClientName.set -> void
 Workleap.Extensions.Mongo.MongoCollectionAttribute.DatabaseName.get -> string?
 Workleap.Extensions.Mongo.MongoCollectionAttribute.DatabaseName.set -> void
 Workleap.Extensions.Mongo.MongoCollectionAttribute.IndexProviderType.get -> System.Type?
@@ -37,6 +39,7 @@ static readonly Workleap.Extensions.Mongo.MongoDefaults.ClientName -> string!
 Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument>
 Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument>.BsonClassMap(System.Action<MongoDB.Bson.Serialization.BsonClassMap<TDocument!>!>! classMapInitializer) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument>.CollectionName(string! collectionName) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
+Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument>.ClientName(string! clientName) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument>.DatabaseName(string! databaseName) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument>.IndexProvider<TIndexProvider>() -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.IMongoCollectionConfiguration<TDocument>

src/Workleap.Extensions.Mongo.Tests/MongoCollectionAttributeTests.cs

@@ -30,4 +30,18 @@ public void Attribute_Throws_Given_Invalid_CollectionName(string collectionName)
     {
         Assert.Throws<ArgumentException>(() => new MongoCollectionAttribute(collectionName));
     }
+
+    [Fact]
+    public void Attribute_ClientName_Is_Null_By_Default()
+    {
+        var attr = new MongoCollectionAttribute("people");
+        Assert.Null(attr.ClientName);
+    }
+
+    [Fact]
+    public void Attribute_Sets_ClientName_Correctly()
+    {
+        var attr = new MongoCollectionAttribute("people") { ClientName = "myCluster" };
+        Assert.Equal("myCluster", attr.ClientName);
+    }
 }

src/Workleap.Extensions.Mongo.Tests/MongoCollectionBuilderTests.cs

@@ -6,6 +6,30 @@ namespace Workleap.Extensions.Mongo.Tests;
 
 public sealed class MongoCollectionBuilderTests
 {
+    [Fact]
+    public void Builder_Sets_ClientName_Correctly()
+    {
+        var builder = new MongoCollectionBuilder<TestDocument>();
+        builder.CollectionName("collection1").ClientName("myCluster");
+
+        var metadata = builder.Build() as MongoCollectionMetadata<TestDocument>;
+
+        Assert.NotNull(metadata);
+        Assert.Equal("myCluster", metadata.ClientName);
+    }
+
+    [Fact]
+    public void Builder_ClientName_Is_Null_By_Default()
+    {
+        var builder = new MongoCollectionBuilder<TestDocument>();
+        builder.CollectionName("collection1");
+
+        var metadata = builder.Build() as MongoCollectionMetadata<TestDocument>;
+
+        Assert.NotNull(metadata);
+        Assert.Null(metadata.ClientName);
+    }
+
     [Fact]
     public void Builder_Builds_Correctly()
     {

src/Workleap.Extensions.Mongo.Tests/MultipleMongoClientTests.cs

@@ -68,6 +68,42 @@ public override IServiceCollection ConfigureServices(IServiceCollection services
         }
     }
 
+    [Fact]
+    public void Collection_WithClientName_Resolves_To_Named_Client()
+    {
+        var collection = this.Services.GetRequiredService<IMongoCollection<NamedClientDocument>>();
+
+        // NamedClientDocument declares ClientName = FooClient ("foo"), whose app name is "app2"
+        Assert.Equal("app2", collection.Database.Client.Settings.ApplicationName);
+    }
+
+    [Fact]
+    public async Task UpdateIndexesAsync_WithoutClientNameOverride_Routes_Each_Type_To_Its_Declared_ClientName()
+    {
+        const string databaseName = "clientnameindextest";
+        var indexer = this.Services.GetRequiredService<IMongoIndexer>();
+
+        // No clientName override — each type should use its own declared ClientName
+        await indexer.UpdateIndexesAsync(new[] { typeof(NamedClientIndexDocument) }, databaseName: databaseName);
+
+        var fooClient = this.Services.GetRequiredService<IMongoClientProvider>().GetClient(FooClient);
+        var fooCollection = fooClient.GetDatabase(databaseName).GetCollection<NamedClientIndexDocument>();
+        var fooIndexNames = (await fooCollection.Indexes.ListAsync()).ToList()
+            .Select(i => i.GetElement("name").Value.AsString)
+            .ToList();
+
+        Assert.Contains(fooIndexNames, name => name.StartsWith("namedclientidx"));
+
+        // Verify the default client did NOT get the index
+        var defaultCollection = this.Services.GetRequiredService<IMongoClient>()
+            .GetDatabase(databaseName).GetCollection<NamedClientIndexDocument>();
+        var defaultIndexNames = (await defaultCollection.Indexes.ListAsync()).ToList()
+            .Select(i => i.GetElement("name").Value.AsString)
+            .ToList();
+
+        Assert.DoesNotContain(defaultIndexNames, name => name.StartsWith("namedclientidx"));
+    }
+
     [MongoCollection("cats", IndexProviderType = typeof(CatDocumentIndexes))]
     private sealed class CatDocument : MongoDocument
     {
@@ -83,4 +119,25 @@ public override IEnumerable<CreateIndexModel<CatDocument>> CreateIndexModels()
                 new CreateIndexOptions { Name = "name", Unique = true });
         }
     }
+
+    [MongoCollection("namedclientdoc", ClientName = FooClient)]
+    private sealed class NamedClientDocument : MongoDocument
+    {
+    }
+
+    [MongoCollection("namedclientidxdoc", ClientName = FooClient, IndexProviderType = typeof(NamedClientIndexDocumentIndexes))]
+    private sealed class NamedClientIndexDocument : MongoDocument
+    {
+        public string Tag { get; set; } = string.Empty;
+    }
+
+    private sealed class NamedClientIndexDocumentIndexes : MongoIndexProvider<NamedClientIndexDocument>
+    {
+        public override IEnumerable<CreateIndexModel<NamedClientIndexDocument>> CreateIndexModels()
+        {
+            yield return new CreateIndexModel<NamedClientIndexDocument>(
+                Builders<NamedClientIndexDocument>.IndexKeys.Ascending(x => x.Tag),
+                new CreateIndexOptions { Name = "namedclientidx" });
+        }
+    }
 }

src/Workleap.Extensions.Mongo.v2/PublicAPI.Shipped.txt

@@ -69,6 +69,7 @@ Workleap.Extensions.Mongo.MongoCollectionBuilder.MongoCollectionBuilder() -> voi
 Workleap.Extensions.Mongo.MongoCollectionBuilder<TDocument>
 Workleap.Extensions.Mongo.MongoCollectionBuilder<TDocument>.BsonClassMap(System.Action<MongoDB.Bson.Serialization.BsonClassMap<TDocument!>!>! classMapInitializer) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.MongoCollectionBuilder<TDocument>.CollectionName(string! collectionName) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
+Workleap.Extensions.Mongo.MongoCollectionBuilder<TDocument>.ClientName(string! clientName) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.MongoCollectionBuilder<TDocument>.DatabaseName(string! databaseName) -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.MongoCollectionBuilder<TDocument>.IndexProvider<TIndexProvider>() -> Workleap.Extensions.Mongo.IMongoCollectionBuilder<TDocument!>!
 Workleap.Extensions.Mongo.MongoCollectionBuilder<TDocument>.MongoCollectionBuilder() -> void

src/Workleap.Extensions.Mongo/Indexing/MongoIndexer.cs

@@ -74,19 +74,22 @@ public async Task UpdateIndexesAsync(IEnumerable<Type> types, string? clientName
             enumeratedTypes.Add(type);
         }
 
-        // Use default MongoDB client by default
-        clientName ??= MongoDefaults.ClientName;
-        var mongoClient = this._mongoClientProvider.GetClient(clientName);
-        var options = this._optionsMonitor.Get(clientName);
+        // When clientName is explicitly provided it overrides all document types; otherwise each type uses its own declared ClientName.
+        var explicitClientOverride = clientName;
 
-        var collectionInfoByDatabase = enumeratedTypes
+        var collectionInfoByClientAndDatabase = enumeratedTypes
             .Select(t => MongoCollectionInformationCache.GetCollectionInformation(t))
-            .GroupBy(info => info.DatabaseName);
+            // Use the effective database name (override if provided, otherwise the collection's DatabaseName) in the grouping key
+            .GroupBy(info => (ClientName: explicitClientOverride ?? info.ClientName ?? MongoDefaults.ClientName, DatabaseName: databaseName ?? info.DatabaseName));
 
-        foreach (var collectionInfos in collectionInfoByDatabase)
+        foreach (var collectionInfos in collectionInfoByClientAndDatabase)
         {
-            // User provided parameter has precedance over the MongoCollectionAttribute, otherwise use the default MongoDB database
-            var database = mongoClient.GetDatabase(databaseName ?? collectionInfos.Key ?? options.DefaultDatabaseName);
+            var effectiveClientName = collectionInfos.Key.ClientName;
+            var mongoClient = this._mongoClientProvider.GetClient(effectiveClientName);
+            var options = this._optionsMonitor.Get(effectiveClientName);
+
+            // User provided databaseName parameter has precedence over the collection's DatabaseName, otherwise use the client's default database
+            var database = mongoClient.GetDatabase(databaseName ?? collectionInfos.Key.DatabaseName ?? options.DefaultDatabaseName);
 
             // Attempt to update the indexes if we acquire the distributed lock
             var lockId = options.Indexing.DistributedLockName;