Ndtyjky

I am struggling with using observables and pipes where I want to add one item from one observable to another observable containing a list of items of the same type.

I have type X. And of the type X I have an observable array:

readonly arrayOfx$: Observable<X>;

I also have an observable of only the the type X:

private readonly _x$: Observable<UpdateOfX>;



interface UpdateOfX {

    x: X,

    updateState: "Add" | "Modified" | "Removed"

}

All this code is in a Service Class where the service should only expose the array of X. The data in the array I want to show in my html with async piping and this part of the functionality works. The host and the client are connected with the signalR technique and onConnected, an array of items of type X is retrieved. But as the application runs, in the backend new items of type X can be created, existing items can be changed or can be removed and when this occures, only this item will be send via the signalR connection and the modification state.

In the front end, this item must be added to the already retrieved array of items of type X. In the service, the pipe technique is used and my question is, how do I add the single item I get in a later moment to the list of items I retrieved earlier?

constructor() {

    this.arrayOfx$ = this._someSignalRHelperService.retrieveMultipleItems$.pipe(

        tap((xArray: X) => console.log(xArray)), 

        //can I somehow get the a later created x from the server here...

    );



    this._x$ = this._someSignalRHelperService.retrieveOneItem$.pipe(

        tap((updateOfX: UpdateOfX) => console.log(updateOfX)),

        map((updateOfX: UpdateOfX) => {

            //process the updateState

            //... or must I do something here to get x into x?

        })

    );

}

Since SignalR is used, the backend is in control when the client receives a new item of type X when there is one created.

You can use combineLatest(), and do whatever manipulation you want as soon as your receive the two emissions:

constructor() {

    this.combinedOfX$ = combineLatest(

        this._someSignalRHelperService.retrieveMultipleItems$,

        this._someSignalRHelperService.retrieveOneItem$

    ).pipe(

        map(([singleOfX, multipleOfX]) => {

            // do your adding or mapping and whatever here.

        })

    )

}

Not sure if that is by design but the problem with having the frontend (client) to deal with the data is not so ideal. Your single source of truth is now based on your client, which different machines have different processing speed and may cause nuances and inconsistent displays. Also, the code will be messy in a sense that you will now need to check through the entire arrayOfX every time a singleOfX gets updated - you need to check if it exists in the current list, if yes, edit/delete; else, append to the list. What if the user refreshes his browser accidentally? You lost all of your processing.

Since you are already using SignalR, it would be more advisable that you let the server handle all the data, and let the server be single source of truth. Then you will just need to subscribe to one hub and listen to the changes of the arrayOfX; and pretty much don't care of the single updates.