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

.github/workflows/ci-wrap-test-harness.yaml

@@ -53,7 +53,6 @@ jobs:
       - name: Checkout Repository
         uses: actions/checkout@v2
         with:
-          ref: ${{ github.event.pull_request.base.ref }}
           path: toolchain
           fetch-depth: 0
 
@@ -104,19 +103,16 @@ jobs:
             cargo-${{ runner.os }}-${{ github.job }}
 
       - name: Set environment variable
-        run: echo "POLYWRAP_CLI_PATH=${{ github.workspace }}/toolchain/packages/cli" >> $GITHUB_ENV
+        run: echo POLYWRAP_CLI_PATH=$(pwd)/toolchain/packages/cli >> $GITHUB_ENV
 
       - name: Set environment variable
-        if: ${{ inputs.wasm-path }}
-        run: echo "POLYWRAP_WASM_PATH=${{ github.workspace }}/toolchain/packages/wasm" >> $GITHUB_ENV
+        run: echo POLYWRAP_WASM_PATH=$(pwd)/toolchain/packages/wasm >> $GITHUB_ENV
 
-      - uses: nick-fields/retry@v2
-        name: Run wrappers build
-        with:
-          command: cargo run -- -w
-          max_attempts: 3
-          retry_on: error
-          timeout_minutes: 60
+      - name: Run wrappers build
+        run: cargo run -- -w
+        env:
+          POLYWRAP_CLI_PATH: ${{env.POLYWRAP_CLI_PATH}}
+          POLYWRAP_WASM_PATH: ${{env.POLYWRAP_WASM_PATH}}
 
       - uses: actions/upload-artifact@v3
         with:

WRAP_TEST_HARNESS

@@ -1 +1 @@
-master
+module-class-wasm-as

packages/cli/src/lib/build-strategies/strategies/DockerVMStrategy.ts

@@ -176,10 +176,12 @@ export class DockerVMBuildStrategy extends BuildStrategy<void> {
         });
 
         // For rust, we want to also mount the cargo registry's cache directory
-        const localCargoCache = `${process.env.HOME}/.cargo/registry`;
-        let cacheVolume = "";
+        const localCargoCache = `${process.env.HOME}/.cargo`;
+        const cacheVolumes: string[] = [];
         if (language === "wasm/rust" && fse.existsSync(localCargoCache)) {
-          cacheVolume = `-v ${localCargoCache}:/usr/local/cargo/registry`;
+          cacheVolumes.push(`-v ${localCargoCache}:/usr/local/cargo`);
+          // Ignore the bin folder, without this an exception is thrown upon exe exec
+          cacheVolumes.push(`-v /usr/local/cargo/bin/`);
         }
 
         let buildError: Error | undefined = undefined;
@@ -196,7 +198,7 @@ export class DockerVMBuildStrategy extends BuildStrategy<void> {
               `${path.resolve(
                 this._volumePaths.linkedPackages
               )}:/linked-packages`,
-              cacheVolume,
+              ...cacheVolumes,
               `${CONFIGS[language].baseImage}:${CONFIGS[language].version}`,
               "/bin/bash",
               "--verbose",

packages/js/client/src/__tests__/core/error-structure.spec.ts

@@ -202,11 +202,9 @@ describe("Error structure", () => {
         ).toBeTruthy();
         expect(result.error?.method).toEqual("throwError");
         expect(result.error?.args).toEqual('{\n  "a": "Hey"\n}');
-        expect(result.error?.source).toEqual({
-          file: "~lib/@polywrap/wasm-as/containers/Result.ts",
-          row: 171,
-          col: 13,
-        });
+        expect(result.error?.source?.file).toEqual(
+          "~lib/@polywrap/wasm-as/containers/Result.ts"
+        );
 
         expect(result.error?.innerError instanceof WrapError).toBeTruthy();
         const prev = result.error?.innerError as WrapError;
@@ -409,11 +407,7 @@ describe("Error structure", () => {
         ).toBeTruthy();
         expect(result.error?.method).toEqual("throwError");
         expect(result.error?.args).toEqual('{\n  "a": "Hey"\n}');
-        expect(result.error?.source).toEqual({
-          file: "src/lib.rs",
-          row: 10,
-          col: 117,
-        });
+        expect(result.error?.source?.file).toEqual("src/lib.rs");
 
         expect(result.error?.innerError instanceof WrapError).toBeTruthy();
         const prev = result.error?.innerError as WrapError;

packages/schema/bind/src/bindings/assemblyscript/wasm/templates/entry-ts.mustache

@@ -1,6 +1,7 @@
 import {
   wrap_invoke_args,
-  wrap_invoke,
+  wrap_invoke_result,
+  wrap_invoke_error,
   wrap_abort,
   InvokeArgs
 } from "@polywrap/wasm-as";
@@ -15,22 +16,30 @@ import {
 {{/methods.length}}
 {{/moduleType}}
 
+import { Module } from "../index";
+
 export function _wrap_invoke(method_size: u32, args_size: u32, env_size: u32): bool {
+  const module = new Module();
   const args: InvokeArgs = wrap_invoke_args(
     method_size,
     args_size
   );
-
+  let result: ArrayBuffer;
   {{#moduleType}}
   {{#methods}}
   {{^first}}else {{/first}}if (args.method == "{{name}}") {
-    return wrap_invoke(args, env_size, {{name}}Wrapped);
+    result = {{name}}Wrapped(module, args.args, env_size);
   }
   {{/methods}}
   {{/moduleType}}
   else {
-    return wrap_invoke(args, env_size, null);
+    wrap_invoke_error(
+      `Could not find invoke function "${args.method}"`
+    );
+    return false;
   }
+  wrap_invoke_result(result);
+  return true;
 }
 
 export function wrapAbort(

packages/schema/bind/src/bindings/assemblyscript/wasm/templates/index-ts.mustache

@@ -16,6 +16,9 @@ export {
 };
 {{/methods.length}}
 {{/moduleType}}
+{{#moduleType}}
+export { ModuleBase } from "./Module";
+{{/moduleType}}
 {{#objectTypes}}
 export { {{#detectKeyword}}{{type}}{{/detectKeyword}} } from "./{{type}}";
 {{/objectTypes}}

packages/schema/bind/src/bindings/assemblyscript/wasm/templates/module-type/index-ts.mustache

@@ -10,4 +10,5 @@ export {
   Args_{{#detectKeyword}}{{name}}{{/detectKeyword}}{{^last}},{{/last}}
   {{/methods}}
 };
+export { ModuleBase } from "./module";
 {{/methods.length}}

packages/schema/bind/src/bindings/assemblyscript/wasm/templates/module-type/module-ts.mustache

@@ -0,0 +1,20 @@
+import * as Types from "..";
+
+import {
+  BigInt,
+  BigNumber,
+  Box,
+  JSON,
+} from "@polywrap/wasm-as";
+
+export abstract class ModuleBase {
+  {{#methods}}
+  abstract {{#detectKeyword}}{{name}}{{/detectKeyword}}(
+    args: Types.Args_{{#detectKeyword}}{{name}}{{/detectKeyword}}{{#env}},
+    env: {{#required}}Types.Env{{/required}}{{^required}}Types.Env | null{{/required}}{{/env}}
+  ): {{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}};
+  {{^last}}
+
+  {{/last}}
+  {{/methods}}
+}

packages/schema/bind/src/bindings/assemblyscript/wasm/templates/module-type/wrapped-ts.mustache

@@ -1,21 +1,17 @@
 {{#methods.length}}
 import { wrap_load_env } from "@polywrap/wasm-as";
-import {
-  {{#methods}}
-  {{#detectKeyword}}{{name}}{{/detectKeyword}}{{^last}},{{/last}}
-  {{/methods}}
-} from "../../index";
 import {
   {{#methods}}
   deserialize{{name}}Args,
   serialize{{name}}Result{{^last}},{{/last}}
   {{/methods}}
 } from "./serialization";
 {{/methods.length}}
+import { ModuleBase } from "./module";
 import * as Types from "..";
 
 {{#methods}}
-export function {{name}}Wrapped(argsBuf: ArrayBuffer, env_size: u32): ArrayBuffer {
+export function {{name}}Wrapped(module: ModuleBase, argsBuf: ArrayBuffer, env_size: u32): ArrayBuffer {
   {{#env}}
   {{#required}}
   if (env_size == 0) {
@@ -37,7 +33,7 @@ export function {{name}}Wrapped(argsBuf: ArrayBuffer, env_size: u32): ArrayBuffe
   const args = deserialize{{name}}Args(argsBuf);
   {{/arguments.length}}
 
-  const result = {{#detectKeyword}}{{name}}{{/detectKeyword}}({{#arguments.length}}
+  const result = module.{{#detectKeyword}}{{name}}{{/detectKeyword}}({{#arguments.length}}
     {
       {{#arguments}}
       {{#detectKeyword}}{{name}}{{/detectKeyword}}: args.{{#detectKeyword}}{{name}}{{/detectKeyword}}{{^last}},{{/last}}
@@ -50,4 +46,4 @@ export function {{name}}Wrapped(argsBuf: ArrayBuffer, env_size: u32): ArrayBuffe
 {{^last}}
 
 {{/last}}
-{{/methods}}
+{{/methods}}

packages/schema/parse/src/__tests__/dunder-methods.spec.ts

@@ -0,0 +1,53 @@
+import { parseSchema } from "..";
+
+const ErrorSchemas = {
+  "__new__": `
+  type Module {
+    __new__: String!
+  }
+  `,
+  "__hello__": `
+  type Module {
+    __hello__: String!
+  }
+  `,
+}
+
+const ValidSchemas = {
+  "_new_": `
+  type Module {
+    _new_: String!
+  }
+  `,
+  "__new": `
+  type Module {
+    __new: String!
+  }
+  `,
+  "new__": `
+  type Module {
+    new__: String!
+  }
+  `,
+  "_hello__": `
+  type Module {
+    _hello__: String!
+  }
+  `
+}
+
+describe("Polywrap Schema shouldn't contain dunder method name", () => {
+
+  for (const [key, value] of Object.entries(ErrorSchemas)) {
+    it(`should throw error for ${key}`, () => {
+      expect(() => parseSchema(value)).toThrowError();
+    });
+  }
+
+  for (const [key, value] of Object.entries(ValidSchemas)) {
+    it(`shouldn't throw error for ${key}`, () => {
+      expect(() => parseSchema(value)).not.toThrowError();
+    });
+  }
+
+})

packages/schema/parse/src/abi/definitions.ts

@@ -305,6 +305,11 @@ export function createObjectPropertyDefinition(
 export function createMethodDefinition(
   args: Omit<Omit<MethodDefinition, "kind">, "type">
 ): MethodDefinition {
+  if (args.name?.startsWith("__") && args.name?.endsWith("__")) {
+    throw new Error(
+      "Dunder methods (Methods starting and ending with __) are reserved methods"
+    );
+  }
   return {
     ...args,
     ...createGenericDefinition({

packages/templates/wasm/assemblyscript/src/index.ts

@@ -1,7 +1,9 @@
-import { Args_sampleMethod, SampleResult } from "./wrap";
+import { Args_sampleMethod, SampleResult, ModuleBase } from "./wrap";
 
-export function sampleMethod(args: Args_sampleMethod): SampleResult {
-  return {
-    result: args.arg,
-  };
+export class Module extends ModuleBase {
+  sampleMethod(args: Args_sampleMethod): SampleResult {
+    return {
+      result: args.arg,
+    };
+  }
 }

packages/test-cases/cases/bind/sanity/output/wasm-as/Module/index.ts

@@ -11,3 +11,4 @@ export {
   Args_optionalEnvMethod,
   Args__if
 };
+export { ModuleBase } from "./module";

packages/test-cases/cases/bind/sanity/output/wasm-as/Module/module.ts

@@ -0,0 +1,28 @@
+import * as Types from "..";
+
+import {
+  BigInt,
+  BigNumber,
+  Box,
+  JSON,
+} from "@polywrap/wasm-as";
+
+export abstract class ModuleBase {
+  abstract moduleMethod(
+    args: Types.Args_moduleMethod
+  ): i32;
+
+  abstract objectMethod(
+    args: Types.Args_objectMethod,
+    env: Types.Env
+  ): Types.AnotherType | null;
+
+  abstract optionalEnvMethod(
+    args: Types.Args_optionalEnvMethod,
+    env: Types.Env | null
+  ): Types.AnotherType | null;
+
+  abstract _if(
+    args: Types.Args__if
+  ): Types._else;
+}