广义 "promisify" 函数中的 Typescript 类型推断

Question

上下文

最近在做第三方库的"promisification"。基本上，这个库充满了 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，您会发现此解决方案并未真正推广。意思是，如果我需要 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);
    });
  }
}

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

Answer 1

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

它在 roadmap 上已经有一段时间了，在 Variadic Types 下。

广义 "promisify" 函数中的 Typescript 类型推断

Typescript type inference in a generalized "promisify" function

type-inference

typescript

typescript-typings

上下文

越来越近

问题