Hur man omdefinierar returtyper för metoder med Proxy i Typescript

Jag försöker att promisifiera alla metoder i en klass med Proxy på detta sätt:

class Person {
  id = 1
  getName(): string {
    return "name"
  }

  getAge(): number {
    return 1
  }
}

const person = new Person();

const asyncPerson = new Proxy(person, {
  get(target, prop, receiver) {
    let fn = Reflect.get(target, prop, receiver)
    if (typeof fn !== 'function') {
      return fn
    }
    return (...args: any[]) => {
      return new Promise((res, rej) => {
        try {
          res(fn.apply(receiver, args))
        } catch (err) {
          rej(err)
        }
      }) 
    }
    
  }
})

console.log(asyncPerson.id)
console.log(asyncPerson.getName())

Problemet är att TypeScript tror att asyncPerson är av typen Person. Finns det något sätt att definiera en ny typ som korrekt återspeglar typen av asyncPerson utan att behöva skriva ut alla Person's metoder manuellt?

Å andra sidan, finns det ett sätt att automatiskt definiera en "promisifierad" klass?

Svar #1

Du kan använda villkorliga typer för att skapa en "promisifierad" version av en typ:

type Promisified<T> = { 
    [K in keyof T]: T[K] extends (...args: infer A) => infer R
        ? (...args: A) => Promise<R>
        : T[K] 
};

Ovanstående verktyg kommer att omsluta returtypen av metoder med ett löfte.

En annan varning är att Proxy-konstruktorns definition alltid returnerar samma typ som indata. För att övervinna detta kan new Proxy<any> användas eller dubbel typkonvertering.

Lekplats