Don't cache rejected promises

src/CachingAuthorizationServerProvider.ts

@@ -2,14 +2,21 @@ import type { AuthorizationServerProvider } from "./AuthorizationServerProvider.
 import type * as oauth from "oauth4webapi"
 
 export class CachingAuthorizationServerProvider implements AuthorizationServerProvider {
-    readonly #cache = new Map<string, Promise<oauth.AuthorizationServer>> // TODO: Take cache from caller
+    readonly #cache = new Map<string, oauth.AuthorizationServer> // TODO: Take cache from caller
     readonly #original: AuthorizationServerProvider
 
     constructor(original: AuthorizationServerProvider) {
         this.#original = original
     }
 
-    getAuthorizationServer(request: Request): Promise<oauth.AuthorizationServer> {
-        return this.#cache.getOrInsertComputed(request.url, _ => this.#original.getAuthorizationServer(request))
+    async getAuthorizationServer(request: Request): Promise<oauth.AuthorizationServer> {
+        const cached = this.#cache.get(request.url)
+        if (cached !== undefined) {
+            return cached
+        }
+
+        const fresh = await this.#original.getAuthorizationServer(request)
+        this.#cache.set(request.url, fresh)
+        return fresh
     }
 }

src/CachingClientProvider.ts

@@ -2,14 +2,21 @@ import type { ClientProvider } from "./ClientProvider.js"
 import type * as oauth from "oauth4webapi"
 
 export class CachingClientProvider implements ClientProvider {
-    readonly #cache = new Map<string, Promise<oauth.Client>> // TODO: Take cache from caller
+    readonly #cache = new Map<string, oauth.Client> // TODO: Take cache from caller
     readonly #original: ClientProvider
 
     constructor(original: ClientProvider) {
         this.#original = original
     }
 
     async getClient(as: oauth.AuthorizationServer, redirectUri: string, signal: AbortSignal): Promise<oauth.Client> {
-        return this.#cache.getOrInsertComputed(as.issuer, _ => this.#original.getClient(as, redirectUri, signal))
+        const cached = this.#cache.get(as.issuer)
+        if (cached !== undefined) {
+            return cached
+        }
+
+        const fresh = await this.#original.getClient(as, redirectUri, signal)
+        this.#cache.set(as.issuer, fresh)
+        return fresh
     }
 }

src/CachingIssuerProvider.ts

@@ -1,14 +1,21 @@
 import { IssuerProvider } from "./IssuerProvider.js"
 
 export class CachingIssuerProvider implements IssuerProvider {
-    readonly #cache = new Map<string, Promise<URL>> // TODO: Take cache from caller
+    readonly #cache = new Map<string, URL> // TODO: Take cache from caller
     readonly #original: IssuerProvider
 
     constructor(original: IssuerProvider) {
         this.#original = original
     }
 
-    getIssuer(request: Request): Promise<URL> {
-        return this.#cache.getOrInsertComputed(request.url, _ => this.#original.getIssuer(request))
+    async getIssuer(request: Request): Promise<URL> {
+        const cached = this.#cache.get(request.url)
+        if (cached !== undefined) {
+            return cached
+        }
+
+        const fresh = await this.#original.getIssuer(request)
+        this.#cache.set(request.url, fresh)
+        return fresh
     }
 }