Introduction to the Building Angular applications with NX

Speaker introduction and course overview

What is NX?

Difference between Repository and Monorepo

Repository vs Monorepo

Angular and NX - Why?

Advantages of NX

Disadvantages of NX

First module summary

Introduction

Second module introduction

Short lesson about NX installation methods

NX installation

A quick overview of the default suggested directory structure of NX repository.

NX repository folder layout

Second module summary

How to install NX

How to build a simple application and how to create libraries in NX

Third module introduction

Adding the first app

Adding the first library

Code session for the first application and library in NX.

Time tracker code

Third module summary

The first NX Angular application

What else you can keep in monorepo...? Multiple apps using multiple frameworks, built-in Storybook and Cypress configuration

Fourth module introduction

How can you add more apps to monorepo, which frameworks are available at the time, and advantages of keeping them together

Built-in app types in NX

What are buildable and publishable libraries

Built-in library types in NX

Storybook

End-to-end testing

Fourth module summary

More built-in NX features

This module will present a real-life example of an NX mono repository with multiple libraries and three applications.

Fifth module introduction

Presenting the current module's plan, highlighting crucial backend details for the frontend to illustrate the problem domain.

Backend overview

How to migrate simple existing applications to NX

Migrating backend app to NX

How to extract library with DTOs classes from backend app and prepare it to be shared with frontend application

Extracting shared DTO library

Let's look at how our final application should look like

Design overview

Add new Angular apps to the existing NX repository

Adding new Angular apps to existing monorepo

Adding Storybook to monorepo - different approach

Using previously configured Storybook in this lesson we will create and prepare a few common components that later we’ll use in apps.

Adding common components. Card, Button, Input, List, ListItem

Adding a domain library for RoomList, RoomBackground and RoomTimelineList that I missed in previous lessons

Constructing the services of the application

Constructing the application - Services

Constructing the Admin application

Constructing the Room application

How to prepare the application to work offline

Preparing the Room applications to work offline

Summary of building a real-life application with NX

Lessons learned and homework

Building a real life application with NX

Sixth module introduction

What is the dependency graph in NX, and how does it help you with developer experience

Dependency graph - what is it?

Why it’s important to keep the dependencies organized

Importance of keeping dependencies in order

How to run unit tests and lint only on the affected parts of the dependency graph

Affected

How to deal with the most common examples of circular dependencies

Dealing with circular dependencies

Sixth module summary

Dependency graph

Seventh module introduction

How to automatically migrate simple applications to the NX mono repository

Automatic migration of existing applications

How to manually migrate complex applications to the NX mono repository

Manual migration of existing applications

What may be the problem during migration of big, stale existing codebases

Analysis of potential problems in migration of big existing codebases

Tips. The migration plan

Why defining a target architecture may be an important step of the migration process

Tips. Target architecture

Seventh module summary

Migrating existing applications to NX

What you have learned from this course

Contact info and final words from the author

Final words

Summary

### Challenges and solutions in building large Angular apps

In large Angular applications, developers face several significant challenges. One major issue is managing complexity. These apps have lots of components, services, and modules that all need to work together smoothly. Keeping everything organized and easy to understand can be tough, especially with a big team.

Another problem is build times. As the app grows, it can take longer and longer for changes to show up during development. This can slow down the development process and make it harder to stay productive.

Dependency management is another headache. This involves making sure all the different parts of the app work well together and play nicely with outside libraries. 

### Tool limitations

Even experienced teams can struggle with managing large Angular applications without using the right tools. Organizing numerous components, services, and modules becomes challenging without tools that aid in clarity and team collaboration. Utilizing appropriate tools is key for experienced teams to successfully navigate the complexities of large Angular projects.

### Fixing problems with NX

NX offers several benefits for managing large Angular applications. It helps reduce the time it takes to build projects and keeps code well-organized by managing dependencies and structuring code into reusable parts. This makes it easier to maintain and expand applications over time.

One of NX's strengths is its ability to speed up builds. It does this by remembering previous build results and doing multiple tasks at the same time. This saves developers time and lets them make changes quickly.

NX also comes with tools for testing and checking code quality. It works well with common testing tools and helps keep code clean and consistent. This catches mistakes early and ensures code stays high-quality.

Furthermore, NX makes it easy to work together on projects. It keeps all code and shared parts in one place, making it simpler to share code between different projects or teams. This improves teamwork, reduces problems with combining code, and makes development smoother overall.

Manage Large Angular Apps and Supercharge Development Workflows

Learn how to create and maintain Angular applications using NX. 
Designed for Angular developers, this course covers best practices, improving workflow, and migrating existing applications to NX. 
Discover how to configure tools like Cypress for end-to-end testing and Storybook for UI component development. 
By the end of this course, you will have the knowledge and experience to work comfortably with NX on a daily basis.

Next-Level Angular Apps with NX

Build a simple time tracker application using NX monorepo.

Create a real-life NX monorepo with three applications. The main goal of these applications is to display the schedule for conference rooms on screens mounted to the doors of the respective rooms.

Build an admin panel as one of the applications to manage the schedule data for the conference rooms.

Use NX graph feature to visualize application architecture.

What is a monorepo approach and how it might help you

Differences between Angular CLI projects and NX projects

How to create Angular applications using NX

How to add Cypress and Storybook to your NX monorepo

How to migrate existing Angular applications to NX monorepo

What is a dependency graph and how to use it to save your time

How to prepare migration even for big and complicated projects

It wouldn't be nice to extract DTO classes from the backend to a separate library and then use it in the frontend...?

That's what we're going to do in this lesson. The main reason and advantage of this action is to have the
strict "contract" used in communication between the backend and frontend. In this case, if someone decides to change the class
because it's necessary for the backend, you'll instantly make the exact change in the front end. If the change is breaking, the CI or
build command will notify you where it's breaking. Of course, it's possible when you're using Typescript.

Extracting a new library, in this case, is fairly simple. The first thing we need to do is to create a new Typescript
library. We covered this in previous lessons, so follow the commands below.

yarn nx g @nx/js:lib libs/shared/dtos --buildable --publishable --importPath "shared/dtos"

As a result, you should find a new library inside of the 

 file, so I'm
removing it, and it's imported in 

---
title: Extracting shared DTO library
description: How to extract library with DTOs classes from backend app and prepare it to be shared with frontend application
code: https://gitlab.com/fullstackio/books/newline-course-apps/building-angular-applications-with-nx-app/-/tree/main/manuscript/code/04.04-dto-library?ref_type=heads
privateVideoUrl: https://stream.mux.com/2Z2WaaNi9TAe2dBfSPOX8ZdJW2YyEdIJ1MD9G1EyaD00.m3u8
---

It wouldn't be nice to extract DTO classes from the backend to a separate library and then use it in the frontend...?

That's what we're going to do in this lesson. The main reason and advantage of this action is to have the
strict "contract" used in communication between the backend and frontend. In this case, if someone decides to change the class
because it's necessary for the backend, you'll instantly make the exact change in the front end. If the change is breaking, the CI or
build command will notify you where it's breaking. Of course, it's possible when you're using Typescript.

Extracting a new library, in this case, is fairly simple. The first thing we need to do is to create a new Typescript
library. We covered this in previous lessons, so follow the commands below.

```bash
yarn nx g @nx/js:lib libs/shared/dtos --buildable --publishable --importPath "shared/dtos"
```

As a result, you should find a new library inside of the `libs/` directory. We don't need the `src/lib/dtos.ts` file, so I'm
removing it, and it's imported in `src/index.ts`.

![Folder structure after running nx generate command](https://d2uusema5elisf.cloudfront.net/courses/next-level-angular-apps-with-nx/module_05/lesson_05.04/public/images/04-04-01.png)

Because we have two kinds of DTOs, inside of the `src/lib/` of my library, I'm creating two directories, `rooms` and `meetings`. This is a small library, and this step may be pointless, but I believe that even in small apps, you should keep everything organized. Not because it's useful but because you train your skills as a programmer.

galczo5

Once we migrated our backend application to Monorepo, we have all the files in

directory in apps here. I thought that it would be nice to extract dto files to

so we can use it in backend and frontend application. So even if we introduce

dto's backend or frontend, the second app will notify us that something is

change the second application. In this lesson we are going to do extraction of

javascript library. So we need to create a new javascript library and I'm using

nx generate nx/js library that path to our library so libs/shirt/dtos and then

to flags buildable and publishable and of course obligatory import path. So I'm

path shirt/dtos. So let's execute the command. We need to answer few questions.

unit test runner we are going to use? Because I'm going to put only dtos there

test some I'm going to choose none. The next question is about bundle we are

I will use tsc. And the last question is about name we provide. So we can use

dtos with files root under libs/shirt/dtos or we can use derived with name

same route for our files. I will use as provided. As always installing staff

after a few seconds we have everything installed and we can continue. So as you

directory called libs and inside we have shirt/dtos, as our c and lib. So I'm

the files inside of lib. In the next step I'm going to go to my backend

and rooms. I'm going to open dtos. I'm going to select these two files and copy

directory in shirt/dtos. The last part in library what we need to do we need to

here and we need to export these two dtos. So let's export everything from libs

and of course from the room dtos. Now we can go to the backend application and

directories. And of course after that change we have to fix imports in files

dtos. So for example we have meeting converter service.ts and as you can see we

that is red so something is wrong. All we need to do is import it from shirt/dt

this in all files that require that change for meeting dtos and room dtos. So I

everything and see you in a few seconds. So all files are fixed at the moment.

dtos is imported from shirt/dtos. So this is our import path that we set

And import path can be anything you want, anything that is meaningful for you.

app works after the change. I'm going to go to my console view and I'm going to

comment that we used previously in previous lessons to start backend. So yarn

backend. And here as you can see a little bit app, annex built for us one

the backend. So it had to build the library that contains dtos before building

You don't need to do anything for it. It does it automatically. So annex is

and is able to build dependency tree to build packages in correct order. So as

everything is started. We have our routes. We have our hello. We have our rooms

and points. So the dtos extraction has ended successfully. And we have a new

can use in both backend and front-end application. So if you introduce a

code to dtos to backend application or front-end application, the second

know during the build step that something is wrong and you have to fix it. So

care about contract between front-end and backend. It works automatically