Promisified功能类型

Question

我正在编写RFC库。 基本上我有一个在服务器上实现并由客户端中的Proxy包装的接口。 Proxy然后在后台进行http调用以调用服务器上的方法。

这适用于已经返回Promise的函数。 但是在客户端上，函数将始终通过Promise包装器返回Proxy，但类型系统不知道这一点。

因此，使用以下代码，我将创建一个映射类型，以将函数的返回类型更改为Promise。

// Generic Function definition
type AnyFunction = (...args: any[]) => any;
// Extracts the type if wrapped by a Promise
type Unpacked<T> = T extends Promise<infer U> ? U : T;

type PromisifiedFunction<T extends AnyFunction> =
    T extends () => infer U ? () => Promise<Unpacked<U>> :
    T extends (a1: infer A1) => infer U ? (a1: A1) => Promise<Unpacked<U>> :
    T extends (a1: infer A1, a2: infer A2) => infer U ? (a1: A1, a2: A2) => Promise<Unpacked<U>> :
    T extends (a1: infer A1, a2: infer A2, a3: infer A3) => infer U ? (a1: A1, a2: A2, a3: A3) => Promise<Unpacked<U>> :
    // ...
    T extends (...args: any[]) => infer U ? (...args: any[]) => Promise<Unpacked<U>> : T;

type Promisified<T> = {
    [K in keyof T]: T[K] extends AnyFunction ? PromisifiedFunction<T[K]> : never
}

示例：

interface HelloService {
    /**
    * Greets the given name
    * @param name 
    */
    greet(name: string): string;
}

function createRemoteService<T>(): Promisified<T> { /*...*/ }

const hello = createRemoteService<HelloService>();
// typeof hello = Promisified<HelloService>
hello.greet("world").then(str => { /*...*/ }) // all fine here
// typeof hello.greet = (a1: string) => Promise<string>

一切顺利，问题是什么？

我不喜欢这个实现的是，参数名称和文档丢失了（至少在vs代码中）。

因此，对于那些只想使用服务的人来说，在外部的某处查找服务定义并不是一个很好的开发经验。

我不喜欢的另一件事是我必须为每一个参数写一个定义。但我想在Typescript支持Variadic Types之前别无他法。

编辑：在继续使用此功能的同时，我发现了一个更大的问题： 在接口中具有重载函数时，未正确推断映射接口。

interface HelloService {
    greet(name: string): string;
    greet(id: number): string;
}

根据函数的顺序，映射类型为
typeof hello.greet = (a1: string) => Promise<string>或
typeof hello.greet = (a1: number) => Promise<string>

但它应该是：
typeof hello.greet = (a1: string|number) => Promise<string>

那么关于如何改进这个的任何建议？

Answer 1

使用新的Typescript 3.0，可以使用generic rest parameters。

这使我们可以指定如下类型：

type UnpackPromise<T> = T extends Promise<infer U> ? U : T;

type AnyFunction<U extends any[], V> = (...args: U) => V;
type Promisified<T> = {
    [K in keyof T]: T[K] extends AnyFunction<infer U, infer V> ? (...args: U) => Promise<UnpackPromise<V>> : never;
}