Generas múltiples solicitudes asíncronas pero solo puedes detectar errores desde la primera:

1. Creas una promesa con async function test() .

2. Luego, crea una llamada sincrónica dentro de él, con new Test() , cada error lanzado sincrónicamente desde dentro será capturado por catch .

3. Luego genera otra llamada de promesa desde dentro del constructor síncrono, este error no puede ser detectado por el bloque try/catch o .catch en o por encima de la async function test() .

   Es similar a esto:

    constructor() { new Promise(() => throw new Error('')) }

Así que tienes 3 formas posibles de resolverlo:

1. Captas el error dentro de la async t() {} .
2. Lo atrapa dentro del constructor con this.t().catch(console.error) (que no se puede reenviar al bloque try/catch) ya que se reenvía al bloque catch de la Promesa detrás de la llamada asíncrona. Y si no hay .catch en la llamada asíncrona, obtiene el error "Rechazo de promesa no controlada".
3. No llames a la función asíncrona desde dentro del constructor, úsala así:

    class Test { async t() { throw new Error("From class"); } } async function test(){ await (new Test()).t(); } try { test().catch(e => { console.log("From async catch"); }); } catch (e) { console.log("From try catch"); }

No hagas métodos asíncronos)))

Su solución se parece un poco a esto.

 class Test { constructor() { this.t(); } t() { (async () => { try { throw new Error("From class"); } catch (e) { console.log(e); } })(); } }

Que tengas un buen resto de tu día.

no funciona si se lanza una excepción desde la clase.

En particular, cuando ocurre un evento de error asíncrono en el constructor , sí. Como dice el título de su pregunta, no puede manejar errores fuera de un contexto async , y un constructor no es eso.

Su implementación actual tiene muchos problemas, desde que client no está undefined hasta que se inicializa hasta no poder notificar a la persona que llama sobre los errores.

Todo esto se puede solucionar no poniendo código de inicialización asincrónica dentro de un constructor . Cree la instancia solo una vez que tenga todas las partes, use una función de fábrica auxiliar async para obtener (y esperar) las partes.

 export class RedisService { client: RedisClient; expirationTime: number | null; constructor(client: RedisClient, expirationTime: number | null) { this.client = client; this.expirationTime = expirationTime; } static create(args: RedisServiceOptions) { const addresses = await dns.promises.resolveSrv(args.host); log.info("Using Redis cluster mode"); const redisData = { defaults: args.password ? { password: args.password } : undefined, rootNodes: addresses.map(address => { log.info(`Adding Redis cluster node: ${address.name}:${address.port}`); return { url: `redis://${address.name}:${address.port}` }; }), }; const client = createCluster(redisData); client.on('error', (err: Error) => log.error(`Redis error: ${err.message}`)); await this.client.connect(); log.info("Connected to Redis"); return new RedisService(client, args.expirationTime); } … // instance methods }

Ahora, en su función principal, puede llamar a create , usar await y manejar los errores:

 async function main(){ try { const service = await RedisService.create(…); } catch(e) { console.log("From async catch", e); } }