simplified wireup so only using IKeyedDependency

Author: Erwinvandervalk

access-token-management/src/AccessTokenManagement/ClientCredentialsTokenManagementServiceCollectionExtensions.cs

@@ -39,15 +39,21 @@ public static ClientCredentialsTokenManagementBuilder AddClientCredentialsTokenM
         services.TryAddSingleton<ITokenRequestSynchronization, TokenRequestSynchronization>();
 
         services.TryAddTransient<IClientCredentialsTokenManagementService, ClientCredentialsTokenManagementService>();
-        services.TryAddKeyedTransient<OptionallyKeyedDependency<IDistributedCache>>(nameof(DistributedClientCredentialsTokenCache));
+
+        // By default, resolve the distributed cache for the DistributedClientCredentialsTokenCache
+        // without key. If desired, a consumers can register the distributed cache with a key
+        services.TryAddKeyedTransient<IDistributedCache>(nameof(DistributedClientCredentialsTokenCache), (sp, _) => sp.GetRequiredService<IDistributedCache>());
         services.TryAddTransient<IClientCredentialsTokenCache, DistributedClientCredentialsTokenCache>();
         services.TryAddTransient<IClientCredentialsTokenEndpointService, ClientCredentialsTokenEndpointService>();
         services.TryAddTransient<IClientAssertionService, DefaultClientAssertionService>();
 
         services.TryAddTransient<IDPoPProofService, DefaultDPoPProofService>();
         services.TryAddTransient<IDPoPKeyStore, DefaultDPoPKeyStore>();
 
-        services.TryAddKeyedTransient<OptionallyKeyedDependency<IDistributedCache>>(nameof(DistributedDPoPNonceStore));
+        // ** DistributedDPoPNonceStore **
+        // By default, resolve the distributed cache for the DistributedClientCredentialsTokenCache
+        // without key. If desired, a consumers can register the distributed cache with a key
+        services.TryAddKeyedTransient<IDistributedCache>(nameof(DistributedDPoPNonceStore), (sp, _) => sp.GetRequiredService<IDistributedCache>());
         services.TryAddTransient<IDPoPNonceStore, DistributedDPoPNonceStore>();
 
         services.AddHttpClient(ClientCredentialsTokenManagementDefaults.BackChannelHttpClientName);

access-token-management/src/AccessTokenManagement/DistributedClientCredentialsTokenCache.cs

@@ -13,14 +13,14 @@ namespace Duende.AccessTokenManagement;
 /// Client access token cache using IDistributedCache
 /// </summary>
 public class DistributedClientCredentialsTokenCache(
-    [FromKeyedServices(nameof(DistributedClientCredentialsTokenCache))] OptionallyKeyedDependency<IDistributedCache> cache,
+    [FromKeyedServices(nameof(DistributedClientCredentialsTokenCache))] IDistributedCache cache,
     ITokenRequestSynchronization synchronization,
     IOptions<ClientCredentialsTokenManagementOptions> options,
     ILogger<DistributedClientCredentialsTokenCache> logger
     )
     : IClientCredentialsTokenCache
 {
-    private readonly IDistributedCache _cache = cache.Dependency;
+    private readonly IDistributedCache _cache = cache;
     private readonly ITokenRequestSynchronization _synchronization = synchronization;
     private readonly ILogger<DistributedClientCredentialsTokenCache> _logger = logger;
     private readonly ClientCredentialsTokenManagementOptions _options = options.Value;

access-token-management/src/AccessTokenManagement/DistributedDPoPNonceStore.cs

@@ -24,10 +24,10 @@ public class DistributedDPoPNonceStore : IDPoPNonceStore
     /// <param name="cache"></param>
     /// <param name="logger"></param>
     public DistributedDPoPNonceStore(
-        [FromKeyedServices(nameof(DistributedDPoPNonceStore))]OptionallyKeyedDependency<IDistributedCache> cache, 
+        [FromKeyedServices(nameof(DistributedDPoPNonceStore))] IDistributedCache cache, 
         ILogger<DistributedDPoPNonceStore> logger)
     {
-        _cache = cache.Dependency;
+        _cache = cache;
         _logger = logger;
     }
 

access-token-management/src/AccessTokenManagement/OptionallyKeyedDependency.cs

@@ -306,7 +306,7 @@ public async Task Can_use_custom_cache_implementation()
 
         services.AddDistributedMemoryCache();
         var replacementCache = new FakeCache();
-        services.AddKeyedSingleton<IDistributedCache>(OptionallyKeyedDependency.Duende, replacementCache);
+        services.AddKeyedSingleton<IDistributedCache>(nameof(DistributedClientCredentialsTokenCache), replacementCache);
 
         services.AddClientCredentialsTokenManagement()
             .AddClient("test", client =>
@@ -336,61 +336,6 @@ public async Task Can_use_custom_cache_implementation()
         replacementCache.SetCount.ShouldBe(1);
     }
 
-    [Fact]
-    public async Task Can_use_custom_cache_implementation_only_for_DistributedClientCredentialsTokenCache()
-    {
-        var services = new ServiceCollection();
-
-        services.AddDistributedMemoryCache();
-        var replacementCache = new FakeCache();
-
-        // register the cache, but using a different key (not default 'duende')
-        services.AddKeyedSingleton<IDistributedCache>("different", replacementCache)
-
-            // Now register a custom OptionallyKeyedDependency that uses the different key
-            .AddKeyedTransient<OptionallyKeyedDependency<IDistributedCache>,
-                CustomOptionallyKeyedDependency<IDistributedCache>>(nameof(DistributedClientCredentialsTokenCache));
-
-        services.AddClientCredentialsTokenManagement()
-            .AddClient("test", client =>
-            {
-                client.TokenEndpoint = "https://as";
-                client.ClientId = "id";
-
-                client.HttpClientName = "custom";
-            });
-
-        var mockHttp = new MockHttpMessageHandler();
-        mockHttp.When("https://as/*")
-            .Respond(HttpStatusCode.OK, JsonContent.Create(new TokenResponse()));
-
-        services.AddHttpClient("custom")
-            .ConfigurePrimaryHttpMessageHandler(() => mockHttp);
-
-        var provider = services.BuildServiceProvider();
-        var sut = provider.GetRequiredService<IClientCredentialsTokenManagementService>();
-
-        var token = await sut.GetAccessTokenAsync("test");
-
-        token.Error.ShouldBeNull();
-
-        // Verify we actually used the cache
-        replacementCache.GetCount.ShouldBe(1);
-        replacementCache.SetCount.ShouldBe(1);
-    }
-
-    /// <summary>
-    /// You can change the key of a dependency by deriving from OptionallyKeyedDependency.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public class CustomOptionallyKeyedDependency<T>(
-        T defaultDependency,
-
-        // Here the key is overwritten
-        [FromKeyedServices(("different"))] T? keyedDependency = default(T?))
-        : OptionallyKeyedDependency<T>(defaultDependency, keyedDependency)
-        where T : class;
-
     public class FakeCache : IDistributedCache
     {
         public int GetCount = 0;