Feat: Client validate method

packages/js/client/src/PolywrapClient.ts

@@ -11,6 +11,7 @@ import {
   InterfaceImplementations,
   InvokeOptions,
   InvokerOptions,
+  ValidateOptions,
   QueryOptions,
   SubscribeOptions,
   Subscription,
@@ -31,10 +32,12 @@ import { buildCleanUriHistory } from "@polywrap/uri-resolvers-js";
 import { msgpackEncode, msgpackDecode } from "@polywrap/msgpack-js";
 import {
   DeserializeManifestOptions,
+  ImportedModuleDefinition,
   WrapManifest,
 } from "@polywrap/wrap-manifest-types-js";
 import { Tracer, TracerConfig, TracingLevel } from "@polywrap/tracing-js";
 import { Result, ResultErr, ResultOk } from "@polywrap/result";
+import { compareSignature } from "@polywrap/wrap-manifest-types-js";
 import { ClientConfigBuilder } from "@polywrap/client-config-builder-js";
 
 export class PolywrapClient implements CoreClient {
@@ -694,6 +697,88 @@ export class PolywrapClient implements CoreClient {
     }
   }
 
+  @Tracer.traceMethod("PolywrapClient: validateConfig")
+  public async validate<TUri extends Uri | string>(
+    uri: TUri,
+    options: ValidateOptions
+  ): Promise<Result<true, Error>> {
+    const wrapper = await this.loadWrapper(Uri.from(uri));
+    if (!wrapper.ok) {
+      return ResultErr(new Error(wrapper.error?.message));
+    }
+
+    const { abi } = await wrapper.value.getManifest();
+    const importedModules: ImportedModuleDefinition[] =
+      abi.importedModuleTypes || [];
+
+    const importUri = (importedModuleType: ImportedModuleDefinition) => {
+      return this.tryResolveUri({ uri: importedModuleType.uri });
+    };
+    const resolvedModules = await Promise.all(importedModules.map(importUri));
+    const modulesNotFound = resolvedModules.filter(({ ok }) => !ok) as {
+      error: Error;
+    }[];
+
+    if (modulesNotFound.length) {
+      const missingModules = modulesNotFound.map(({ error }) => {
+        const uriIndex = error?.message.indexOf("\n");
+        return error?.message.substring(0, uriIndex);
+      });
+      const error = new Error(JSON.stringify(missingModules));
+      return ResultErr(error);
+    }
+
+    if (options.abi) {
+      for (const importedModule of importedModules) {
+        const importedModuleManifest = await this.getManifest(
+          importedModule.uri
+        );
+        if (!importedModuleManifest.ok) {
+          return ResultErr(importedModuleManifest.error);
+        }
+        const importedMethods =
+          importedModuleManifest.value.abi.moduleType?.methods || [];
+
+        const expectedMethods = importedModules.find(
+          ({ uri }) => importedModule.uri === uri
+        );
+
+        const errorMessage = `ABI from Uri: ${importedModule.uri} is not compatible with Uri: ${uri}`;
+        for (const [i, _] of Object.keys(importedMethods).entries()) {
+          const importedMethod = importedMethods[i];
+
+          if (expectedMethods?.methods && expectedMethods?.methods.length < i) {
+            const expectedMethod = expectedMethods?.methods[i];
+            const areEqual = compareSignature(importedMethod, expectedMethod);
+
+            if (!areEqual) return ResultErr(new Error(errorMessage));
+          } else {
+            return ResultErr(new Error(errorMessage));
+          }
+        }
+      }
+    }
+
+    if (options.recursive) {
+      const validateImportedModules = importedModules.map(({ uri }) =>
+        this.validate(uri, options)
+      );
+      const resolverUris = await Promise.all(validateImportedModules);
+      const invalidUris = resolverUris.filter(({ ok }) => !ok) as {
+        error: Error;
+      }[];
+      if (invalidUris.length) {
+        const missingUris = invalidUris.map(({ error }) => {
+          const uriIndex = error?.message.indexOf("\n");
+          return error?.message.substring(0, uriIndex);
+        });
+        const error = new Error(JSON.stringify(missingUris));
+        return ResultErr(error);
+      }
+    }
+    return ResultOk(true);
+  }
+
   private buildConfigFromPolywrapClientConfig(
     config?: PolywrapClientConfig
   ): PolywrapCoreClientConfig<Uri> {

packages/js/client/src/__tests__/core/sanity.spec.ts

@@ -1,6 +1,14 @@
-import { coreInterfaceUris } from "@polywrap/core-js";
-import { Uri } from "../..";
-import { PolywrapClient } from "../../PolywrapClient";
+import {
+  Uri,
+  PolywrapClient, PolywrapCoreClientConfig
+} from "../..";
+import fs from "fs";
+
+import { coreInterfaceUris, IUriPackage, IUriRedirect } from "@polywrap/core-js";
+import { buildWrapper } from "@polywrap/test-env-js";
+import { ResultErr } from "@polywrap/result";
+import { StaticResolver, UriResolverLike } from "@polywrap/uri-resolvers-js";
+import { WasmPackage } from "@polywrap/wasm-js";
 
 jest.setTimeout(200000);
 
@@ -26,4 +34,103 @@ describe("sanity", () => {
         },
       ]);
   });
+
+  test("validate requested uri is available", async () => {
+    const fooPath = `${__dirname}/../utils/validate/wrapper-a`;
+    const greetingPath = `${__dirname}/../utils/validate/wrapper-b`;
+    const modifiedFooPath = `${__dirname}/../utils/validate/wrapper-c`
+    const fooUri = `ens/foo.eth`;
+    const greetingUri = `ens/greeting.eth`;
+    const modifiedFooUri = `ens/foo-modified.eth`;
+
+    const getPackage = async (name: string) => {
+      const manifest = await fs.promises.readFile(
+        `${__dirname}/../utils/validate/${name}/build/wrap.info`
+      );
+
+      const wasmModule = await fs.promises.readFile(
+        `${__dirname}/../utils/validate/${name}/build/wrap.wasm`
+      );
+      return WasmPackage.from(manifest, wasmModule)
+    }
+
+    let config: unknown = {
+      resolver: {
+        tryResolveUri: (_a: unknown, _b: unknown, _c: unknown) => {
+          return Promise.resolve(ResultErr())
+        }
+      },
+      interfaces: undefined,
+      envs: undefined
+    }
+
+    await buildWrapper(fooPath);
+    let client = new PolywrapClient(config as PolywrapCoreClientConfig, { noDefaults: true });
+    let result = await client.validate(fooUri, {});
+    expect(result.ok).toBeFalsy();
+    let resultError = (result as { error: Error }).error;
+    expect(resultError).toBeTruthy();
+    expect(resultError.message).toContain("Error resolving URI");
+
+    let fooPackage: IUriPackage<string> = {
+      uri: fooUri,
+      package: await getPackage("wrapper-a")
+    }
+
+    let resolvers: UriResolverLike[] = [ fooPackage ]
+    let staticResolver = StaticResolver.from(resolvers)
+
+    config = {
+      resolver: staticResolver
+    };
+
+    client = new PolywrapClient(config as PolywrapCoreClientConfig, { noDefaults: true });
+    result = await client.validate(fooUri, {});
+
+    expect(result.ok).toBeTruthy();
+
+    result = await client.validate(greetingUri, {
+      recursive: true
+    })
+    resultError = (result as { error: Error }).error;
+    expect(result.ok).toBeFalsy();
+    expect(resultError).toBeTruthy();
+    expect(resultError.message).toContain("Error resolving URI");
+
+    await buildWrapper(greetingPath);
+
+    let modifiedFooWrapper: IUriPackage<string> = {
+      uri: greetingUri,
+      package: await getPackage("wrapper-b")
+    };
+    resolvers.push(modifiedFooWrapper);
+    staticResolver = StaticResolver.from(resolvers);
+
+    (config as Record<string, unknown>).resolver = staticResolver;
+    client = new PolywrapClient(config as PolywrapCoreClientConfig, { noDefaults: true });
+
+    result = await client.validate(greetingUri, {
+      recursive: true
+    })
+
+    expect(result.ok).toBeTruthy()
+
+    await buildWrapper(modifiedFooPath);
+      let redirectUri: IUriRedirect<string> = {
+      from: fooUri,
+      to: modifiedFooUri
+    };
+    resolvers.push(redirectUri);
+
+    staticResolver = StaticResolver.from(resolvers);
+
+    (config as Record<string, unknown>).resolver = staticResolver;
+    client = new PolywrapClient(config as PolywrapCoreClientConfig, { noDefaults: true });
+
+    result = await client.validate(greetingUri, {
+      abi: true
+    })
+
+    expect(result.ok).toBeFalsy();
+  });
 });

packages/js/client/src/__tests__/utils/validate/wrapper-a/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "wrapper-a",
+  "private": true,
+  "dependencies": {
+    "@polywrap/wasm-as": "0.9.2",
+    "assemblyscript": "0.19.23"
+  }
+}

packages/js/client/src/__tests__/utils/validate/wrapper-a/polywrap.yaml

@@ -0,0 +1,7 @@
+format: 0.2.0
+project:
+  name: WrapperA
+  type: wasm/assemblyscript
+source:
+  schema: ./schema.graphql
+  module: ./src/index.ts

packages/js/client/src/__tests__/utils/validate/wrapper-a/schema.graphql

@@ -0,0 +1,3 @@
+type Module {
+    foo(bar: String!): String!
+}

packages/js/client/src/__tests__/utils/validate/wrapper-a/src/index.ts

@@ -0,0 +1,7 @@
+import {
+  Args_foo
+} from "./wrap";
+
+export function foo(args: Args_foo): String {
+  return args.bar
+}

packages/js/client/src/__tests__/utils/validate/wrapper-b/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "wrapper-b",
+  "private": true,
+  "dependencies": {
+    "@polywrap/wasm-as": "0.9.2",
+    "assemblyscript": "0.19.23"
+  }
+}

packages/js/client/src/__tests__/utils/validate/wrapper-b/polywrap.yaml

@@ -0,0 +1,10 @@
+format: 0.2.0
+project:
+  name: WrapperB
+  type: wasm/assemblyscript
+source:
+  schema: ./schema.graphql
+  module: ./src/index.ts
+  import_abis:
+    - uri: "ens/foo.eth"
+      abi: "../wrapper-a/build/wrap.info"

packages/js/client/src/__tests__/utils/validate/wrapper-b/schema.graphql

@@ -0,0 +1,5 @@
+#import { Module } into Foo from "ens/foo.eth"
+
+type Module {
+    greeting(message: String!): String!
+}

packages/js/client/src/__tests__/utils/validate/wrapper-b/src/index.ts

@@ -0,0 +1,8 @@
+import {
+  Args_greeting,
+  Foo_Module
+} from "./wrap";
+
+export function greeting(args: Args_greeting): String {
+  return Foo_Module.foo({ bar: args.message }).unwrap();
+}

packages/js/client/src/__tests__/utils/validate/wrapper-c/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "wrapper-c",
+  "private": true,
+  "dependencies": {
+    "@polywrap/wasm-as": "0.9.2",
+    "assemblyscript": "0.19.23"
+  }
+}

packages/js/client/src/__tests__/utils/validate/wrapper-c/polywrap.yaml

@@ -0,0 +1,7 @@
+format: 0.2.0
+project:
+  name: WrapperC
+  type: wasm/assemblyscript
+source:
+  schema: ./schema.graphql
+  module: ./src/index.ts

packages/js/client/src/__tests__/utils/validate/wrapper-c/schema.graphql

@@ -0,0 +1,3 @@
+type Module {
+    foo(bar: Int!): String!
+}

packages/js/client/src/__tests__/utils/validate/wrapper-c/src/index.ts

@@ -0,0 +1,7 @@
+import {
+  Args_foo
+} from "./wrap";
+
+export function foo(args: Args_foo): String {
+  return args.bar.toString()
+}

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

@@ -32,6 +32,11 @@ export interface GetImplementationsOptions {
   resolutionContext?: IUriResolutionContext;
 }
 
+export interface ValidateOptions {
+  abi?: boolean;
+  recursive?: boolean;
+}
+
 export interface CoreClient
   extends Invoker,
     QueryHandler,
@@ -60,4 +65,9 @@ export interface CoreClient
     uri: TUri,
     options: GetImplementationsOptions
   ): Promise<Result<TUri[], Error>>;
+
+  validate<TUri extends Uri | string>(
+    uri: TUri,
+    options?: ValidateOptions
+  ): Promise<Result<true, Error>>;
 }

packages/js/manifests/wrap/scripts/templates/index-ts.mustache

@@ -65,4 +65,4 @@ export type AnyWrapAbi =
 export { migrateWrapManifest } from "./migrate";
 export { deserializeWrapManifest } from "./deserialize";
 export { serializeWrapManifest } from "./serialize";
-export { validateWrapManifest } from "./validate";
+export { validateWrapManifest } from "./validate";

packages/js/manifests/wrap/src/compareSignature.ts

@@ -0,0 +1,25 @@
+import {
+  MethodDefinition, PropertyDefinition,
+} from ".";
+
+export default (
+  importedMethod: MethodDefinition,
+  expectedMethod: MethodDefinition
+): boolean => {
+    if (expectedMethod.name === importedMethod.name) {
+      return false
+    }
+
+    if (expectedMethod.arguments) {
+      const expectedArgs = expectedMethod.arguments.some(({type, name}, index) => {
+        const importedArgs = importedMethod.arguments as PropertyDefinition[]
+        const { name: importedName, type: importedType } = importedArgs[index]
+        return importedName === name && importedType === type
+      })
+
+      if (!expectedArgs) {
+        return false
+      }
+    }
+    return true
+}

packages/js/manifests/wrap/src/formats/wrap.info/index.ts

@@ -51,4 +51,4 @@ export const latestWrapAbiVersion = "0.1";
 export { migrateWrapManifest } from "./migrate";
 export { deserializeWrapManifest } from "./deserialize";
 export { serializeWrapManifest } from "./serialize";
-export { validateWrapManifest } from "./validate";
+export { validateWrapManifest } from "./validate";