Angular 6 - Why use @ngrx/store rather than service injection

I think you should read those two posts about Ngrx store:

• Angular Service Layers: Redux, RxJs and Ngrx Store - When to Use a Store And Why?
• Ngrx Store - An Architecture Guide

If the first one explains the main issues solved by Ngrx Store, it also quote this statement from the React How-To "that seems to apply equally to original Flux, Redux, Ngrx Store or any store solution in general":

You’ll know when you need Flux. If you aren’t sure if you need it, you don’t need it.

To me Ngrx store solves multiple issues. For example when you have to deal with observables and when responsability for some observable data is shared between different components. In this case store actions and reducer ensure that data modifications will always be performed "the right way".

It also provides a reliable solution for http requests caching. You will be able to store the requests and their responses, so that you could verify that the request you're making has not a stored response yet.

The second post is about what made such solutions appear in the React world with Facebook's unread message counter issue.

Concerning your solution of storing non-obvervable data in services. It works fine when you're dealing with constant data. But when several components will have to update this data you will probably encounter change detection issues and improper update issues, that you could solve with:

• observer pattern with private Subject public Observable and next function
• Ngrx Store

I'm almost only reading about the benefits of Ngrx and other Redux like store libraries, while the (in my opinion) costly tradeoffs seem to be brushed off with far too much ease. This is often the only reason that I see given: "The only reason not to use Ngrx is if your app is small and simple". This (I would say) is simply incomplete reasoning and not good enough.

Here are my complaints about Ngrx:

• You have logic split out into several different files, which makes the code hard to read and understand. This goes against basic code cohesion and locality principles. Having to jump around to different places to read how an operation is performed is mentally taxing and can lead to cognitive overload and exhaustion.
• With Ngrx you have to write a lot more code, which increases the chances of bugs. More code -> more places for bugs to appear.
• An Ngrx store can become a dumping ground for all things, with no rhyme or reason. It can become a global hodge podge of stuff that no one can get a coherent overview of. It can grow and grow until no one understands it any more.
• I've seen a lot of unnecessary deep object cloning in Ngrx apps, which has caused real performance issues. A particular app I was assigned to work on was taking 40 ms to persist data in the store because of deep cloning of a huge store object. This is over two lost render frames if you are trying to hit a smooth 60 fps. Every interaction felt janky because of it.
• Most things that Ngrx does can be done much simpler using a basic service/facade pattern that expose observables from rxjs subjects.

Just put methods on services/facades that return observables - such a method replaces the reducer, store, and selector from Ngrx. And then put other methods on the service/facade to trigger data to be pushed on these observables - these methods replace your actions and effects from Ngrx. So instead of reducers+stores+selectors you have methods that return observables. Instead of actions+effects you have methods that produce data the the observables. Where the data comes from is up to you, you can fetch something or compute something, and then just call subject.next() with the data you want to push.

• The rxjs knowledge you need in order to use ngrx will already cause you to be competent in using bare rxjs yourself anyways.
• If you have several components that depend on some common data, then you still don't need ngrx, as the basic service/facade pattern explicitly handles this already.
• If several services depend on common data between them, then you just make a common service between these services. You still don't need ngrx. It's services all the way down, just like it is components all the way down.

For me Ngrx doesn't look so good on the bottom line.

It is essentially a bloated and over engineered Enterprise™ðŸ¢ðŸ‘¨‍💼🤮 grade Rxjs Subject, when you could have just used the good old and trusty Rxjs Subject. Listen to me kids, life is too short for unnecessary complexity. Stick to the bare necessities. The simple bare necessities. Forget about your worries and your strife.

I've been working with NgRx for over three years now. I used it on small projects, where it was handy but unnecessary and I used it in applications where it was perfect fit. And meanwhile I had a chance to work on the project which did not use it and I must say it would profit from it.

On the current project I was responsible for designing the architecture of new FE app. I was tasked to completely refactor the existing application which for the same requirements used non NgRx way and it was buggy, difficult to understand and maintain and there was no documentation. I decided to use NgRx there and I did it because of following reasons:

• The application has more than one actor over the data. Server uses the SSE to push state updates which are independent from user actions.
• At the application start we load most of available data which are then partially updated with SSE.
• Various UI elements are enabled/disabled depending on multiple conditions which come from BE and from user decisions.
• UI has multiple variations. Events from BE can change currently visible UI elements (texts in dialogs) and even user actions might change how UI looks and works (recurring dialog can be replaced by snack if user clicked some button).
• State of multiple UI elements must be preserved so when user leaves the page and goes back the same content (or updated via SSE) is visible.

As you can see the requirements does not meet the standard CRUD operations web page. Doing it the "Angular" way brought such complexity to the code that it became super hard to maintain and what's worst by the time I joined the team the last two original members were leaving without any documentation of that custom made, non NgRx solution.

Now after the year since refactoring the app to use NgRx I think I can sum up the pros and cons.

Pros:

• The app is more organized. State representation is easy to read, grouped by purpose or data origin and is simple to extend.
• We got rid of many factories, facades and abstract classes which lost their purpose. The code is lighter, and components are 'dumber', with less hidden tricks coming from somewhere else.
• Complicated state calculations are made simple using effects and selectors and most components can be now fully functional just by injecting the store and dispatching the actions or selecting the needed slice of the state while handling multiple actions at once.
• Because of updated app requirements we were forced to refactor the store already and it was mostly Ctrl + C, Ctrl + V and some renaming.
• Thanks to Redux Dev Tools it is easier to debug and optimize (yep really)
• This is most important - even thought our state itself is unique the store management we are using is not. It has support, it has documentation and it's not impossible to find solutions to some difficult problems on the internet.
• Small perk, NgRx is another technology you can put to your CV :)

Cons:

• My colleagues were new to the NgRx and it took some time for them to adapt and fully understand it.
• On some occasions we introduced the issue where some actions were dispatched multiple times and it was difficult to find the cause of it and fix it
• Our Effects are huge, that's true. They can get messy but that's what we have pull requests for. And if this code wasn't there it would still end up somewhere else :)
• Biggest issue? Actions are differentiated by their string type. Copy an action, forget to rename it and boom, something different is happening than you expect, and you have no clue why.

As a conclusion I would say that in our case the NgRx was a great choice. It is demanding at first but later everything feels natural and logical. Also, when you check the requirements, you'll notice that this is a special case. I understand the voices against NgRx and in some cases I would support them but not on this project. Could we have done it using 'Angular' way? Of course, it was done this way before, but it was a mess. It was still full of boiler plate code, things happening in different places without obvious reasons and more.

Anyone who would have the chance to compare those two versions would say the NgRx version is better.