How do I throw an error on a behaviour subject and continue the stream?

On one end, I have a stream which may occasionally throw an error:


Later on, however, I want to continue the stream:

on the other end, I have a subscriber subscribed to behaviorSubject.asObservable().

In the subscribtion, I’m handling the value and the error:

   ( value ) =>  {  /* ok */ },
   ( error ) =>  {  /* some error */ }

I want the effect to be the same as a simple onSuccess and onError callback, where onError is called every time an error occurs and doesn’t prevent future onSuccess calls from being made. How do I do this with RXJS?

I’ve looked into catch but it seems to just prevent error from being called on subscribers.


Short answer: It’s not possible.

How to work with this: The basic concept of RxJS is that any error or complete-call will basically “kill” a stream. This concept forces you not “just to throw around errors here and there as you please” but to handle errors and the flow of data within your application properly. A BehaviorSubject for example is typically meant to hold data, however it should not be used to also include the process of retrieving/creating that data and handle possible errors that might occur during the retrieval of the data.

So if you want to go by the book, you should split up your flow into two parts:

  1. Retrieval/creation of the data: A stream, that will run once then then completes and/or throws an error whenever one occurs. When the data is retrieved it will be sent to the store.
  2. The store (e.g. as in your case: a bunch of BehaviorSubjects): Only valid data arrives in the store, this means that no error-handling is done here and all parts relying on the store can trust in the store that it holds the correct data.

As an example your data flow could look as follows (as a rough sketch):


dataStore: BehaviorSubject<IData> = new BehaviorSubject<IData>();
errorMessage: BehaviorSubject<IErrorMsg> = new BehaviorSubject<IErrorMsg>();


fetchDataById(id: string) {
        .subscribe(handleData, handleError);

handleData(data: IData) {;;

handleError(error: Error) {;;

“But this looks like a lot of overhead…” – True, however it ensures a clean and easy-to-understand flow of data within your application, that is easy to test and maintain. Also there are ready-to-use store-concepts like ngrx or redux that could be used.