广义“promisify”函数中的打字稿类型推断

Question

上下文

最近我正在研究第三方库的“承诺”。基本上，该库充满了 NodeJS 异步风格的函数（使用回调作为最后一个参数）。 IE。签名与此类似的函数：

function foo(arg1: string, arg2: number, ..., callback: (error, result) => void): void

我试图写一个函数来减少包装原始函数的代码，并将它们变成Promise<T>返回函数：

function cb<TResult>(
  resolve: (res: TResult) => void,
  reject: (err: any) => void
): (actualError, actualResult) => void {

  return (error, result) => error ? reject(error) : resolve(result);
}

然后为了保证方法，我会写这样的代码：

patchUserMetadata(userId: string, userMetadata: any): Promise<a0.Auth0UserProfile> {
  return new Promise((resolve, reject) =>
    this.wrapped.patchUserMetadata(userId, userMetadata, cb(resolve, reject)));
}

linkUser(userId: string, secondaryUserToken: string): Promise<any> {
  return new Promise((resolve, reject) =>
    this.wrapped.linkUser(userId, secondaryUserToken, cb(resolve, reject)));
}

// ... and so on, and on, and on...

---

如您所见，我对 TypeScript 还不是很熟悉，基本上是在尝试重新发明轮子。我的轮子最终变成了一个六边形，我一直在手动编写太多的包装代码......

审阅我的代码的人指出，我可以使用 js-promisify 以更低的成本获得类似的结果。该库定义了一个帮助器来完成这项工作：

module.exports = function (fun, args, self) {
  return new Promise(function (resolve, reject) {
    args.push(function (err, data) {
      err && reject(err);
      resolve(data);
    })
    fun.apply(self, args);
  });
};

---

由于我处理的是 TypeScript 而不是 JavaScript，因此我更进一步并做了一些研究。这就是我最终选择 typed-promisify 的方式，代码现在看起来像这样：

patchUserMetadata = promisify(this.wrapped.patchUserMetadata);

linkUser = promisify(this.wrapped.linkUser);

整洁多了，嗯？

越来越近

我想知道这个promisify 函数究竟是如何工作的？我查看了源代码，发现了一个类似于js-promisify 的解决方案：

export function promisify<T>(f: (cb: (err: any, res: T) => void) => void, thisContext?: any): () => Promise<T>;
export function promisify<A, T>(f: (arg: A, cb: (err: any, res: T) => void) => void, thisContext?: any): (arg: A) => Promise<T>;
export function promisify<A, A2, T>(f: (arg: A, arg2: A2, cb: (err: any, res: T) => void) => void, thisContext?: any): (arg: A, arg2: A2) => Promise<T>;
// ...more overloads

export function promisify(f: any, thisContext?: any) {
  return function () {
    let args = Array.prototype.slice.call(arguments);
    return new Promise((resolve, reject) => {
      args.push((err: any, result: any) => err !== null ? reject(err) : resolve(result));
      f.apply(thisContext, args);
    });
  }
}

问题

如果您仔细查看promisify，您会发现这个解决方案并没有真正通用。意思是，如果我需要承诺一个具有 10 多个参数的函数，则不会有匹配的重载。实现仍然可以正常工作，但是在这种情况下类型信息会丢失。

TypeScript 中有没有一种方法可以推断出精确的函数类型（或签名，或参数的计数和类型），而无需预先定义所有那些讨厌的重载？

我正在寻找这样的东西[显然，伪代码]：

export function promisify<...[TArgs], T>(
  f: (...allArgsButLastTwo: [TArgs],
  cb: (err: any, res: T) => void) => void,
  thisContext?: any
): (...[TArgs]) => Promise<T>;

export function promisify(
  ...allArgsButLastTwo: any[],
  f: any,
  thisContext?: any
) {
  return function () {
    let args = Array.prototype.slice.call(arguments);
    return new Promise((resolve, reject) => {
      args.push((err: any, result: any) => err !== null ? reject(err) : resolve(result));
      f.apply(thisContext, args);
    });
  }
}

我有一种感觉，我正在寻找的东西是不可以实现的，这就是为什么长重载列表是作者不得不使用的最后手段/妥协解决方案。

Answer 1

从 2.5 版开始，在解决此问题之前，目前无法在 TypeScript 中执行此操作： https://github.com/Microsoft/TypeScript/issues/5453

它已经在roadmap 上一段时间了，在可变参数类型下。