How to convert a promise to rxjs since 7

[willin]

import { catchError, from } from 'rxjs';

const fn = () => Promise.reject('test');
from(fn()).pipe(
  catchError((err) => {
    console.log('errored');
    throw err;
  })
);

Errored with:

UnhandledPromiseRejection: This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "test".

source at:

https://github.com/willin/v0/blob/main/src/utils/helpers.ts#L11

works previously however now cant, and i have no idea why

[josepot]

Hi @willin

I just checked and the code that you shared works just fine. However, you probably wanted to do this instead:

import { catchError, defer } from 'rxjs';

const fn = () => Promise.reject('test');
defer(fn).pipe(
  catchError((err) => {
    console.log('errored');
    throw err;
  })
);

Because the code above delays the creation of the Promise rejection until there is a subscription on the created Observable.

Please notice that the code that you shared is equivalent to from(Promise.reject('test'))... which eagerly creates a Promise rejection which is not being handled, which in its turn causes the v8 (and possibly other js engines) to log an Uncaugh (in promise) of error in the console. However, if you did this:

const fn = () => Promise.reject('test');
from(fn()).pipe(
  catchError((err) => {
    console.log('errored');
    throw err;
  })
).subscribe({
  error(e) {
    console.log('handling the exception, all good!', e)
  }
})

Then you wouldn't get the Uncaught (in promise) of... error on the console, because the rejection would be synchronously handled.

[willin]

i tried your codes and works. thx.

however mine not working:

import { Observable, defer, from, catchError } from 'rxjs';

export async function toPromise<T>(fn: (...arg: any[]) => Observable<T> | Promise<T>, args: any[] = []): Promise<T> {
  defer(fn).pipe(
    catchError((err) => {
      throw err;
    })
  );
  // eslint-disable-next-line no-return-await
  return await new Promise((resolve, reject) => {
    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
    from(fn(...args) as any)
      .pipe(
        catchError((err) => {
          throw err;
        })
      )
      .subscribe({
        next: (val) => resolve(val as T),
        error: (error) => reject(error)
      });
  });
}

[josepot]

I really don't understand what you are trying to do here, but perhaps you are looking for the firstValueFrom creation operator?

[willin]

i want to write a toPromise function, which inputs maybe an Observable or a Promise.

[benlesh]

that would be:

function toPromise<T>(factory: () => PromiseLike<T> | Observable<T>): Promise<T> {
  const input = factory();
  return (typeof input.then === 'function') ? Promise.resolve(input) : firstValueFrom(input);
}