feat(wasm-rs): codegen should create IModule interface

WRAP_TEST_HARNESS

@@ -1 +1 @@
-master
+module-trait-rs

packages/js/client/src/__tests__/core/type-test-cases.ts

@@ -690,19 +690,19 @@ export const typeTestCases = (implementation: string) => {
         },
       ]);
 
-      const method5 = await client.invoke({
+      const method4 = await client.invoke({
         uri,
-        method: "method5",
+        method: "method4",
         args: {
           arg: {
             prop: [49, 50, 51, 52],
           },
         },
       });
 
-      if (!method5.ok) fail(method5.error);
-      expect(method5.value).toBeTruthy();
-      expect(method5.value).toEqual({
+      if (!method4.ok) fail(method4.error);
+      expect(method4.value).toBeTruthy();
+      expect(method4.value).toEqual({
         prop: "1234",
         nested: {
           prop: "nested prop",

packages/js/uri-resolver-extensions/src/__tests__/wrappers/test-resolver/polywrap.build.yaml

@@ -0,0 +1,4 @@
+format: 0.2.0
+linked_packages:
+  - name: "polywrap-wasm-rs"
+    path: ../../../../../../wasm/rs/

packages/js/uri-resolver-extensions/src/__tests__/wrappers/test-resolver/polywrap.yaml

@@ -5,3 +5,5 @@ project:
 source:
   module: ./Cargo.toml
   schema: ./polywrap.graphql
+extensions:
+  build: ./polywrap.build.yaml

packages/js/uri-resolver-extensions/src/__tests__/wrappers/test-resolver/src/lib.rs

@@ -1,30 +1,39 @@
 pub mod wrap;
 use wrap::{
     *,
+    env::{Env},
     imported::{
         ArgsGetFile, ArgsTryResolveUri,
     }
 };
 
-pub fn try_resolve_uri(args: ArgsTryResolveUri, _env: Option<Env>) -> Option<UriResolverMaybeUriOrManifest> {
-    if args.authority != "test" {
-        return None;
-    }
-
-    match args.path.as_str() {
-        "from" => Some(UriResolverMaybeUriOrManifest {
-            manifest: None,
-            uri: Some("test/to".to_string())
-        }),
-        "package" => Some(UriResolverMaybeUriOrManifest {
-            manifest: Some(vec![0]),
-            uri: None
-        }),
-        "error" => panic!("Test error"),
-        _ => None
+impl ModuleTrait for Module {
+    fn try_resolve_uri(
+        args: ArgsTryResolveUri,
+        _env: Option<Env>
+    ) -> Result<Option<UriResolverMaybeUriOrManifest>, String> {
+        if args.authority != "test" {
+            return Ok(None);
+        }
+
+        match args.path.as_str() {
+            "from" => Ok(Some(UriResolverMaybeUriOrManifest {
+                manifest: None,
+                uri: Some("test/to".to_string())
+            })),
+            "package" => Ok(Some(UriResolverMaybeUriOrManifest {
+                manifest: Some(vec![0]),
+                uri: None
+            })),
+            "error" => Err("Test error".to_string()),
+            _ => Ok(None)
+        }
     }
-}
 
-pub fn get_file(_args: ArgsGetFile, _env: Option<Env>) -> Option<Vec<u8>> {
-    return None;
-}
+    fn get_file(
+        _args: ArgsGetFile,
+        _env: Option<Env>
+    ) -> Result<Option<Vec<u8>>, String> {
+        return Ok(None);
+    }
+}

packages/schema/bind/src/bindings/rust/plugin/index.ts

@@ -1,4 +1,4 @@
-import * as Transforms from "./transforms";
+import * as Transforms from "../transforms";
 import { Functions } from "../";
 import { GenerateBindingFn, renderTemplates } from "../..";
 import { BindOptions, BindOutput } from "../../..";

packages/schema/bind/src/bindings/rust/plugin/transforms/propertyDeps.ts → packages/schema/bind/src/bindings/rust/transforms/propertyDeps.ts

@@ -1,13 +1,14 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 /* eslint-disable no-useless-escape */
-import { isBaseType, isBuiltInType } from "../../types";
+import { isBaseType, isBuiltInType } from "../types";
 
 import {
   ImportedModuleDefinition,
   ObjectDefinition,
   AnyDefinition,
   ModuleDefinition,
   EnvDefinition,
+  Abi,
 } from "@polywrap/wrap-manifest-types-js";
 import { AbiTransforms } from "@polywrap/schema-parse";
 
@@ -18,6 +19,7 @@ interface PropertyDep {
 }
 
 interface PropertyDepsState {
+  abiEnvDefinition?: EnvDefinition;
   envDefinition?: EnvDefinition;
   objectDefinition?: ObjectDefinition;
   moduleDefinition?: ModuleDefinition;
@@ -30,6 +32,12 @@ export function propertyDeps(): AbiTransforms {
 
   return {
     enter: {
+      Abi: (abi: Abi) => {
+        if (abi.envType) {
+          state.abiEnvDefinition = abi.envType;
+        }
+        return abi;
+      },
       EnvDefinition: (def: EnvDefinition) => {
         state.envDefinition = def;
         state.propertyDeps = [];
@@ -43,6 +51,13 @@ export function propertyDeps(): AbiTransforms {
       ModuleDefinition: (def: ModuleDefinition) => {
         state.moduleDefinition = def;
         state.propertyDeps = [];
+        if (state.abiEnvDefinition) {
+          state.propertyDeps.push({
+            crate: "crate",
+            type: "Env",
+            isEnum: false,
+          });
+        }
         return def;
       },
       ImportedModuleDefinition: (def: ImportedModuleDefinition) => {

packages/schema/bind/src/bindings/rust/wasm/index.ts

@@ -1,4 +1,4 @@
-import * as Transforms from "./transforms";
+import * as Transforms from "../transforms";
 import { Functions } from "../";
 import { GenerateBindingFn, renderTemplates } from "../..";
 import { loadSubTemplates } from "../../utils";

packages/schema/bind/src/bindings/rust/wasm/templates/entry-rs.mustache

@@ -12,20 +12,29 @@ use polywrap_wasm_rs::{
     invoke,
     InvokeArgs,
 };
+use crate::module::Module;
 
 #[no_mangle]
 pub extern "C" fn _wrap_invoke(method_size: u32, args_size: u32, env_size: u32) -> bool {
     // Ensure the abort handler is properly setup
     abort::wrap_abort_setup();
 
     let args: InvokeArgs = invoke::wrap_invoke_args(method_size, args_size);
+    let result: Vec<u8>;
 
     match args.method.as_str() {
         {{#moduleType}}
         {{#methods}}
-        "{{name}}" => invoke::wrap_invoke(args, env_size, Some({{#toLower}}{{name}}{{/toLower}}_wrapped)),
+        "{{name}}" => {
+            result = {{#toLower}}{{name}}{{/toLower}}_wrapped(args.args.as_slice(), env_size);
+        }
         {{/methods}}
         {{/moduleType}}
-        _ => invoke::wrap_invoke(args, env_size, None),
-    }
+        _ => {
+            invoke::wrap_invoke_error(format!("Could not find invoke function {}", args.method));
+            return false;
+        }
+    };
+    invoke::wrap_invoke_result(result);
+    return true;
 }

packages/schema/bind/src/bindings/rust/wasm/templates/mod-rs.mustache

@@ -43,6 +43,8 @@ pub use {{#detectKeyword}}{{#toLower}}{{namespace}}{{/toLower}}{{/detectKeyword}
 {{#moduleType}}
 pub mod {{#detectKeyword}}{{#toLower}}{{type}}{{/toLower}}{{/detectKeyword}};
 pub use {{#detectKeyword}}{{#toLower}}{{type}}{{/toLower}}{{/detectKeyword}}::{
+    Module,
+    ModuleTrait,
     {{#methods}}
     deserialize_{{#toLower}}{{name}}{{/toLower}}_args,
     serialize_{{#toLower}}{{name}}{{/toLower}}_result,

packages/schema/bind/src/bindings/rust/wasm/templates/module-type/mod-rs.mustache

@@ -15,4 +15,7 @@ pub use serialization::{
     {{/methods}}
 };
 {{/methods.length}}
+
+pub mod module;
+pub use module::*;
 {{/moduleType}}

packages/schema/bind/src/bindings/rust/wasm/templates/module-type/module-rs.mustache

@@ -0,0 +1,37 @@
+{{#moduleType}}
+use crate::{
+    {{#methods}}
+    Args{{#toUpper}}{{name}}{{/toUpper}},
+    {{/methods}}
+};
+use polywrap_wasm_rs::{
+    BigInt,
+    BigNumber,
+    Map,
+    JSON,
+};
+{{#propertyDeps.length}}
+
+{{#propertyDeps}}
+{{^isEnum}}
+use {{crate}}::{{#detectKeyword}}{{#toUpper}}{{type}}{{/toUpper}}{{/detectKeyword}};
+{{/isEnum}}
+{{#isEnum}}
+use crate::{
+    {{#detectKeyword}}{{#toUpper}}{{type}}{{/toUpper}}{{/detectKeyword}},
+};
+{{/isEnum}}
+{{/propertyDeps}}
+{{/propertyDeps.length}}
+
+pub struct Module;
+
+pub trait ModuleTrait {
+  {{#methods}}
+  fn {{#detectKeyword}}{{#toLower}}{{name}}{{/toLower}}{{/detectKeyword}}(args: Args{{#toUpper}}{{name}}{{/toUpper}}{{#env}}, env: {{#required}}Env{{/required}}{{^required}}Option<Env>{{/required}}{{/env}}) -> Result<{{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}}, String>;
+  {{^last}}
+
+  {{/last}}
+  {{/methods}}
+}
+{{/moduleType}}

packages/schema/bind/src/bindings/rust/wasm/templates/module-type/wrapped-rs.mustache

@@ -6,20 +6,18 @@ use polywrap_wasm_rs::{
 
 use crate::{
     {{#methods}}
-    {{#detectKeyword}}{{#toLower}}{{name}}{{/toLower}}{{/detectKeyword}},
     Args{{#toUpper}}{{name}}{{/toUpper}},
     deserialize_{{#toLower}}{{name}}{{/toLower}}_args,
     serialize_{{#toLower}}{{name}}{{/toLower}}_result{{^last}},{{/last}}
     {{/methods}}
 };
 {{/methods.length}}
-{{/moduleType}}
 
+use crate::module::{ModuleTrait, Module};
 {{#envType}}
 use crate::Env;
 {{/envType}}
 
-{{#moduleType}}
 {{#methods}}
 pub fn {{#toLower}}{{name}}{{/toLower}}_wrapped(args: &[u8], env_size: u32) -> Vec<u8> {
     {{#env}}
@@ -34,7 +32,6 @@ pub fn {{#toLower}}{{name}}{{/toLower}}_wrapped(args: &[u8], env_size: u32) -> V
     {{/required}}
     {{^required}}
     let mut env: Option<Env> = None;
-
     if env_size > 0 {
       let env_buf = wrap_load_env(env_size);
       env = Some(Env::from_buffer(&env_buf).unwrap());
@@ -46,12 +43,19 @@ pub fn {{#toLower}}{{name}}{{/toLower}}_wrapped(args: &[u8], env_size: u32) -> V
     match deserialize_{{#toLower}}{{name}}{{/toLower}}_args(args) {
         Ok(args) => {
     {{/arguments.length}}
-            let result = {{#detectKeyword}}{{#toLower}}{{name}}{{/toLower}}{{/detectKeyword}}(Args{{#toUpper}}{{name}}{{/toUpper}} {
+            let result = Module::{{#detectKeyword}}{{#toLower}}{{name}}{{/toLower}}{{/detectKeyword}}(Args{{#toUpper}}{{name}}{{/toUpper}} {
                 {{#arguments}}
                 {{#detectKeyword}}{{#toLower}}{{name}}{{/toLower}}{{/detectKeyword}}: args.{{#detectKeyword}}{{#toLower}}{{name}}{{/toLower}}{{/detectKeyword}},
                 {{/arguments}}
             }{{#env}}, env{{/env}});
-            serialize_{{#toLower}}{{name}}{{/toLower}}_result({{#return}}&{{/return}}result).unwrap()
+            match result {
+                Ok(res) => {
+                    serialize_{{#toLower}}{{name}}{{/toLower}}_result({{#return}}&{{/return}}res).unwrap()
+                }
+                Err(e) => {
+                    panic!("{}", e.to_string())
+                }
+            }
     {{#arguments.length}}
         }
         Err(e) => {