Skip to content
TheChatArchiveThe Chat Archive
Grok 4.1 Fast· xaiHugging Face Frontier Reasoning Traces

Build an Angular application using NgRx for advanced state management and lazy loading.

  1. User

    Build an Angular application using NgRx for advanced state management and lazy loading.

  2. Assistant

    Building an Angular Application with NgRx for Advanced State Management and Lazy Loading

    This guide builds a Todo application demonstrating:

    • NgRx with Entity Adapter for efficient state management (CRUD operations, selectors).
    • Effects for side effects (loading/persisting todos to localStorage).
    • Lazy loading of the TodosModule.
    • Advanced patterns: OnPush change detection, trackBy, functional NgRx (createAction/createReducer), feature selectors.
    • Cross-module state access (Home shows total todos from lazy-loaded feature).

    1. Prerequisites

    • Node.js >= 18
    • Angular CLI >= 17 (npm i -g @angular/cli@latest)

    2. Create the Project

    ng new todo-ngrx-app --routing --style=scss --strict
    cd todo-ngrx-app
    

    3. Install Dependencies

    # NgRx packages
    ng add @ngrx/store@17
    ng add @ngrx/effects@17
    ng add @ngrx/router-store@17
    ng add @ngrx/store-devtools@17
    
    # UUID for todo IDs
    npm install uuid @types/uuid
    

    4. Generate Modules and Components

    # Lazy-loaded feature module with route
    ng generate module todos --route todos --module app.module.ts
    
    # Home component (eager-loaded)
    ng generate component home
    

    5. Create the Code Files

    Replace or create the following files. (The CLI commands above generate stubs; overwrite them.)

    src/app/models/todo.model.ts (New file)

    export interface Todo {
      id: string;
      label: string;
      completed: boolean;
    }
    

    src/app/todos/store/todo.actions.ts (New file)

    import { createAction, props } from '@ngrx/store';
    import { Todo } from '../../models/todo.model';
    
    export const loadTodos = createAction('[Todo] Load Todos');
    
    export const loadTodosSuccess = createAction(
      '[Todo] Load Todos Success',
      props<{ todos: Todo[] }>()
    );
    
    export const addTodo = createAction('[Todo] Add Todo', props<{ todo: Todo }>());
    
    export const toggleTodo = createAction('[Todo] Toggle Todo', props<{ id: string }>());
    
    export const deleteTodo = createAction('[Todo] Delete Todo', props<{ id: string }>());
    

    src/app/todos/store/todo.reducer.ts (New file)

    import { createReducer, on, createEntityAdapter } from '@ngrx/store';
    import { Todo } from '../../models/todo.model';
    import * as TodoActions from './todo.actions';
    
    export const todoAdapter = createEntityAdapter<Todo>();
    
    export interface State extends ReturnType<typeof todoAdapter.getInitialState> {}
    
    export const initialState = todoAdapter.getInitialState();
    
    export const todoReducer = createReducer(
      initialState,
      on(TodoActions.loadTodosSuccess, (state, { todos }) => todoAdapter.setAll(todos, state)),
      on(TodoActions.addTodo, (state, { todo }) => todoAdapter.addOne(todo, state)),
      on(TodoActions.toggleTodo, (state, { id }) => {
        const todo = state.entities[id];
        if (!todo) return state;
        return todoAdapter.updateOne(
          { id, changes: { completed: !todo.completed } },
          state
        );
      }),
      on(TodoActions.deleteTodo, (state, { id }) => todoAdapter.removeOne(id, state))
    );
    

    src/app/todos/store/todo.selectors.ts (New file)

    import { createFeatureSelector, createSelector } from '@ngrx/store';
    import { todoAdapter, State } from './todo.reducer';
    
    export const selectTodoState = createFeatureSelector<State>('todos');
    
    const adapterSelectors = todoAdapter.getSelectors(selectTodoState);
    
    export const selectAllTodos = adapterSelectors.selectAll;
    export const selectTodoTotal = adapterSelectors.selectTotal;
    export const selectTodoEntities = adapterSelectors.selectEntities;
    

    src/app/todos/store/todo.effects.ts (New file)

    import { Injectable } from '@angular/core';
    import { Actions, createEffect, ofType } from '@ngrx/effects';
    import { Store } from '@ngrx/store';
    import { map, tap, withLatestFrom } from 'rxjs/operators';
    import { AppState } from '../../app.state';
    import * as TodoActions from './todo.actions';
    import * as TodoSelectors from './todo.selectors';
    import { Todo } from '../../models/todo.model';
    
    @Injectable()
    export class TodoEffects {
      loadTodos$ = createEffect(() =>
        this.actions$.pipe(
          ofType(TodoActions.loadTodos),
          map(() => {
            const todosStr = localStorage.getItem('todos') || '[]';
            const todos: Todo[] = JSON.parse(todosStr);
            return TodoActions.loadTodosSuccess({ todos });
          })
        )
      );
    
      persistTodos$ = createEffect(
        () =>
          this.actions$.pipe(
            ofType(
              TodoActions.addTodo,
              TodoActions.toggleTodo,
              TodoActions.deleteTodo
            ),
            withLatestFrom(this.store.select(TodoSelectors.selectAllTodos)),
            tap(([, todos]) => {
              localStorage.setItem('todos', JSON.stringify(todos));
            })
          ),
        { dispatch: false }
      );
    
      constructor(private actions$: Actions, private store: Store<AppState>) {}
    }
    

    src/app/todos/todos.component.ts

    import { Component, OnInit, ChangeDetectionStrategy } from '@angular/core';
    import { Store } from '@ngrx/store';
    import { Observable } from 'rxjs';
    import { v4 as uuid } from 'uuid';
    import { AppState } from '../../app.state';
    import { Todo } from '../../models/todo.model';
    import * as TodoActions from '../store/todo.actions';
    import * as TodoSelectors from '../store/todo.selectors';
    
    @Component({
      selector: 'app-todos',
      template: `
        <h2>My Todos ({{ total$ | async }})</h2>
        <div class="input-group">
          <input
            #newTodoInput
            type="text"
            class="new-todo-input"
            placeholder="Enter new todo..."
            (keyup.enter)="addTodo(newTodoInput.value); newTodoInput.value = ''"
          />
          <button (click)="loadTodos()">Reload from Storage</button>
        </div>
        <ul class="todos-list">
          <li *ngFor="let todo of todos$ | async; trackBy: trackById">
            <input
              type="checkbox"
              [checked]="todo.completed"
              (change)="toggleTodo(todo.id)"
            />
            <span [class.completed]="todo.completed">{{ todo.label }}</span>
            <button (click)="deleteTodo(todo.id)">Delete</button>
          </li>
        </ul>
      `,
      styles: [
        `
          .completed {
            text-decoration: line-through;
            opacity: 0.6;
          }
          .input-group {
            margin-bottom: 1rem;
          }
          .new-todo-input {
            padding: 0.5rem;
            margin-right: 0.5rem;
            width: 300px;
          }
          .todos-list {
            list-style: none;
            padding: 0;
          }
          .todos-list li {
            display: flex;
            align-items: center;
            margin-bottom: 0.5rem;
          }
          .todos-list span {
            flex: 1;
            margin: 0 1rem;
          }
        `,
      ],
      changeDetection: ChangeDetectionStrategy.OnPush,
    })
    export class TodosComponent implements OnInit {
      todos$ = this.store.select(TodoSelectors.selectAllTodos);
      total$ = this.store.select(TodoSelectors.selectTodoTotal);
    
      constructor(private store: Store<AppState>) {}
    
      ngOnInit(): void {
        this.store.dispatch(TodoActions.loadTodos());
      }
    
      addTodo(label: string): void {
        if (label?.trim()) {
          this.store.dispatch(
            TodoActions.addTodo({ todo: { id: uuid(), label: label.trim(), completed: false } })
          );
        }
      }
    
      toggleTodo(id: string): void {
        this.store.dispatch(TodoActions.toggleTodo({ id }));
      }
    
      deleteTodo(id: string): void {
        this.store.dispatch(TodoActions.deleteTodo({ id }));
      }
    
      loadTodos(): void {
        this.store.dispatch(TodoActions.loadTodos());
      }
    
      trackById(_index: number, todo: Todo): string {
        return todo.id;
      }
    }
    

    src/app/todos/todos.module.ts (Update imports)

    import { NgModule } from '@angular/core';
    import { CommonModule } from '@angular/common';
    import { TodosRoutingModule } from './todos-routing.module';
    import { TodosComponent } from './todos.component';
    import { StoreModule } from '@ngrx/store';
    import { EffectsModule } from '@ngrx/effects';
    import { todoReducer } from './store/todo.reducer';
    import { TodoEffects } from './store/todo.effects';
    
    @NgModule({
      declarations: [TodosComponent],
      imports: [
        CommonModule,
        TodosRoutingModule,
        StoreModule.forFeature('todos', todoReducer),
        EffectsModule.forFeature([TodoEffects]),
      ],
    })
    export class TodosModule {}
    

    src/app/home/home.component.ts (Update to demo cross-module state)

    import { Component } from '@angular/core';
    import { Store } from '@ngrx/store';
    import { Observable } from 'rxjs';
    import { AppState } from '../app.state';
    import * as TodoSelectors from '../todos/store/todo.selectors';
    
    @Component({
      selector: 'app-home',
      template: `
        <h1>Welcome to NgRx Todo App!</h1>
        <p>Navigate to <a routerLink="/todos">Todos</a> to manage your list.</p>
        <p>Total Todos in State: <strong>{{ total$ | async }}</strong></p>
      `,
      styleUrls: ['./home.component.scss'],
    })
    export class HomeComponent {
      total$ = this.store.select(TodoSelectors.selectTodoTotal);
    
      constructor(private store: Store<AppState>) {}
    }
    

    src/app/app.state.ts (New file for typing)

    import * as fromTodo from './todos/store/todo.reducer';
    
    export interface AppState {
      todos: fromTodo.State;
    }
    

    src/app/app-routing.module.ts (Update routes)

    import { NgModule } from '@angular/core';
    import { RouterModule, Routes } from '@angular/router';
    import { HomeComponent } from './home/home.component';
    
    const routes: Routes = [
      { path: '', component: HomeComponent },
      {
        path: 'todos',
        loadChildren: () => import('./todos/todos.module').then((m) => m.TodosModule),
      },
      { path: '**', redirectTo: '' },
    ];
    
    @NgModule({
      imports: [RouterModule.forRoot(routes)],
      exports: [RouterModule],
    })
    export class AppRoutingModule {}
    

    src/app/app.component.html (Update for nav)

    <nav>
      <a routerLink="/">Home</a> |
      <a routerLink="/todos">Todos</a>
    </nav>
    <main>
      <router-outlet></router-outlet>
    </main>
    

    src/app/app.component.scss (Optional styles)

    nav {
      padding: 1rem;
      background: #f5f5f5;
      a {
        margin-right: 1rem;
        text-decoration: none;
        color: blue;
        &:hover {
          text-decoration: underline;
        }
      }
    }
    main {
      padding: 2rem;
    }
    

    6. Run the App

    ng serve
    
    • Open http://localhost:4200
    • Add/toggle/delete todos → Persisted to localStorage.
    • Refresh → Reloads from storage.
    • Home shows total count (cross-module).
    • Open DevTools → NgRx tab for state inspection.

    Key Advanced Features Demonstrated

    • Entity Adapter: Normalized state, efficient upserts/selectors.
    • Effects: Async side-effects (load/persist), non-dispatching.
    • Lazy Loading: Todos module loads on-demand.
    • Selectors: Feature-based, memoized (e.g., selectTotal).
    • Performance: OnPush + trackBy + pure pipes.
    • Persistence: localStorage via Effects.

    This is production-ready scaffolding. Extend with API (HttpClient in Effects), guards, resolvers, etc. Source: Official NgRx patterns.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.