Implement ICouchbaseClientProvider for a cleaner DI approach

Author: brantburnett

src/Couchbase.Aspire.Client/AspireCouchbaseExtensions.cs

@@ -123,22 +123,14 @@ void ConfigureClusterOptions(ClusterOptions options)
         if (serviceKey is null)
         {
             builder.Services.AddCouchbase(ConfigureClusterOptions);
-
-            if (!string.IsNullOrEmpty(settings.BucketName))
-            {
-                builder.Services.TryAddSingleton<INamedBucketProvider>(sp =>
-                    new BucketProvider(sp.GetRequiredService<IClusterProvider>(), settings.BucketName));
-            }
+            builder.Services.TryAddSingleton<ICouchbaseClientProvider>(sp =>
+                new CouchbaseClientProvider(sp.GetRequiredService<IClusterProvider>(), settings.BucketName));
         }
         else
         {
             builder.Services.AddKeyedCouchbase(serviceKey, ConfigureClusterOptions);
-
-            if (!string.IsNullOrEmpty(settings.BucketName))
-            {
-                builder.Services.TryAddKeyedSingleton<INamedBucketProvider>(serviceKey, (sp, serviceKey) =>
-                    new BucketProvider(sp.GetRequiredKeyedService<IClusterProvider>(serviceKey), settings.BucketName));
-            }
+            builder.Services.TryAddKeyedSingleton<ICouchbaseClientProvider>(serviceKey, (sp, serviceKey) =>
+                new CouchbaseClientProvider(sp.GetRequiredKeyedService<IClusterProvider>(serviceKey), settings.BucketName));
         }
 
         if (!settings.DisableTracing)

src/Couchbase.Aspire.Client/BucketProvider.cs

@@ -0,0 +1,65 @@
+using System.Diagnostics.CodeAnalysis;
+using Couchbase.Extensions.DependencyInjection;
+
+namespace Couchbase.Aspire.Client;
+
+/// <summary>
+/// Provides access to a Couchbase cluster and named bucket.
+/// </summary>
+/// <remarks>
+/// <see cref="INamedBucketProvider.GetBucketAsync"/> will throw a <see cref="CouchbaseException"/>
+/// if a bucket name is not configured for this client.
+/// </remarks>
+public interface ICouchbaseClientProvider : IClusterProvider, INamedBucketProvider
+{
+}
+
+internal sealed class CouchbaseClientProvider(IClusterProvider clusterProvider, string? bucketName) : ICouchbaseClientProvider
+{
+    // The default implementation of IClusterProvider also implements IBucketProvider
+    private readonly IBucketProvider? _bucketProvider = clusterProvider as IBucketProvider;
+
+    public string BucketName => bucketName ?? "";
+
+    public ValueTask<ICluster> GetClusterAsync() => clusterProvider.GetClusterAsync();
+
+    public ValueTask<IBucket> GetBucketAsync()
+    {
+        if (string.IsNullOrEmpty(bucketName))
+        {
+            ThrowNoBucketNameException();
+        }
+
+        if (_bucketProvider is not null)
+        {
+            // Fast path for the default implementation of IClusterProvider
+            return _bucketProvider.GetBucketAsync(bucketName);
+        }
+        else
+        {
+            // Fallback
+            return GetBucketManualAsync(bucketName);
+        }
+    }
+
+    private async ValueTask<IBucket> GetBucketManualAsync(string bucketName)
+    {
+        var cluster = await clusterProvider.GetClusterAsync().ConfigureAwait(false);
+        return await cluster.BucketAsync(bucketName).ConfigureAwait(false);
+    }
+
+    // Don't dispose of the cluster provider, it's owned by the DI container and will
+    // be disposed via that path.
+
+    void IDisposable.Dispose()
+    {
+    }
+
+    ValueTask IAsyncDisposable.DisposeAsync() => ValueTask.CompletedTask;
+
+    [DoesNotReturn]
+    private static void ThrowNoBucketNameException()
+    {
+        throw new CouchbaseException("No bucket name was configured for this Couchbase client.");
+    }
+}

src/Couchbase.Aspire.Client/CouchbaseClientProvider.cs

@@ -2,7 +2,7 @@
 @using Couchbase.Core.Exceptions.KeyValue
 @using Couchbase.Extensions.DependencyInjection
 @rendermode InteractiveServer
-@inject INamedBucketProvider BucketProvider
+@inject ICounterCollectionProvider CollectionProvider
 
 <PageTitle>Counter</PageTitle>
 
@@ -27,8 +27,7 @@
     {
         try
         {
-            var bucket = await BucketProvider.GetBucketAsync();
-            var collection = bucket.Scope("test-scope").Collection("counter");
+            var collection = await CollectionProvider.GetCollectionAsync();
 
             var result = await collection.GetAsync("counter", new Couchbase.KeyValue.GetOptions()
                 .Transcoder(new Couchbase.Core.IO.Transcoders.LegacyTranscoder()));
@@ -49,8 +48,7 @@
     {
         try
         {
-            var bucket = await BucketProvider.GetBucketAsync();
-            var collection = bucket.Scope("test-scope").Collection("counter");
+            var collection = await CollectionProvider.GetCollectionAsync();
 
             try
             {

tests/Aspire.Test.WebApp/Components/Pages/Counter.razor

@@ -0,0 +1,9 @@
+using Couchbase.Aspire.Client;
+using Couchbase.Extensions.DependencyInjection;
+
+namespace Aspire.Test.WebApp;
+
+public interface ICounterCollectionProvider : INamedCollectionProvider;
+
+public class CounterCollectionProvider(ICouchbaseClientProvider clientProvider)
+    : NamedCollectionProvider(clientProvider, "test-scope", "counter"), ICounterCollectionProvider;

tests/Aspire.Test.WebApp/CounterCollectionProvider.cs

@@ -1,10 +1,12 @@
+using Aspire.Test.WebApp;
 using Aspire.Test.WebApp.Components;
 using Couchbase.Aspire.Client;
 
 var builder = WebApplication.CreateBuilder(args);
 
 builder.AddServiceDefaults();
 builder.AddCouchbaseClient("test-bucket");
+builder.Services.AddSingleton<ICounterCollectionProvider, CounterCollectionProvider>();
 
 // Add services to the container.
 builder.Services.AddRazorComponents()