fix: support optional async WrapperCache methods

packages/js/client/src/PolywrapClient.ts

@@ -39,6 +39,7 @@ import {
   RunOptions,
   GetManifestOptions,
   SimpleCache,
+  executeMaybeAsyncFunction,
 } from "@polywrap/core-js";
 import { msgpackEncode, msgpackDecode } from "@polywrap/msgpack-js";
 import { WrapManifest } from "@polywrap/wrap-manifest-types-js";
@@ -481,7 +482,9 @@ export class PolywrapClient implements Client {
     // Update cache for all URIs in the chain
     if (cacheWrite && wrapper) {
       const uris = uriHistory.getResolutionPath().stack.map((x) => x.sourceUri);
-      this._wrapperCache.set(uris, wrapper);
+      await executeMaybeAsyncFunction(
+        this._wrapperCache.set.bind(this._wrapperCache, uris, wrapper)
+      );
     }
 
     if (shouldClearContext) {

packages/js/core/src/__tests__/MaybeAsync.spec.ts

@@ -4,15 +4,37 @@ import {
   isPromise,
 } from "..";
 
+class ClassInstance {
+  constructor(private _prop: string) {}
+
+  normalMethod(arg: string): string {
+    return this._prop + arg;
+  }
+
+  async asyncMethod(arg: string): Promise<string> {
+    await new Promise((resolve) =>
+      setTimeout(resolve, 200)
+    );
+
+    return this._prop + arg;
+  }
+}
+
 describe("MaybeAsync", () => {
   const promise: MaybeAsync<string> =
     new Promise<string>((resolve, reject) => { return "" });
-  const testFunction = (args: unknown[]) => { return "" };
-  const testFunctionReturnPromise = (args: unknown[]) => new Promise<string>((resolve, reject) => { return "" });
+  const testFunction = (args: unknown[]) => { return "foo" };
+  const testFunctionReturnPromise = (args: unknown[]) => new Promise<string>((resolve) => { resolve("foo") });
 
-  it("sanity", () => {
+  it("sanity", async () => {
     expect(isPromise(promise)).toBe(true);
-    expect(executeMaybeAsyncFunction(testFunction)).toBeDefined();
-    expect(executeMaybeAsyncFunction(testFunctionReturnPromise)).toBeDefined();
+    expect(await executeMaybeAsyncFunction(testFunction)).toBe("foo");
+    expect(await executeMaybeAsyncFunction(testFunctionReturnPromise)).toBe("foo");
   });
+
+  it("works with class instances", async () => {
+    const instance = new ClassInstance("bar");
+    expect(await executeMaybeAsyncFunction(instance.normalMethod.bind(instance, "foo"))).toBe("barfoo")
+    expect(await executeMaybeAsyncFunction(instance.asyncMethod.bind(instance, "foo"))).toBe("barfoo")
+  })
 });

packages/js/core/src/types/WrapperCache.ts

@@ -1,8 +1,8 @@
-import { Uri, Wrapper } from ".";
+import { Uri, Wrapper, MaybeAsync } from ".";
 
 export interface WrapperCache {
-  get(uri: Uri): Wrapper | undefined;
-  has(uri: Uri): boolean;
-  set(uris: Uri[], wrapper: Wrapper): void;
-  set(uri: Uri, wrapper: Wrapper): void;
+  get(uri: Uri): MaybeAsync<Wrapper | undefined>;
+  has(uri: Uri): MaybeAsync<boolean>;
+  set(uris: Uri[], wrapper: Wrapper): MaybeAsync<void>;
+  set(uri: Uri, wrapper: Wrapper): MaybeAsync<void>;
 }

packages/js/core/src/uri-resolution/resolvers/cache/CacheResolver.ts

@@ -1,4 +1,10 @@
-import { Uri, Client, WrapperCache } from "../../../types";
+import {
+  Uri,
+  Client,
+  WrapperCache,
+  executeMaybeAsyncFunction,
+  Wrapper,
+} from "../../../types";
 import { UriResolver, UriResolutionResult } from "../../core";
 
 export class CacheResolver implements UriResolver {
@@ -11,7 +17,9 @@ export class CacheResolver implements UriResolver {
     client: Client,
     cache: WrapperCache
   ): Promise<UriResolutionResult> {
-    const wrapper = cache.get(uri);
+    const wrapper = await executeMaybeAsyncFunction<Wrapper | undefined>(
+      cache.get.bind(cache, uri)
+    );
 
     return Promise.resolve({
       uri: uri,

packages/js/core/src/uri-resolution/resolvers/extendable/ExtendableUriResolver.ts

@@ -4,6 +4,7 @@ import {
   WrapperCache,
   getImplementations,
   coreInterfaceUris,
+  executeMaybeAsyncFunction,
 } from "../../..";
 import { CreateWrapperFunc } from "./types/CreateWrapperFunc";
 import { UriResolutionResult } from "../../core/types/UriResolutionResult";
@@ -105,7 +106,11 @@ export class ExtendableUriResolver implements UriResolver {
     const implementationsToLoad = new Queue<Uri>();
 
     for (const implementationUri of implementationUris) {
-      if (!cache.has(implementationUri)) {
+      if (
+        !(await executeMaybeAsyncFunction<boolean>(
+          cache.has.bind(cache, implementationUri)
+        ))
+      ) {
         implementationsToLoad.enqueue(implementationUri);
       }
     }
@@ -148,7 +153,7 @@ export class ExtendableUriResolver implements UriResolver {
           };
         }
       } else {
-        cache.set(implementationUri, wrapper);
+        await cache.set(implementationUri, wrapper);
         loadedImplementations.push(implementationUri.uri);
         failedAttempts = 0;
       }