`exec` generic type def doubly wrapped `Promise`?

[vincerubinetti]

Currently the type definition for exec looks like this:

exec<T extends (...args: any[]) => any>(method: string | T, params?: Parameters<T> | null | undefined, options?: import("./types.js").ExecOptions | undefined): Promise<ReturnType<T>>;

Note the Promise<ReturnType<T>>. I think this unnecessarily wraps the ReturnType in a Promise when the return type already is a promise. I think it should be something like Promisify<ReturnType<T>> and type Promisify<T> = T extends Promise<any> ? T : Promise<T>; (wraps type in promise, but only if not already a promise).

I pretty sure it should be like this, because just testing out...

// worker

export const encode = async (blah: any) => {
  const encoder = await createEncoder();
  // ...
  return new Blob();
};

export type Encode = typeof encode;

workerpool.worker({ encode });

// consumer

import EncodeWorker from "./encode.worker?worker&url";
import { Encode } from "./encode.worker.ts";

const encoderPool = workerpool.pool(EncodeWorker);
const getBlob = (blah: any) =>
  encoderPool.exec<Encode>("encode", [blah]);

// test

getBlob(blah).then((result) => console.log(result));

Typescript says result is type Promise<Blob>, but console log shows just Blob. I didn't look at the exec implementation, but the result is definitely just a blob, so the typing must be wrong.

[vincerubinetti]

As a side note but somewhat related, I find the typing of this library leaves a bit to be desired as compared to the comlink library that I'm coming from. Not meant as a harsh criticism, this library's functionality is awesome and way beyond what comlink offers, but I wonder if you'd consider making some changes that would allow better typing.

For example, exec currently allows any function string key as its first arg, even when providing the generic argument. The params are typed correctly though, so that's good.

I wonder if the exec typing could be changed in a non-breaking way to something like this:

type APIShape = Record<string, (...args: any[]) => any>;

const exec = <
  API extends APIShape = APIShape,
  Key extends keyof API = keyof API,
  Params extends Parameters<API[Key]> = Parameters<API[Key]>,
>(
  key: Key,
  params: Params,
) => {
  console.log(key, params);
};

type API = {
  someFunc: (a: number) => void;
};

exec<API>("foo", [123]); // errors on "foo"
exec<API>("someFunc", ["abc"]); // errors on "abc"
exec<API>("someFunc", [123]); // ✅
exec("foo", [123]); // allows untyped

(I'm not a TS wizard, and I'm just brainstorming here).

[josdejong]

Thanks for your input. It would be neat indeed to improve the typings such that you don't get a double Promise returned.

I would love to rewrite the code of workerpool into TypeScript, that should also improve the typings. I like your idea with API typings too: define the types of the functions that a worker offers, and use that with exec.

Help improving the type definitions would be very welcome!