Setup Project and Fastify Platform - NestJs with Passport #01
Tags: nestjs, tutorial, backend, fastify
Published: 2022-01-06 21:49:49

In this series of posts I will create an Authentication system with Passport using social auth and JWT. Let's use the combination of NestJs + Passport + Fastify to create a complete authentication system.

So in this first part, we start with a blank project and will use the Fastify Platform and understand how NestJs works.

## What is NestJs?

NestJs is a framework for building efficient and scalable Node.js server-side applications. It uses robust HTTP Server frameworks like Express or Fastify. NestJs provides a level of abstraction above the common Node.js frameworks and exposes their APIs to the developer. This gives a great amount of freedom to use third-party modules.

Used for writing scalable, testable, and loosely coupled applications. It supports databases like PostgreSQL, MongoDB, MySQL.

---

## Start Project

We will use the `@nestjs/cli` to create a starter project and clear the files when we don't use them in our project. If you want to see the details, check the official documentation.

First, we install `@nestjs/cli` globally in your computer and initialize a blank project. I recommend using yarn for installing packages, but you can choose a package manager your preference.

```cmd
yarn global add @nestjs/cli
nest new nest-auth
```

And you access the folder and run in VSCode (or in another editor if you prefer).

```cmd
cd nest-auth
code .
```

In the image below, you see the file structure, when we have an app module, controller, and service.

![Folder Structure for Nest-Auth](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c68uviuxhqgivxo6o1zk.png)

### Type of blocks in NestJs

**Modules:** used to organize the code and split features into logical reusable units. Grouped TypeScript files are decorated with “@Module” decorator which provides metadata that NestJs makes use of to organize the application structure.

**Providers:** also called services, which are designed to abstract any form of complexity and logic. Providers can be created and injected into controllers or other providers.

**Controllers:** responsible for handling incoming requests and returning appropriate responses to the client-side of the application (for example call to the API).


## Configure Fastify Platform

In this project, I choose to use Fastify because it has a much better performance and functionalities than Express.

> Fastify provides a good alternative framework for Nest because it solves design issues in a similar manner to Express. However, fastify is much faster than Express, achieving almost two times better benchmarks results. A fair question is why does Nest use Express as the default HTTP provider? The reason is that Express is widely-used, well-known, and has an enormous set of compatible middleware, which is available to Nest users out-of-the-box.

So let's configure that, in `main.ts` we configure the platform if we use Fastify.

First, we need to install the required package:

```
yarn add @nestjs/platform-fastify
```

And in `src/main.ts` you import `FastifyAdapter` and `NestFastifyApplication` for initialize that in `NestFactory.create`.

```ts
// src/main.ts

import { NestFactory } from '@nestjs/core';
import {
  FastifyAdapter,
  NestFastifyApplication,
} from '@nestjs/platform-fastify';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    new FastifyAdapter()
  );
  await app.listen(3000);
}
bootstrap();
```

We don't need any more settings, now Fastify is configured and ready to use :clap:

## Run First Route

When making a project using `@nestjs/cli` it creates an example route, so will use that route to test our configuration. In the next tutorials, I explain how routes work in NestJs. Now we want to know if Fastify is working.

Open `app.controller` file, our see a default route using GET method in `/` path when using the `http://localhost:3000/` the server run `getHello` function and return a response from `AppService`

```ts
// src/app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
```

The `AppService` has a method called `getHello` that returns a string `Hello World`

```ts
// src/app.service.ts

import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}
```

So let's send a request using Postman for this route and see what returns


![Postman Route Return](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/aif66l6oxo7u3xkgraoi.png)

Good news its working :clap:

### Logger

If you want to get a log always that you send one request you can set this option inside `Fastify Adapter`

```ts
// src/main.ts

async function bootstrap() {
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    new FastifyAdapter({ logger: true }),
  );

  await app.listen(3000);
}
bootstrap();
```

Here is an example if you use this option

![Terminal logger](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/av8msrre4a3b3ndv98s8.png)

---

## Until Next Time

That is all we are going to cover in this article, we understood about NestJs and made an initial setup for our project to grow. In the next piece in the series, we'll configure the Database using Prisma, Docker, and Postgresql.

Thank you for reading!

---

Follow repository to consulting code

{% github mnzsss/nest-auth-explained no-readme %}

---

## References

* [NestJs Documentation](https://docs.nestjs.com/)
* [Why Choose NestJS As Your Backend Framework?](https://selleo.com/blog/why-choose-nest-js-as-your-backend-framework)