Support guest-type generation of async exports

[mschuwalow]

Currently the counterparts of the async options for the regular types command are missing for the guest-types command https://github.com/bytecodealliance/jco/blob/main/src/jco.js#L87-L91.

Specifically generating async-exports would be very useful as it shows up easily when using something like the fetch api and componentize-js can handle async exports.

[vados-cosmonic]

Hey @mschuwalow this is intended, because at present there is only async support in the host at present (those options don't mean quite the same thing in the guest context). The work on P3 async is still under way (see #617) , but at the JS level you can absolutely use async as you have noticed.

It's completely up to the user how they define the functions that they export when defining a component, so you are free to use async exports right now:

For example if you were building a component that implements wasi:cli/run:

export const run {
    async run() {
        // ...
    }
}

This is perfectly fine and compiles and runs, and doesn't produce any typechecking failures AFAIK, mostly because the types of the module that represents the component aren't exposed/used.

Are you writing code that looks more like this:

import type { run as wasiCliRun } from "wasi:cli/run@0.2.3";

export const run: { run: typeof wasiCliRun } = {
  async run() {
    // ...
  }
};

This also happens to type check for me, but I can see how there is definitely a difference between the stated types and the actual types (i.e. Promise<void> versus void).

Would you mind expanding on exactly what you would like to see change? Is it literally that you'd prefer the return types for generated function types in the .d.ts files to be Promises rather than the current bare values?

[vados-cosmonic]

Another variation that also type checks fine, but uses the top level wit.d.ts that is generated:

import type { run as wasiCliRun } from "wasmcloud:examples/component";

export const run: typeof wasiCliRun = {
  async run() {
    // ...
  }
};

This also requires that you actually produce the run function (not misnamed, etc).

[mschuwalow]

@vados-cosmonic thanks!

Sadly, this approach stops working if you try to generate types for a component that exports a function that returns a value instead of void.

wit:

package pack:name;

interface foo {
  bar: func(arg: u32) -> u32;
}

world component {
  export foo;
}

implementation

import type { foo as wasiFoo } from "pack:name/component";

export const foo: typeof wasiFoo = {
  async bar(arg: number) {
    return 0
  }
}

Will fail typechecking with something like

'(arg: number) => Promise<number>' is not assignable to type '(in_: number) => number'

So optimally I would like all bindings to be generated such that they return promise, or at least have an option to generate bindings for a specific function such that it returns a promise.
The later is actually somewhat possible using the javascript api already (though it's a hack).

[vados-cosmonic]

Thanks for clarifying and doing a bit more testing to flesh this out! Hopefully we can get this in soon