I've prepared a simple backend application in NestJS to organize our work in this module. Suppose you have never heard of NestJS, no worries. It's pretty simple, and it looks like Angular.

The most important thing to know about any backend when you're a front-end developer is what you can get from the endpoints. In NestJS, endpoint declaration is contained in controllers. Our backend has two of them.

import {Body, Controller, Get, Post} from '@nestjs/common';
import {map, Observable} from "rxjs";
import {RoomsDao} from "./db/rooms-dao";
import {RoomConverterService} from "./room-converter/room-converter.service";
import {RoomDtoConverterService} from "./room-dto-converter/room-dto-converter.service";
import {RoomDto} from "./dtos/roomDto";

@Controller('rooms')
export class RoomsController {

    constructor(
        private readonly dao: RoomsDao,
        private readonly roomConverter: RoomConverterService,
        private readonly roomDtoConverter: RoomDtoConverterService
    ) {
    }

    @Get()
    getRooms(): Observable<Array<RoomDto>> {
        return this.dao.getRooms()
            .pipe(
                map(rooms => this.roomDtoConverter.convertMany(rooms))
            );
    }

    @Post()
    addRoom(@Body() dto: RoomDto): Observable<void> {
        const room = this.roomConverter.convert(dto);
        return this.dao.addRoom(room)
    }

}

There are two endpoints, one to create a new room and the second to get all created rooms. So, for example, if you send a request 

, it should return you a list of rooms. Notice that both endpoints use 

 request body type. Later, this type is converted to something more suitable for the domain. Data Transfer Objects are used in my backend application only to transfer data, as always should be.

import {Body, Controller, Get, Post, Query} from '@nestjs/common';
import {MeetingsDao} from "./db/meetings-dao";
import {map, Observable} from "rxjs";
import {MeetingDto} from "./dtos/meetingDto"; // <- look how nice it looks like
import {MeetingDtoConverterService} from "./meeting-dto-converter/meeting-dto-converter.service";
import {MeetingConverterService} from "./meeting-converter/meeting-converter.service";

@Controller('meetings')
export class MeetingsController {

    constructor(private readonly meetingsDao: MeetingsDao,
                private readonly dtoConverter: MeetingDtoConverterService,
                private readonly meetingConverter: MeetingConverterService) {
    }

    @Get()
    getMeetings(@Query("roomId") roomId: string): Observable<Array<MeetingDto>> {
        console.log(roomId)
        return this.meetingsDao.getMeetings(roomId)
            .pipe(
                map(meetings => this.dtoConverter.convertMany(meetings))
            );
    }

    @Post()
    addMeeting(@Body() dto: MeetingDto): Observable<void> {
        const meeting = this.meetingConverter.convert(dto);
        return this.meetingsDao.addMeeting(meeting);
    }

}

---
title: Backend overview 
description: Presenting the current module's plan, highlighting crucial backend details for the frontend to illustrate the problem domain.
code: https://gitlab.com/fullstackio/books/newline-course-apps/building-angular-applications-with-nx-app/-/tree/main/manuscript/code/04.02-backend?ref_type=heads
privateVideoUrl: https://stream.mux.com/800wfd7sDkXXXN6KudYpSREwLM9hOuelXP5GVh1ebMYY.m3u8
---

I've prepared a simple backend application in NestJS to organize our work in this module. Suppose you have never heard of NestJS, no worries. It's pretty simple, and it looks like Angular.

The most important thing to know about any backend when you're a front-end developer is what you can get from the endpoints. In NestJS, endpoint declaration is contained in controllers. Our backend has two of them.

## Rooms

```typescript { actualFilename=../../../manuscript/code/04.02-backend/src/rooms/rooms.controller.ts endChar=971 endLine=33 startChar=0 startLine=1 statedFilename=src/rooms/rooms.controller.ts url=https&#x3A;//gitlab.com/fullstackio/books/building-angular-applications-with-nx/module_05/lesson_05.02/.../../manuscript/code/04.02-backend/src/rooms/rooms.controller.ts }
import {Body, Controller, Get, Post} from '@nestjs/common';
import {map, Observable} from "rxjs";
import {RoomsDao} from "./db/rooms-dao";
import {RoomConverterService} from "./room-converter/room-converter.service";
import {RoomDtoConverterService} from "./room-dto-converter/room-dto-converter.service";
import {RoomDto} from "./dtos/roomDto";

@Controller('rooms')
export class RoomsController {

    constructor(
        private readonly dao: RoomsDao,
        private readonly roomConverter: RoomConverterService,
        private readonly roomDtoConverter: RoomDtoConverterService
    ) {
    }

    @Get()
    getRooms(): Observable<Array<RoomDto>> {
        return this.dao.getRooms()
            .pipe(
                map(rooms => this.roomDtoConverter.convertMany(rooms))
            );
    }

    @Post()
    addRoom(@Body() dto: RoomDto): Observable<void> {
        const room = this.roomConverter.convert(dto);
        return this.dao.addRoom(room)
    }

}
```

There are two endpoints, one to create a new room and the second to get all created rooms. So, for example, if you send a request `GET http://localhost:3000/rooms`, it should return you a list of rooms. Notice that both endpoints use `RoomDto` as a type returned by the `GET` endpoint and `POST` request body type. Later, this type is converted to something more suitable for the domain. Data Transfer Objects are used in my backend application only to transfer data, as always should be.

galczo5

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

Backend overview

I have prepared for you a backend application that we will use to migrate it to

and then we will write two front-end applications that we will use that backend

In this lesson we will do a short overview what we have inside how to start

so on. The application is using an sjs as backend framework if you have never

no worries it's very similar to Angela so it will look familiar for you. Let's

SRC folder so let's open it and similar to Angela we have main.ts file so let's

As you can see we have putstrap function and similar to Angela we have app

what is inside app module. In the app module we have two imports, two rooms and

app controller and two providers, app service and fake database latency service

what is inside app controller first. Controls are very simple so first of all

hello here it means that the endpoint will be exposed as hello and then I have

get so I will have get hello endpoint that will return a simple string. Let's

module and let's check what is inside rooms and meetings modules. So let's

As you can see we have a new module that imports fake database module. It has

rooms controller and few providers. So let's start again with controllers.

It's a bit more complicated so we have endpoint called rooms. It has two

We've got you can get the list of all rooms. Room is described by room dto

check in a moment and the post one is used to create a new room. So let's check

room dto. So our room will have ID, name and image. Let's go back to app module

check what is inside meetings module. So let's check meetings controller and as

it's very simple we have two methods we have get and post again to get all the

so it's a query parameter room ID and post to create a new meeting and we have

here it contains ID room ID name of the room house date from and date to. Let's

meetings module and check what is inside providers. So we have two providers we

converter service and meeting converters service. So meeting dto converter

service that converts meeting to meeting dto and the second service does the

in reverse direction so we are mapping meeting dto to meeting starting the app

First of all we need to install all necessary dependencies so we are install

As you can see we have our endpoints exposed so we have our hello rooms that

meetings that contains get and post and basically that's it it's a very simple

in-memory database so nothing really complicated and I want to encourage you to

because if you like angular I bet you will like netjs.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Masterclasses

Tutorials

Fullstack React with TypeScript