Subinvoke resolution context

packages/client/src/__tests__/core/uri-resolution/uri-resolution.spec.ts → packages/client/src/__tests__/core/uri-resolution.spec.ts

@@ -1,27 +1,18 @@
-import { GetPathToTestWrappers } from "@polywrap/test-cases";
 import {
   Uri,
-  IUriResolutionStep,
   UriPackageOrWrapper,
   UriResolutionContext,
-  buildCleanUriHistory,
+  UriResolutionResult,
 } from "@polywrap/core-js";
-import { UriResolutionResult } from "@polywrap/uri-resolvers-js";
-import fs from "fs";
 import { Result } from "@polywrap/result";
-import { PolywrapClient, ClientConfigBuilder } from "../../../";
+import { PolywrapClient, ClientConfigBuilder } from "../../";
 
 jest.setTimeout(200000);
 
-const expectResultWithHistory = async (
+const expectResolutionResult = async (
   receivedResult: Result<UriPackageOrWrapper, unknown>,
   expectedResult: Result<UriPackageOrWrapper, unknown>,
-  uriHistory: IUriResolutionStep<unknown>[],
-  historyFileName: string
 ): Promise<void> => {
-  if (historyFileName && uriHistory) {
-    await expectHistory(uriHistory, historyFileName);
-  }
 
   expect(expectedResult.ok).toEqual(receivedResult.ok);
 
@@ -36,34 +27,6 @@ const expectResultWithHistory = async (
   }
 };
 
-const expectHistory = async (
-  receivedHistory: IUriResolutionStep<unknown>[] | undefined,
-  historyFileName: string
-): Promise<void> => {
-  if (!receivedHistory) {
-    fail("History is not defined");
-  }
-
-  let expectedCleanHistory = await fs.promises.readFile(
-    `${__dirname}/histories/${historyFileName}.json`,
-    "utf-8"
-  );
-
-  const receivedCleanHistory = replaceAll(
-    JSON.stringify(buildCleanUriHistory(receivedHistory), null, 2),
-    `${GetPathToTestWrappers()}`,
-    "$root-wrapper-dir"
-  );
-
-  expect(receivedCleanHistory).toEqual(
-    JSON.stringify(JSON.parse(expectedCleanHistory), null, 2)
-  );
-};
-
-function replaceAll(str: string, strToReplace: string, replaceStr: string) {
-  return str.replace(new RegExp(strToReplace, "g"), replaceStr);
-}
-
 describe("URI resolution", () => {
   it("sanity", async () => {
     const uri = new Uri("ens/wraps.eth:uri-resolver-ext@1.1.0");
@@ -78,14 +41,12 @@ describe("URI resolution", () => {
     );
 
     if (expectResult.ok) {
-      expectResult.value.type = "wrapper"
+      expectResult.value.type = "wrapper";
     }
 
-    await expectResultWithHistory(
+    await expectResolutionResult(
       result,
       expectResult,
-      resolutionContext.getHistory(),
-      "sanity"
     );
   });
 

packages/core-client/README.md

@@ -257,7 +257,7 @@ Invoke a wrapper.
 
 ## Development
 
-The Polywrap JavaScript client is open-source. It lives within the [Polywrap JavaScript Client repo](https://github.com/polywrap/javascript-client). Contributions from the community are welcomed!
+The Polywrap JavaScript client is open-source. It lives within the [Polywrap JavaScript Client repository](https://github.com/polywrap/javascript-client). Contributions from the community are welcomed!
 
 ### Build
 ```bash

packages/core-client/src/PolywrapCoreClient.ts

@@ -21,6 +21,7 @@ import {
   WrapperEnv,
   ReadonlyUriMap,
   UriMap,
+  UriResolutionResult,
 } from "@polywrap/core-js";
 import { msgpackEncode, msgpackDecode } from "@polywrap/msgpack-js";
 import {
@@ -274,29 +275,59 @@ export class PolywrapCoreClient implements CoreClient {
       const resolutionContext =
         options.resolutionContext ?? new UriResolutionContext();
 
+      const loadWrapperContext = resolutionContext.createSubContext();
+
       const loadWrapperResult = await this.loadWrapper(
         typedOptions.uri,
-        resolutionContext
+        loadWrapperContext
       );
 
       if (!loadWrapperResult.ok) {
+        resolutionContext.trackStep({
+          sourceUri: typedOptions.uri,
+          result: UriResolutionResult.err(loadWrapperResult.error),
+          description: `Client.loadWrapper`,
+          subHistory: loadWrapperContext.getHistory(),
+        });
+
         return loadWrapperResult;
       }
+
+      let resolutionPath = loadWrapperContext.getResolutionPath();
+      resolutionPath =
+        resolutionPath.length > 0 ? resolutionPath : [typedOptions.uri];
+
+      const finalUri = resolutionPath[resolutionPath.length - 1];
+
       const wrapper = loadWrapperResult.value;
 
-      const resolutionPath = resolutionContext.getResolutionPath();
+      resolutionContext.trackStep({
+        sourceUri: typedOptions.uri,
+        result: UriResolutionResult.ok(finalUri, loadWrapperResult.value),
+        description: `Client.loadWrapper`,
+        subHistory: loadWrapperContext.getHistory(),
+      });
 
-      const env = getEnvFromUriHistory(
-        resolutionPath.length > 0 ? resolutionPath : [typedOptions.uri],
-        this
-      );
+      const env = options.env ?? getEnvFromUriHistory(resolutionPath, this);
+
+      const invokeContext = resolutionContext.createSubContext();
 
       const invokeResult = await this.invokeWrapper<TData>({
-        env: env,
         ...typedOptions,
+        env: env,
+        resolutionContext: invokeContext,
         wrapper,
       });
 
+      resolutionContext.trackStep({
+        sourceUri: finalUri,
+        result: invokeResult.ok
+          ? UriResolutionResult.ok(finalUri)
+          : ResultErr(invokeResult.error),
+        description: `Client.invokeWrapper`,
+        subHistory: invokeContext.getHistory(),
+      });
+
       if (!invokeResult.ok) {
         return invokeResult;
       }

packages/core/src/uri-resolution/UriResolutionContext.ts

@@ -72,6 +72,11 @@ export class UriResolutionContext implements IUriResolutionContext {
   }
 
   createSubContext(): IUriResolutionContext {
-    return new UriResolutionContext(this._resolvingUriMap, this._history);
+    const map = new Map<string, boolean>();
+    // Copy the resolvingUriMap to the new map, so that changes to the new map don't affect the old map
+    for (const key of this._resolvingUriMap.keys()) {
+      this._resolvingUriMap.get(key) && map.set(key, true);
+    }
+    return new UriResolutionContext(map, []);
   }
 }

packages/uri-resolvers/src/helpers/UriResolutionResult.ts → packages/core/src/uri-resolution/UriResolutionResult.ts

@@ -1,10 +1,7 @@
-import {
-  UriPackageOrWrapper,
-  IUriResolutionStep,
-  Uri,
-  IWrapPackage,
-  Wrapper,
-} from "@polywrap/core-js";
+import { Uri, IWrapPackage, Wrapper } from "../types";
+import { IUriResolutionStep } from "./IUriResolutionStep";
+import { UriPackageOrWrapper } from "./UriPackageOrWrapper";
+
 import { Result, ResultOk, ResultErr } from "@polywrap/result";
 
 // $start: UriResolutionResult

packages/core/src/uri-resolution/index.ts

@@ -3,3 +3,4 @@ export * from "./IUriResolver";
 export * from "./UriPackageOrWrapper";
 export * from "./IUriResolutionContext";
 export * from "./UriResolutionContext";
+export * from "./UriResolutionResult";

packages/plugin/src/PluginWrapper.ts

@@ -1,5 +1,6 @@
 import { PluginModule } from "./PluginModule";
 import { getErrorSource } from "./utils/getErrorSource";
+import { ResolutionContextOverrideClient } from "./ResolutionContextOverrideClient";
 
 import {
   Wrapper,
@@ -84,7 +85,7 @@ export class PluginWrapper implements Wrapper {
     const result = await this._module._wrap_invoke(
       method,
       jsArgs,
-      client,
+      new ResolutionContextOverrideClient(client, options.resolutionContext),
       options.env || {}
     );