Armen VardanyanOriginal cover photo by Hansjörg Keller on Unsplash.
In my previous articles, we covered access restriction and handling lists with NgRx. Today, we are going to address a more general problem of decision-making across an Angular app that utilizes mainly NgRx Effects (but also a bit of reducers and selectors). In this Article, we will cover the following topics:
- Error handling with NgRx
- Handling redirections
- Handling loading data
- User interactions
Let's get started!
Error handling with NgRx
Error handling is something everyone hates (and often just forgets about), but also something everyone really, really needs. With NgRx apps, the complexity of error handling actually increases if we do not address this with proper care. Usually, errors in NgRx arise from effects, which, in most scenarios, are caused by HTTP requests.
There are usually two approaches to handling error in general: handling locally or globally. Handling locally means that we actually address the very specific error that occurred in some specific part of the app. For instance, if the user failed to log in, we might want to show a very specific error message like "Invalid username or password", instead of some generic error message like "Something went wrong".
Handling globally, on the other hand, means that we, in a way, lump all errors into one "pipeline" and use the very generic error messages we mentioned before. We could, of course, start a discussion about which idea is more suitable for what scenarios, but the harsh reality is that almost every app will need a bit of both worlds. We want to show error messages if any errors happen ("Something went wrong" is still better than a silent failure), but we also want to perform some specific actions in case of some errors. Let's address both scenarios.
Generic error handling with NgRx
In NgRx, everything that happens is triggered by an action. For activities that might involve gerring an error (HTTP calls, WebSockets, etc), we usually create several actions for a single activity:
export const DataActions = createActionGroup({
source: 'Data',
events: {
'Load Data': emptyProps(),
'Load Data Success': props<{ data: Data }>(),
'Load Data Error': props<{ error: string }>(),
},
});
As we can see, only to load a piece of data from an API, we need three actions. We might have dozens, if not hundreds, such "error" and "success" actions in a given application, so we might want to show a generic error message in case any of them is dispatched. We can do this by standardizing the error action's payload. For instance, we might want to add some very specific property to all actions that represent errors. In our case, the presence of the error property in the action payload can be enough to know that the action represents an error.
We can, then, subscribe to all actions that represent errors and show a generic error message. This is a very common pattern in NgRx apps, and is usually what is understood as "global error handling". In our case, we can do this by subscribing to all actions and filtering out the ones that have an error property in their payload:
export const handleErrors$ = createEffect(() => {
const actions$ = inject(Actions);
const notificationsService = inject(NotificationsService);
return actions$.pipe(
filter((action) => !!action.payload.error),
tap((action) => {
notificationsService.add({
severity: 'error',
summary: 'Error',
detail,
});
}),
}, { functional: true, dispatch: false });
In this case, any "error" action we ever dispatch will result in the same notification being shown, but also with a custom message. We can go a bit further by standardizing the approach the action props are created for an error. Here is a small helper function that can be handy:
export function errorProps(error: string) {
return function() {
return({error});
};
}
Now, we can use this function to create the error props for our actions:
export const DataActions = createActionGroup({
source: 'Data',
events: {
'Load Data': emptyProps(),
'Load Data Success': props<{ data: Data }>(),
'Load Data Error': errorProps('Failed to load data'),
},
});
This will make all the errors look the same way to avoid typos or confusion. Next, let's improve this to also be able to handle very specific errors.
Handling specific errors
In our case, we might want to be able to customize the way a generic error handler works for some specific cases. We want to be able
- to tell the effect whether to show a generic error message or not
- redirect to error pages with some predefined data
- display error notification inside a page
Let's start with the first one. We can do this by adding a new property to the error action payload:
export function errorProps(error: string, showNotififcation = true) {
return function() {
return({error, showNotification});
};
}
Now we can create an action that will later tell the effect to skip the generic notification message:
export const DataActions = createActionGroup({
source: 'Data',
events: {
'Load Data': emptyProps(),
'Load Data Success': props<{ data: Data }>(),
'Load Data Error': errorProps('Failed to load data', false),
},
});
Next, we should update the effect to reflect this:
export const handleErrors$ = createEffect(() => {
const actions$ = inject(Actions);
const notificationsService = inject(NotificationsService);
return actions$.pipe(
filter((action) => !!action.payload.error),
tap((action) => {
if (action.payload.showNotification) {
notificationsService.add({
severity: 'error',
summary: 'Error',
detail,
});
}
}),
);
}, { functional: true, dispatch: false });
Notice we did not add the checking of the showNotification property to the filter operator. This is because we will have scenarios where a notification should not be shown, but another action still has to be performed (like redirecting to an error page). Let's do precisely this by adding a new parameter to our error action:
export function errorProps(error: string, showNotification = true, redirectTo?: string) {
return function() {
return({error, showNotification, redirectTo});
};
}
Now, we can create an action that will later tell the effect to redirect to an error page:
export const DataActions = createActionGroup({
source: 'Data',
events: {
'Load Data': emptyProps(),
'Load Data Success': props<{ data: Data }>(),
'Load Data Error': errorProps('Failed to load data', false, '/error'),
},
});
Next, let's finalize our effect by adding a redirection to the error page if the redirectTo property is present in the action payload:
export const handleErrors$ = createEffect(() => {
const actions$ = inject(Actions);
const notificationsService = inject(NotificationsService);
const router = inject(Router);
return actions$.pipe(
filter((action) => !!action.payload.error),
tap((action) => {
if (action.payload.showNotification) {
notificationsService.add({
severity: 'error',
summary: 'Error',
detail,
});
}
if (action.payload.redirectTo) {
router.navigateByUrl(action.payload.redirectTo);
}
}),
);
}, { functional: true, dispatch: false });
And that is it to this. Of course, if we need something really custom for a particular error action, we can just write a completely separate effect to handle that. Sometimes, if we want to also do something in the UI in relation to an error, we can also add the error message (and any other data) to the store and use them via a selector anywhere.
Next, let us discuss loading data into our component, and several approaches to it.
Handling loading data
Before we proceed, we should first understand that the approaches listed in this section are not better or worse than one another. Instead, they are approaches for different situations, depending on what we want for our UX. Let's examine them step by step.
Selecting data in the component to use
The most straightforward way we can get some data (presumably from an API) is by just selecting it in the component. With the latest APIs, we can select a signal of our data and use it directly in the template. Here is a very simple example:
@Component({
selector: 'app-my',
template: `
<div>
<h1>Data</h1>
<p>{{ data() }}</p>
</div>
`,
})
export class MyComponent {
data = this.store.selectSignal(dataFeature.selectData);
}
Of course, in real life, we often need to deal with scenarios like loading, errors, and so on. In this case, our state might look like this:
export interface State {
data: Data | null;
loading: boolean;
error: string | null;
}
If we are using the createFeature function to register our state, we can make use of the selectDataState function that the feature automatically creates for us. This will return the entire state with loading, error, and data properties. We can then use this in our component:
@Component({
selector: 'app-my',
template: `
<div>
@if (vm().loading) {
<p>Loading...</p>
}
@if (vm().error) {
<p>Error: {{ vm().error }}</p>
} @else {
<h1>Data</h1>
<p>{{ vm().data }}</p>
}
</div>
`,
})
export class MyComponent {
vm = this.store.selectSignal(dataFeature.selectDataState);
}
This is very useful in most scenarios. However, sometimes we might not want to display the entire page if this important piece of data is not loaded. In Angular, this is commonly achieved with the use of routing resolvers, functions that return some Observables that routing waits for to emit before displaying a particular page. This is easy with the use of the HttpClient service, however, this becomes a bit complicated with NgRx (because we only make HTTP calls inside effects), resulting in lots of developers skipping resolvers entirely. However, there is an easy way to achieve this functionality. Let's build a simple resolver that utiliuzes the Store and the Actions Observable to know when the data is actually loaded:
export const dataResolver: ResolveFn<Data[]> = () => {
const store = inject(Store);
const actions$ = inject(Actions);
store.dispatch(DataActions.loadData());
return store.select(dataFeature.selectData).pipe(
skipUntil(actions.pipe(ofType(DataActions.loadDataSuccess))),
);
}
Here, we first dispatch the action that actually initiates the HTTP call, then we just return the selected data from the store as an Observable, but with a catch - we tell it to wait until the action signaling that the data has been loaded is dispatched. Given that effects are guaranteed to run after reducers, this will ensure that the data is actually put into the store before the resolver returns it. We can then just pick this data up in our component:
@Component({
selector: 'app-my',
template: `
<div>
<h1>Data</h1>
<p>{{ vm.data() }}</p>
</div>
`,
})
export class MyComponent {
private readonly route = inject(ActivatedRoute);
readonly vm = toSignal(this.route.data, {
initialValue: null,
}) as Signal<{data: Data}>;
}
We used ActivatedRoute instead of the Store because we already returned this data in the resolver. This makes our components even leaner - we don't even have to inject the Store and in unit testing, it can be often easier to mock the ActivatedRoute than the Store.
Finally, let's take a look at advanced decision-making with NgRx actions and effects, and see how this can help work with complex cases in large applications.
User interactions
NgRx is very useful when writing declarative code, as it allows us to just select the relevant state, and use it in our templates. However, sometimes, especially when dealing with third-party libraries, we need to perform some "imperative actions" which is tangentially related to our store. Consider this code which uses the Angular Material MatDialog service to open a confirmation dialog:
export class MyComponent {
private readonly dialog = inject(MatDialog);
private readonly store = inject(Store);
openConfirmationDialog() {
const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
data: {
title: 'Confirmation',
message: 'Are you sure you want to do this?',
},
});
dialogRef.componentInstance.confirm.subscribe(() => {
this.store.dispatch(DataActions.deleteData());
});
dialogRef.componentInstance.cancel.subscribe(() => {
dialogRef.close();
});
}
}
As we can see, there is a lot of imperative code in just this one method, there are two subscriptions, and they aren't even particularly simple (we just omitted unsubscription logic). Also, we must consider that in a normal application, we might have a dozen different places where the same confirmation dialog is used, with the only difference being the action that is performed when the user confirms/rejects.
Let's now approach this with an NgRx mindset, and try to create an action that can handle such a scenario, with callbacks as payloads.
export function confirmAction(callbacks: {confirm: () => void, reject: () => void}) {
return function() {
return({type: 'Open Confirmation Dialog', callbacks});
};
}
Now, we can create an action that will later tell the effect to redirect to an error page:
export const DataActions = createActionGroup({
source: 'Data',
events: {
'Delete Data': confirmAction({
confirm: () => {
return({action: 'Delete Data Confirmed'});
},
reject: () => {
return({action: 'Delete Data Rejected'});
},
}),
},
});
Now, we can create an effect that will handle all such actions:
export const handleConfirmationDialog$ = createEffect(() => {
const actions$ = inject(Actions);
const dialog = inject(MatDialog);
return actions$.pipe(
ofType(DataActions.openConfirmationDialog),
tap((action) => {
const dialogRef = dialog.open(ConfirmationDialogComponent, {
data: {
title: 'Confirmation',
message: 'Are you sure you want to do this?',
},
});
dialogRef.componentInstance.confirm.subscribe(() => {
action.payload.callbacks.confirm();
});
dialogRef.componentInstance.cancel.subscribe(() => {
action.payload.callbacks.reject();
});
}),
);
}, { functional: true, dispatch: false });
Finally, we can really simplify our component:
export class MyComponent {
private readonly store = inject(Store);
openConfirmationDialog() {
this.store.dispatch(DataActions.openConfirmationDialog({
confirm: () => {
this.store.dispatch(DataActions.deleteData());
},
reject: () => {
// Do nothing
},
}));
}
}
And that is it. However... we might face a problem if we try to make our application as fine as possible. In NgRx, it is a good practice to keep everything serializable, which is a fancy way of saying "easily convertible to JSON". In the app configuration, it is possible to set specific options to help safeguard us from, for example, putting functions in the store. This is done with two options, strictStoreSerializability and strictActionSerializability.
export const config: ApplicationConfig = {
providers: [
provideStore({}, {
runtimeChecks: {
strictActionSerializability: true,
strictStoreSerializability: true,
},
}),
};
This goes a long mile to help keep our applications maintainable and prevent hard-to-debug issues.
[!NOTE] You can read more about runtime checks in the NgRx docs.
However, if we make actions strictly serializable, our confirmAction action will not work with the callbacks we passed! So, what can we do about it? Well, the easiest way is to give it other actions for confirm/reject options to handle by the effect. Because the nested actions will also be required to be serializable, this will help us bring everything back to a workable state, an approach that I personally call "higher-order actions".
export function confirmAction(confirmAction: string, rejectAction: string, callbackActions: {
confirm: ActionCreator<any, any>,
reject: ActionCreator<any, any>
}) {
return function() {
return({type: 'Open Confirmation Dialog', callbackActions});
};
}
Next, we need to do a major update to our effect:
export const handleConfirmationDialog$ = createEffect(() => {
const actions$ = inject(Actions);
const dialog = inject(MatDialog);
return actions$.pipe(
ofType(DataActions.openConfirmationDialog),
map(({callbackActions}) => {
const dialogRef = dialog.open(ConfirmationDialogComponent, {
data: {
title: 'Confirmation',
message: 'Are you sure you want to do this?',
},
});
return merge([
dialogRef.componentInstance.confirm.pipe(
map(() => callbackActions.confirm()),
),
dialogRef.componentInstance.cancel.pipe(
tap(() => dialogRef.close()),
map(() => callbackActions.reject()),
),
])
}),
);
}, { functional: true, dispatch: false });
Let's deconstruct what goes on here.
- The
ConfirmationDialogComponentexposes theconfirmandcancelobservables. - We open a
MatDialogwith theConfirmationDialogComponentand every time an action created by theconfirmActionis dispatched, we subscribe to theconfirmobservable and dispatch the action that was passed to theconfirmActionfunction. - We also subscribe to the
cancelobservable and dispatch the action that was passed to theconfirmActionfunction. - We return a
mergeof the two observables so that when either of them emits, the whole effect will emit.
With this implementation, it is easy to perform complex decision-making just using several actions in a component:
export class MyComponent {
private readonly store = inject(Store);
openConfirmationDialog() {
this.store.dispatch(DataActions.openConfirmationDialog({
confirm: DataActions.deleteData,
reject: DataActions.cancelDeleteData,
}));
}
}
And that is it. With higher-order actions, we can easily delegate decision-making further to other effects and reducers as necessary, making the component code as declarative as possible.
Conclusion
In this article, we covered a few approaches to complex logic in Angular applications utilizing NgRx. NgRx is a huge tapestry of opportunities, and often we can easily transform ugly code into something understandable and maintainable. Such approaches are underappreciated, and with this piece, I try to bring them forth to help developers improve their state management solutions.
