DEV Community: depak379mandal

Auth Service with JWT token and mail module, Part 2

depak379mandal — Wed, 29 May 2024 13:26:50 +0000

Love to work with you, You can hire me on Upwork.

We have looked into email and auth service now is the time to dive into mail and user module. Let me give you what is structure of mail module we have

src/modules/mail
├── mail.interface.ts
├── mailerConfig.service.ts
└── templates
    └── auth
        └── registration.hbs

mail.interface.ts is a simple file that does include required interface for mail in system. Mail module does contain our email templates in templates folder, and we got mailerConfig.service.ts for mail module to be used as config factory. Let me just paste them one by one.

// src/modules/mail/mail.interface.ts

export interface MailData<T = never> {
  to: string;
  data: T;
}

// src/modules/mail/templates/auth/registration.hbs

<html lang='en'>
  <head>
    <meta charset='UTF-8' />
    <meta name='viewport' content='width=device-width, initial-scale=' />
    <title>{{title}}</title>
  </head>

  <body style='margin:0;font-family:arial'>
    <table style='border:0;width:100%'>
      <tr style='background:#eeeeee'>
        <td
          style='padding:20px;color:#808080;text-align:center;font-size:40px;font-weight:600'
        >
          {{app_name}}
        </td>
      </tr>
      <tr>
        <td style='padding:20px;color:#808080;font-size:16px;font-weight:100'>
          Thank You for registration, Please verify to activate account.<br />
        </td>
      </tr>
      <tr>
        <td style='text-align:center'>
          <a
            href='{{url}}'
            style='display:inline-block;padding:20px;background:#00838f;text-decoration:none;color:#ffffff'
          >{{actionTitle}}</a>
        </td>
      </tr>
    </table>
  </body>

</html>

// src/modules/mail/mailConfig.service.ts

import { MailerOptions, MailerOptionsFactory } from '@nestjs-modules/mailer';
import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { HandlebarsAdapter } from '@nestjs-modules/mailer/dist/adapters/handlebars.adapter';
import * as path from 'path';

@Injectable()
export class MailerConfigClass implements MailerOptionsFactory {
  constructor(private configService: ConfigService) {}

  createMailerOptions(): MailerOptions {
    return {
      transport: {
        host: this.configService.get('mail.host'),
        port: this.configService.get('mail.port'),
        ignoreTLS: this.configService.get('mail.ignoreTLS'),
        secure: this.configService.get('mail.secure'),
        requireTLS: this.configService.get('mail.requireTLS'),
        auth: {
          user: this.configService.get('mail.user'),
          pass: this.configService.get('mail.password'),
        },
      },
      defaults: {
        from: `"${this.configService.get(
          'mail.defaultName',
        )}" <${this.configService.get('mail.defaultEmail')}>`,
      },
      template: {
        dir: path.join(
          this.configService.get('app.workingDirectory'),
          'src',
          'modules',
          'mail',
          'templates',
        ),
        adapter: new HandlebarsAdapter(),
        options: {
          strict: true,
        },
      },
    };
  }
}

In above, we are using handlebars as our templating engine that get included with our installed module for mailer. Above does our all setup so we can use mailer config and use the MailerService everywhere as our MailerModule is global module and exports MailerService, So it is available everywhere as ConfigService. Now we can move towards AppModule where we are importing AuthModule, MailerModule and UserModule. We are going to discuss more in ⁣UserModule.

// src/modules/app/app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { configLoads } from '../config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TypeORMConfigFactory } from '../database/typeorm.factory';
import { AuthModule } from '../auth/auth.module';
import { UserModule } from '../user/user.module';
import { MailerModule } from '@nestjs-modules/mailer';
import { MailerConfigClass } from '../mail/mailerConfig.service';

const modules = [AuthModule, UserModule];

export const global_modules = [
  ...
  MailerModule.forRootAsync({
    useClass: MailerConfigClass,
  }),
];

@Module({
  imports: [...global_modules, ...modules],
})
export class AppModule {}

In src/modules/config/app.config.ts the file, we have included new variable

frontendDomain: process.env.FRONTEND_DOMAIN,

same goes for src/modules/config/mail.config.ts we have added new config variables

// src/modules/config/mail.config.ts

import { registerAs } from '@nestjs/config';

export default registerAs('mail', () => ({
  port: parseInt(process.env.MAIL_PORT, 10),
  host: process.env.MAIL_HOST,
  user: process.env.MAIL_USER,
  password: process.env.MAIL_PASSWORD,
  defaultEmail: process.env.MAIL_DEFAULT_EMAIL,
  defaultName: process.env.MAIL_DEFAULT_NAME,
  ignoreTLS: process.env.MAIL_IGNORE_TLS === 'true',
  secure: process.env.MAIL_SECURE === 'true',
  requireTLS: process.env.MAIL_REQUIRE_TLS === 'true',
}));

We are now ready to move into UserModule, we have seen all the essential parts that needed. Just last part to complete all those APIs that will start working.

// src/modules/user/services/token.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from 'src/entities/user.entity';
import { Token, TokenType } from 'src/entities/user_token.entity';
import { Repository } from 'typeorm';

@Injectable()
export class TokenService {
  constructor(
    @InjectRepository(Token)
    private readonly tokenRepository: Repository<Token>,
  ) {}

  async create(
    user: User,
    type: keyof typeof TokenType = 'REGISTER_VERIFY',
    expires_at: Date = new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
  ) {
    const token = Token.create({
      user_id: user.id,
      type: TokenType[type],
      expires_at,
    });
    return this.tokenRepository.save(token);
  }

  async verify(token: string, type: keyof typeof TokenType) {
    const tokenEntity = await this.tokenRepository.findOne({
      relations: ['user'],
      loadEagerRelations: true,
      where: { token, type: TokenType[type], is_used: false },
    });
    if (!tokenEntity) {
      throw new Error('Token not found');
    }
    if (tokenEntity.expires_at < new Date()) {
      throw new Error('Token expired');
    }
    tokenEntity.is_used = true;
    await tokenEntity.save();
    return tokenEntity.user;
  }
}

Very explanatory in terms of program, one function to create token and another to verify. The token expires in a week, But you can see that expires_at is very dynamic and can be changed after passed as third argument. Now, time for UserService that does nothing but creates a user.

// src/modules/user/services/user.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from 'src/entities/user.entity';
import { RegisterDto } from 'src/modules/auth/email.dto';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async create(userCreateDto: RegisterDto) {
    const user = User.create({ ...userCreateDto });
    return this.userRepository.save(user);
  }
}

At the end, we just import them as providers and exports them to be used in other modules.

// src/modules/user/user.module.ts

import { Module } from '@nestjs/common';
import { UserService } from './services/user.service';
import { TokenService } from './services/token.service';
import { Token } from 'src/entities/user_token.entity';
import { User } from 'src/entities/user.entity';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [TypeOrmModule.forFeature([User, Token])],
  providers: [UserService, TokenService],
  exports: [UserService, TokenService],
})
export class UserModule {}

Now we can open our terminal and run the npm run start:dev command and see our output. But even before everything, we need a logger that logs our request and response. To do that, we have morgan we can install it using npm i morgan and types by npm i -D @types/morgan. That can be included in createApplication in bootstrap file.

// src/utils/bootstrap.ts

import * as morgan from 'morgan';

export const createApplication = (app: INestApplication) => {
  ...
  app.use(morgan('dev'));

  return app;
};

Now it will give us more insight on certain API calls. So after running npm run start:dev. We get something like below that loads all the modules with mapped routes.

[3:14:58 AM] File change detected. Starting incremental compilation...

[3:14:58 AM] Found 0 errors. Watching for file changes.

Debugger attached.
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [NestFactory] Starting Nest application...
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] AppModule dependencies initialized +27ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] TypeOrmModule dependencies initialized +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] MailerModule dependencies initialized +1ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] ConfigHostModule dependencies initialized +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] ConfigModule dependencies initialized +11ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] JwtModule dependencies initialized +5ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] MailerCoreModule dependencies initialized +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] TypeOrmCoreModule dependencies initialized +71ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] TypeOrmModule dependencies initialized +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] TypeOrmModule dependencies initialized +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] UserModule dependencies initialized +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [InstanceLoader] AuthModule dependencies initialized +1ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [RoutesResolver] EmailController {/auth/email} (version: 1): +14ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [RouterExplorer] Mapped {/auth/email/register, POST} (version: 1) route +2ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [RouterExplorer] Mapped {/auth/email/verify, POST} (version: 1) route +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [RouterExplorer] Mapped {/auth/email/login, POST} (version: 1) route +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [RouterExplorer] Mapped {/auth/email/send-verify-email, POST} (version: 1) route +1ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [RouterExplorer] Mapped {/auth/email/reset-password-request, POST} (version: 1) route +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [RouterExplorer] Mapped {/auth/email/reset-password, POST} (version: 1) route +0ms
[Nest] 78996  - 04/09/2024, 3:15:01 AM     LOG [NestApplication] Nest application successfully started +3ms

And above that we can test the routes, I am using mailtrap.io as mail testing platform. You can just go with anything you like. Update .env with below provided sample

NODE_ENV=development
APP_PORT=8000
APP_NAME="NestJS Series"
FRONTEND_DOMAIN=https://example.com

# Database Configuration
DATABASE_URL=postgresql://danimai:Danimai@localhost:5432/nest-series

# Mail confgiuration
MAIL_HOST=
MAIL_PORT=2525
MAIL_USER=
MAIL_PASSWORD=
MAIL_IGNORE_TLS=true
MAIL_SECURE=false
MAIL_REQUIRE_TLS=false
MAIL_DEFAULT_EMAIL=noreply@example.com
MAIL_DEFAULT_NAME=Danimai

# JWT
AUTH_JWT_SECRET=random-gibberish-token-for-jwt
AUTH_JWT_TOKEN_EXPIRES_IN=90d

So I have completed my testing and works very fine for my side. If having any issues on your side let me know in further, We also have comment section to discuss and get into more depth. In the next tutorial, we will be learning how to update User profile and Authorisation guard.

Thank you very much for reading, See you in the next article.

Auth Service with JWT token and mail module, Part 1

depak379mandal — Wed, 29 May 2024 13:18:47 +0000

Love to work with you, You can hire me on Upwork.

Now we have to go with big changes and setup, We need more of base for basic libraries like mail, JWT and bcrypt. So let me describe more on the whole scenario with flowchart and some textual context. We are going to add more complex ideas in future like refresh and access token with more complex media upload.

Above is a very clear sequential diagram to understand the entire architecture that we are going to build to solve the Authentication flow. We are also going to include login API that is not included right now in the Diagram. So let me start with something we call Service, So I am just attaching an email service that will help you to understand how we are going to solve the service. And its work distribution over multiple modules like mail, auth, and user module. Each of the modules have its own functionality that they will be fulfilling, and we are going to arrange all the required functions according to them. About DTOs and Controllers, we have discussed them in previous article.

I am including below the EmailService but there is also AuthService that actually holds the core parts of Authentication service like creating JWT token and sending required email. We will discuss on AuthService at the end of the EmailService.

// src/modules/auth/services/email.service.ts

import {
  Injectable,
  NotFoundException,
  UnprocessableEntityException,
} from '@nestjs/common';
import {
  EmailVerifyDto,
  LoginDto,
  RegisterDto,
  ResetPasswordDto,
  SendVerifyMailDto,
} from '../email.dto';
import { UserService } from '../../user/services/user.service';
import { TokenService } from '../../user/services/token.service';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from 'src/entities/user.entity';
import { Repository } from 'typeorm';
import { AuthService } from './auth.service';

@Injectable()
export class EmailService {
  constructor(
    private authService: AuthService,
    private userService: UserService,
    private tokenService: TokenService,
    @InjectRepository(User) private userRepository: Repository<User>,
  ) {}

  async register(registerDto: RegisterDto) {
    const user = await this.userService.create(registerDto);
    const token = await this.tokenService.create(user, 'REGISTER_VERIFY');
    await this.authService.userRegisterEmail({
      to: user.email,
      data: {
        hash: token.token,
      },
    });
  }

  async verify(verifyDto: EmailVerifyDto) {
    try {
      const user = await this.tokenService.verify(
        verifyDto.verify_token,
        'REGISTER_VERIFY',
      );
      user.email_verified_at = new Date();
      user.is_active = true;
      await user.save();
    } catch (e) {
      throw new UnprocessableEntityException({ verify_token: e.message });
    }
  }

  async login(loginDto: LoginDto) {
    const user = await this.userRepository.findOne({
      where: { email: loginDto.email.toLowerCase() },
    });

    if (!user) {
      throw new UnprocessableEntityException({ email: 'User not found' });
    }
    if (!user.is_active) {
      throw new UnprocessableEntityException({ email: 'User not active' });
    }
    if (!user.email_verified_at) {
      throw new UnprocessableEntityException({ email: 'User not verified' });
    }
    if (!user.comparePassword(loginDto.password)) {
      throw new UnprocessableEntityException({
        password: 'Password is incorrect',
      });
    }
    const auth_token = this.authService.createJwtToken(user);
    return { auth_token };
  }

  async sendVerifyMail(sendVerifyMailDto: SendVerifyMailDto) {
    const user = await this.userRepository.findOne({
      where: { email: sendVerifyMailDto.email.toLowerCase() },
    });

    if (!user) {
      throw new NotFoundException({ email: 'User not found' });
    }
    if (user.email_verified_at) {
      throw new UnprocessableEntityException({
        email: 'User already verified',
      });
    }
    const token = await this.tokenService.create(user, 'REGISTER_VERIFY');
    await this.authService.userRegisterEmail({
      to: user.email,
      data: {
        hash: token.token,
      },
    });
  }

  async sendForgotMail(sendForgotMailDto: SendVerifyMailDto) {
    const user = await this.userRepository.findOne({
      where: { email: sendForgotMailDto.email.toLowerCase() },
    });

    if (!user) {
      throw new UnprocessableEntityException({ email: 'User not found' });
    }

    if (!user.email_verified_at) {
      throw new UnprocessableEntityException({
        email: 'Please verify email first.',
      });
    }

    const token = await this.tokenService.create(user, 'RESET_PASSWORD');
    await this.authService.forgotPasswordEmail({
      to: user.email,
      data: {
        hash: token.token,
      },
    });
  }

  async resetPassword(resetPasswordDto: ResetPasswordDto) {
    try {
      const user = await this.tokenService.verify(
        resetPasswordDto.reset_token,
        'RESET_PASSWORD',
      );
      user.password = resetPasswordDto.password;
      await user.save();
    } catch (e) {
      throw new UnprocessableEntityException({ reset_token: e.message });
    }
  }
}

That is too much to even understand, So I will be breaking functions one by one for you guys, and we will understand how strings are attached and works. It is going to be a long ride, that is good as no system does not have small components. We need to just understand structure/architecture/organization of all multiple small components that make whole big system.

Register User

// src/modules/auth/services/email.service.ts

async register(registerDto: RegisterDto) {
    const user = await this.userService.create(registerDto);
    const token = await this.tokenService.create(user, 'REGISTER_VERIFY');
    await this.authService.userRegisterEmail({
      to: user.email,
      data: {
        hash: token.token,
      },
    });
  }

In above whatever we do of anything related to user we do in userService like create user, updating user Or anything related to user. And we know userService belongs to UserModule So we can use that from UserModule as we don’t want over-distribution of something that particularly belongs to some module. NestJS provide us a way to exports the providers and by importing the module other module any module can use injected dependency without mentioned in providers list as it is directly exported from imported module. So in above module UserServiceand TokenService is coming from UserModule. register function does create user and token, then sends email with token for required verify process in Authentication.

Verify User

// src/modules/auth/services/email.service.ts

async verify(verifyDto: EmailVerifyDto) {
    try {
      const user = await this.tokenService.verify(
        verifyDto.verify_token,
        'REGISTER_VERIFY',
      );
      user.email_verified_at = new Date();
      user.is_active = true;
      await user.save();
    } catch (e) {
      throw new UnprocessableEntityException({ verify_token: e.message });
    }
}

Above is very basic idea what happens on verification it tries to verify the token by helper function this.tokenService.verify that we will look into later and if the token is valid it updates the email_verified_at field with current date and also sets is_active to true. So any user can log in to their account and use APIs in further.

Resend Verify Mail (If user is not verified)

// src/modules/auth/services/email.service.ts

async sendVerifyMail(sendVerifyMailDto: SendVerifyMailDto) {
    const user = await this.userRepository.findOne({
      where: { email: sendVerifyMailDto.email.toLowerCase() },
    });

    if (!user) {
      throw new NotFoundException({ email: 'User not found' });
    }
    if (user.email_verified_at) {
      throw new UnprocessableEntityException({
        email: 'User already verified',
      });
    }
    const token = await this.tokenService.create(user, 'REGISTER_VERIFY');
    await this.authService.userRegisterEmail({
      to: user.email,
      data: {
        hash: token.token,
      },
    });
  }

If user is not verified and unable to verify in particular, expire time. They can resend verify email again from this endpoint. We have injected userRepository to find user if they exist in our DB, or they are already verified, If they are verified we will not re-send verify email. If they are not verified, we will send another email as per request from user.

Send Forgot Email

// src/modules/auth/services/email.service.ts

async sendForgotMail(sendForgotMailDto: SendVerifyMailDto) {
    const user = await this.userRepository.findOne({
      where: { email: sendForgotMailDto.email.toLowerCase() },
    });

    if (!user) {
      throw new UnprocessableEntityException({ email: 'User not found' });
    }

    if (!user.email_verified_at) {
      throw new UnprocessableEntityException({
        email: 'Please verify email first.',
      });
    }

    const token = await this.tokenService.create(user, 'RESET_PASSWORD');
    await this.authService.forgotPasswordEmail({
      to: user.email,
      data: {
        hash: token.token,
      },
    });
  }

This function in service is to provide functionality to send forgot password email, So whenever user requests for forgot password, we can just use this particular function. As same above, we fetch the user details if they exist, we proceed ahead. If they are not verified, we don’t proceed, as they need to first verify the user. Verification is not necessary, it is really up to you if you wanted to include it or not. In ahead we create a token, So user are tracked, then we send password to user.

Reset Password

// src/modules/auth/services/email.service.ts

async resetPassword(resetPasswordDto: ResetPasswordDto) {
    try {
      const user = await this.tokenService.verify(
        resetPasswordDto.reset_token,
        'RESET_PASSWORD',
      );
      user.password = resetPasswordDto.password;
      await user.save();
    } catch (e) {
      throw new UnprocessableEntityException({ reset_token: e.message });
    }
  }

Above is steps to verify user, we verify the use tokenService that verifies and returns the connected user. After that, we proceed with saving the password in DB, but you will notice we are just adding it to DB directly without encrypting. That part actually handled by a hook we implement in User entity.

// src/entities/user.entity.ts

import {
  AfterLoad,
  BeforeInsert,
  BeforeUpdate,
  Column,
  Entity,
  OneToMany,
} from 'typeorm';
import { ApiHideProperty, ApiProperty } from '@nestjs/swagger';
import { BaseEntity } from './base';
import { Token } from './user_token.entity';
import * as bcrypt from 'bcryptjs';

@Entity({ name: 'users' })
export class User extends BaseEntity {
  ...

  @ApiHideProperty()
  previousPassword: string;

  @AfterLoad()
  storePasswordInCache() {
    this.previousPassword = this.password;
  }

  @BeforeInsert()
  @BeforeUpdate()
  async setPassword() {
    if (this.previousPassword !== this.password && this.password) {
      const salt = await bcrypt.genSalt();
      this.password = await bcrypt.hash(this.password, salt);
    }
    this.email = this.email.toLowerCase();
  }

  comparePassword(password: string) {
    return bcrypt.compareSync(password, this.password);
  }
}

Above, we are using listeners and subscribers (hooks). We always create a cache saved as previousPassword, So whenever we update a new password, we can use the previous password from that property to compare and encrypt using bcryptjs. The naming of hooks is very clear, @AfterLoad works after fetching the data from DB, @BeforeInsert and @BeforeUpdate are respectively called after insertion and update of data in DB. We also require a library bcryptjs to be installed.

npm i bcryptjs
npm i -D @types/bcryptjs

Login User

// src/modules/auth/services/email.service.ts

async login(loginDto: LoginDto) {
    const user = await this.userRepository.findOne({
      where: { email: loginDto.email.toLowerCase() },
    });

    if (!user) {
      throw new UnprocessableEntityException({ email: 'User not found' });
    }
    if (!user.is_active) {
      throw new UnprocessableEntityException({ email: 'User not active' });
    }
    if (!user.email_verified_at) {
      throw new UnprocessableEntityException({ email: 'User not verified' });
    }
    if (!user.comparePassword(loginDto.password)) {
      throw new UnprocessableEntityException({
        password: 'Password is incorrect',
      });
    }
    const auth_token = this.authService.createJwtToken(user);
    return { auth_token };
}

At last, we are a place where we can discuss, How user actually logged in. In log in DTO we get email and password, taking both of them we check if user actually exist or not then comparePassword If correct then we create token from authService.

Now is the time to reveal the core of services that we have as AuthService and MailerService.
Auth Service

We need libraries like jwt and nodemailer that will help us in tokenization and mailing respectively. To install them use below command

npm i @nestjs/jwt @nestjs-modules/mailer

Now we can define Auth Service that holds our JWT token creation and sending mail using nodemailer. That is very simple functions we have implemented, So you can take a look at it. It needs multipart to be in places like MailModule as a global module. Also needs MailData an interface that helps to define common data to be passed in functions of email.

// src/modules/auth/services/auth.service.ts

import { Injectable } from '@nestjs/common';
import { User } from 'src/entities/user.entity';
import { JwtService } from '@nestjs/jwt';
import { MailerService } from '@nestjs-modules/mailer';
import { ConfigService } from '@nestjs/config';
import { MailData } from 'src/modules/mail/mail.interface';

@Injectable()
export class AuthService {
  constructor(
    private jwtService: JwtService,
    private mailerService: MailerService,
    private configService: ConfigService,
  ) {}

  createJwtToken(user: User) {
    return this.jwtService.sign({
      id: user.id,
      timestamp: Date.now(),
    });
  }

  async userRegisterEmail(
    mailData: MailData<{
      hash: string;
    }>,
  ) {
    await this.mailerService.sendMail({
      to: mailData.to,
      subject: 'Thank You For Registration, Verify Your Account.',
      text: `${this.configService.get(
        'app.frontendDomain',
      )}/auth/verify?token=${mailData.data.hash}`,
      template: 'auth/registration',
      context: {
        url: `${this.configService.get(
          'app.frontendDomain',
        )}/auth/verify?token=${mailData.data.hash}`,
        app_name: this.configService.get('app.name'),
        title: 'Thank You For Registration, Verify Your Account.',
        actionTitle: 'Verify Your Account',
      },
    });
  }

  async forgotPasswordEmail(
    mailData: MailData<{
      hash: string;
    }>,
  ) {
    await this.mailerService.sendMail({
      to: mailData.to,
      subject: 'Here is your Link for Reset Password.',
      text: `${this.configService.get(
        'app.frontendDomain',
      )}/auth/reset-password?token=${mailData.data.hash}`,
      template: 'auth/registration',
      context: {
        url: `${this.configService.get(
          'app.frontendDomain',
        )}/auth/reset-password?token=${mailData.data.hash}`,
        app_name: this.configService.get('app.name'),
        title: 'Here is your Link for Reset Password.',
        actionTitle: 'Reset Password',
      },
    });
  }
}

For JWT, we need only need to register it as module in AuthModule. To use any of the Entity in services, we always need it to be injected from module. Otherwise, it will raise concern, that we don’t have any service or injectable available in opposite of mentioned one. That is why to use userRepository we are just importing the TypeOrmModule.forFeature([User]) including the required entity to be injected as repository.

// src/modules/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { EmailController } from './email.controller';
import { EmailService } from './services/email.service';
import { AuthService } from './services/auth.service';
import { UserModule } from '../user/user.module';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from 'src/entities/user.entity';
import { JwtModule } from '@nestjs/jwt';
import { ConfigService } from '@nestjs/config';

@Module({
  imports: [
    UserModule,
    TypeOrmModule.forFeature([User]),
    JwtModule.registerAsync({
      inject: [ConfigService],
      useFactory: async (configService: ConfigService) => ({
        secret: configService.get('auth.secret'),
        signOptions: { expiresIn: configService.get('auth.expires') },
      }),
    }),
  ],
  controllers: [EmailController],
  providers: [EmailService, AuthService],
})
export class AuthModule {}

To define basic options for JWT, we provide it directly in imported modules as follows, Also registerAsync to use any other module as that imported module depends on. It dynamically gets instantiated after dependent module creation. So we have provided basic options like secret and expiration time.

// src/modules/auth/auth.module.ts

JwtModule.registerAsync({
  inject: [ConfigService],
  useFactory: async (configService: ConfigService) => ({
    secret: configService.get('auth.secret'),
    signOptions: { expiresIn: configService.get('auth.expires') },
  }),
}),

We need to discuss more on Mail Module and User module that are used in above code snippets. But this article is getting bigger that expected. So let us move the parts in next article. Thank you very much for reading, check my profile in further to get into other articles of this series.
See you in the next.

Validation and controller setup in Nest JS

depak379mandal — Wed, 29 May 2024 13:09:56 +0000

Love to work with you, You can hire me on Upwork.

We have gone from defining first phase requirement to config load and TypeORM setup with migrations. Now we will look into setting up validation serialization and controller with Swagger Decorator’s.

We are starting with auth module, and we are going to create email controller instead of auth controller as we in future will add more services and controller for authentication provider like google, Facebook and LinkedIn. We already discussed APIs in getting started article, We are implementing those in here for controller and validation setup.

So I will just add controller with some comments and later will be explaining in details.



// src/modules/auth/email.controller.ts

import { Body, Controller, HttpCode, HttpStatus, Post } from '@nestjs/common';
import {
  ApiAcceptedResponse,
  ApiCreatedResponse,
  ApiForbiddenResponse,
  ApiNoContentResponse,
  ApiNotFoundResponse,
  ApiOperation,
  ApiTags,
} from '@nestjs/swagger';
import {
  EmailVerifyDto,
  LoginDto,
  RegisterDto,
  SendVerifyMailDto,
} from './email.dto';
import { EmailService } from './email.service';

// This is for swagger to aggregate all the APIs under this tag
@ApiTags('Auth Email')
// auth/email is path and it will get suffixed with /v1 as /v1/auth/email
@Controller({
  path: 'auth/email',
  version: '1',
})
export class EmailController {

  // It will be used later right now we are just 
  // going to return whatever we are getting from body
  constructor(private emailService: EmailService) {}

  @Post('/register')
  @ApiOperation({ summary: 'Register by email' })
  @ApiCreatedResponse({
    description: 'User successfully registered.',
  })
  // this actually overrides the default status code 
  @HttpCode(HttpStatus.CREATED)
  async register(@Body() registerDto: RegisterDto) {
    return registerDto;
  }

  @Post('/verify')
  @ApiOperation({ summary: 'Verify Email address.' })
  @ApiAcceptedResponse({
    description: 'Email verified successfully.',
  })
  @HttpCode(HttpStatus.ACCEPTED)
  async verify(@Body() emailVerifyDto: EmailVerifyDto) {
    return emailVerifyDto;
  }

  @Post('/login')
  @ApiOperation({ summary: 'Log in with Email.' })
  @HttpCode(HttpStatus.OK)
  async login(@Body() loginDto: LoginDto) {
    return loginDto;
  }

  @Post('/send-verify-email')
  @ApiOperation({ summary: 'Send Verification mail.' })
  @ApiNoContentResponse({
    description: 'Sent Verification mail.',
  })
  @ApiForbiddenResponse({
    description: 'User already verified.',
  })
  @ApiNotFoundResponse({
    description: 'User not found.',
  })
  @HttpCode(HttpStatus.NO_CONTENT)
  async sendVerifyMail(@Body() sendVerifyMailDto: SendVerifyMailDto) {
    return sendVerifyMailDto;
  }

  @Post('/reset-password-request')
  @ApiOperation({ summary: 'Send Reset Password mail.' })
  @ApiNoContentResponse({
    description: 'Sent Reset Password mail.',
  })
  @ApiForbiddenResponse({
    description: 'Please verify email first.',
  })
  @ApiNotFoundResponse({
    description: 'User not found.',
  })
  @HttpCode(HttpStatus.NO_CONTENT)
  async sendForgotMail(@Body() sendForgotMailDto: SendVerifyMailDto) {
    return sendForgotMailDto;
  }
}



// src/modules/auth/email.service.ts

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

@Injectable()
export class EmailService {
  constructor() {}
}

Have added some comments in the above code for understanding details of the code that are included. All the decorator starts with @Api are swagger decorators that generate code for us. So to define methods of the API we use @Get @post @Patch @head @Delete and @Put Decorators, they are very conveniently available from NestJS common library. You have to provide path, it automatically merges the base path from Controller decorator as suffix and starts working. You can also observer I have included emailService that we will discuss in the next article, But DTO’s will be in this article. DTO’s are for validation they are classes that have class-validator decorators and swagger decorators that help us the Body to validate and in same time it works as our swagger documentation.

You will see many decorators to even fetch some common data from request object or even Request itself. NestJS provide very convenient decorators for all those things. Like in above, I have used @Body decorator that actually gives me back body object from request. I can also fetch single field from body as @Body('email') previous code only fetches email from body, nothing else. We can also validate a particular body by providing a class with Validation Pipe. A Validation Pipe we are going to implement, but that will be global, not for every endpoint. So Validation Pipe Will take care of everything.

We need an endpoint for swagger too, So first we need all the DTO we have imported from email.dto.ts files and global validation pipe with swagger setup for our application.



// src/modules/auth/email.dto.ts

import { ApiProperty } from '@nestjs/swagger';
import { Transform } from 'class-transformer';
import {
  IsEmail,
  IsNotEmpty,
  IsString,
  IsStrongPassword,
} from 'class-validator';

const strongPasswordConfig = {
  minLength: 8,
  minLowercase: 1,
  minNumbers: 1,
  minSymbols: 1,
  minUppercase: 1,
};

export class RegisterDto {
  @ApiProperty({ example: 'example@danimai.com' })
  @IsEmail()
  @Transform(({ value }) =>
    typeof value === 'string' ? value.toLowerCase() : value,
  )
  email: string;

  @ApiProperty({ example: 'Password@123' })
  @IsString()
  @IsStrongPassword(strongPasswordConfig)
  password: string;

  @ApiProperty({ example: 'Danimai' })
  @IsString()
  @IsNotEmpty()
  first_name: string;

  @ApiProperty({ example: 'Mandal' })
  @IsString()
  @IsNotEmpty()
  last_name: string;
}

export class EmailVerifyDto {
  @ApiProperty({ example: 'vhsbdjsdfsd-dfmsdfjsd-sdfnsdk' })
  @IsString()
  verify_token: string;
}

export class LoginDto {
  @ApiProperty({ example: 'example@danimai.com' })
  @IsEmail()
  @Transform(({ value }) =>
    typeof value === 'string' ? value.toLowerCase() : value,
  )
  email: string;

  @ApiProperty({ example: 'Password@123' })
  @IsString()
  @IsStrongPassword(strongPasswordConfig)
  password: string;
}

export class SendVerifyMailDto {
  @ApiProperty({ example: 'example@danimai.com' })
  @IsEmail()
  @Transform(({ value }) =>
    typeof value === 'string' ? value.toLowerCase() : value,
  )
  email: string;
}

export class ResetPasswordDto {
  @ApiProperty({ example: 'Password@123' })
  @IsString()
  @IsStrongPassword(strongPasswordConfig)
  password: string;

  @ApiProperty({ example: 'vhsbdjsdfsd-dfmsdfjsd-sdfnsdk' })
  @IsString()
  reset_token: string;
}



// src/utils/validation-options.ts

import {
  HttpException,
  HttpStatus,
  ValidationError,
  ValidationPipeOptions,
} from '@nestjs/common';

const validationOptions: ValidationPipeOptions = {
  transform: true,
  whitelist: true,
  errorHttpStatusCode: HttpStatus.UNPROCESSABLE_ENTITY,
  exceptionFactory: (errors: ValidationError[]) =>
    new HttpException(
      {
        status: HttpStatus.UNPROCESSABLE_ENTITY,
        errors: errors.reduce(
          (accumulator, currentValue) => ({
            ...accumulator,
            [currentValue.property]: Object.values(
              currentValue.constraints,
            ).join(', '),
          }),
          {},
        ),
      },
      HttpStatus.UNPROCESSABLE_ENTITY,
    ),
};

export default validationOptions;



// src/utils/bootstrap.ts

import {
  INestApplication,
  ValidationPipe,
  VersioningType,
} from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
import { SerializerInterceptor } from './serializer.interceptor';
import validationOptions from './validation-options';

// for swagger documentation builder it takes application and gives back us with setup
export const documentationBuilder = (
  app: INestApplication,
  configService: ConfigService,
) => {
  const config = new DocumentBuilder()
    .addBearerAuth()
    .setTitle(configService.get('app.name'))
    .setDescription('The Danimai API description')
    .setVersion('1')
    .build();

  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('docs', app, document);
};

// some global implementation in one function like URI versioning, global pipe and interceptor
export const createApplication = (app: INestApplication) => {
  app.enableShutdownHooks();
  app.enableVersioning({
    type: VersioningType.URI,
  });
  app.useGlobalInterceptors(new SerializerInterceptor());
  app.useGlobalPipes(new ValidationPipe(validationOptions));

  return app;
};



// src/utils/serializer.interceptor.ts

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
} from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class SerializerInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    return next.handle().pipe();
  }
}

Above are some new things we have introduced, like validation pipe that helps us in documentation. But be with me, we will understand them one by one as we move forward, just include them as for now. As we right now have a bootstrap file, we can utilize that in our main.ts file.



// src/main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './modules/app/app.module';
import { ConfigService } from '@nestjs/config';
import { createApplication, documentationBuilder } from './utils/bootstrap';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  const configService = app.get(ConfigService);

  // bootstrapped functions
  createApplication(app);
  documentationBuilder(app, configService);

  await app.listen(configService.get('app.port') || 8000);
}
bootstrap();

Even now we will not get any output as we don’t have included anything in auth.module.ts and that is not included in app.module.ts parent module file.



// src/modules/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { EmailController } from './email.controller';
import { EmailService } from './email.service';

@Module({
  controllers: [EmailController],
  providers: [EmailService],
})
export class AuthModule {}

And we include this module in main app module.



import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { configLoads } from '../config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TypeORMConfigFactory } from '../database/typeorm.factory';
import { AuthModule } from '../auth/auth.module';

// here we have included that
const modules = [AuthModule];

export const global_modules = [
  ConfigModule.forRoot({
    load: configLoads,
    isGlobal: true,
    envFilePath: ['.env'],
  }),
  TypeOrmModule.forRootAsync({
    useClass: TypeORMConfigFactory,
  }),
];

@Module({
  imports: [...global_modules, ...modules],
})
export class AppModule {}

It is just first setup to cover everything else, in upcoming series. If now you will run the application using



npm run start:dev

It will show you this, where every router getting mapped with AuthModule Instance.



[10:23:03 PM] File change detected. Starting incremental compilation...

[10:23:03 PM] Found 0 errors. Watching for file changes.

[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [NestFactory] Starting Nest application...
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [InstanceLoader] AppModule dependencies initialized +12ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [InstanceLoader] TypeOrmModule dependencies initialized +0ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [InstanceLoader] ConfigHostModule dependencies initialized +0ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [InstanceLoader] AuthModule dependencies initialized +5ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [InstanceLoader] TypeOrmCoreModule dependencies initialized +74ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [RoutesResolver] EmailController {/auth/email} (version: 1): +24ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [RouterExplorer] Mapped {/auth/email/register, POST} (version: 1) route +2ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [RouterExplorer] Mapped {/auth/email/verify, POST} (version: 1) route +0ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [RouterExplorer] Mapped {/auth/email/login, POST} (version: 1) route +1ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [RouterExplorer] Mapped {/auth/email/send-verify-email, POST} (version: 1) route +0ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [RouterExplorer] Mapped {/auth/email/reset-password-request, POST} (version: 1) route +0ms
[Nest] 29745  - 04/05/2024, 10:23:04 PM     LOG [NestApplication] Nest application successfully started +2ms

And to view Swagger you have to go to http://localhost:8000/docs/ in browser, it will show the UI for swagger

But above is nothing as it does not work as expected, it only takes body validates and returns error if invalid or returns same data if valid. So we need to implement services for this controller.

Let us meet in the next, and complete this API endpoints one by one and deep dive into more concept of Nest JS. Thank you

TypeORM integration with migrations in NestJS

depak379mandal — Wed, 29 May 2024 13:00:52 +0000

Love to work with you, You can hire me on Upwork.

To even think about TypeORM we must install all the required libraries in the application, already included command in getting started article. We can run below code to install TypeORM with pg Postgres driver.

npm install --save @nestjs/typeorm typeorm pg

We can define a factory class/function that will return all the required details/config for our TypeORM module. It will be helpful to segregate modules in terms of their functionality.

Even before everything we need a database, I have created nest-series database in Postgres using DBeaver. You can use PGAdmin or any other tool just connect to your local DB Or you can use remote as per your interest. After that You have to create a connection URL, that URL will look like below.

DATABASE_URL=postgresql://<username>:<password>@localhost:5432/nest-series

Just replace above with your credentials and place it in .env. Now we move to our config factory class. Config class will use details ormconfig.ts file, So ormconfig.ts can be used in npm command as data source.

// ormconfig.ts

import { DataSource } from 'typeorm';
import * as dotenv from 'dotenv';
import { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions';

dotenv.config();

export const configs: PostgresConnectionOptions = {
  type: 'postgres',
  url: process.env.DATABASE_URL,
  entities: [__dirname + '/src/**/*.entity.{ts,js}'],
  migrations: [__dirname + '/src/modules/database/migrations/*{.ts,.js}'],
  dropSchema: false,
  logging: false,
};
const dataSource = new DataSource(configs);

export default dataSource;

// src/modules/database/typeorm.factory.ts

import { Injectable } from '@nestjs/common';
import { TypeOrmModuleOptions, TypeOrmOptionsFactory } from '@nestjs/typeorm';
import ORMConfig from '../../../ormconfig';

@Injectable()
export class TypeORMConfigFactory implements TypeOrmOptionsFactory {
  createTypeOrmOptions(): TypeOrmModuleOptions {
    return ORMConfig.options;
  }
}

We can use Injectable class to use configService as I have mentioned in earlier article that we will be using config service as an injected service. In constructor, we can inject configService as ConfigService. We have implemented TypeOrmOptionsFactory the interface to follow the particular contract of factory config class. Now we can use this factory in App Module file where we are registering our TypeORM Module.

// src/modules/app/app.module.ts

...
import { TypeOrmModule } from '@nestjs/typeorm';
import { TypeORMConfigFactory } from '../database/typeorm.factory';

const modules = [];

export const global_modules = [
  ...
  TypeOrmModule.forRoot({
    useClass: TypeORMConfigFactory,
  }),
];

@Module({
  imports: [...global_modules, ...modules],
})
export class AppModule {}

After this, you can run npm run start:dev to confirm if anything is going wrong in setup for TypeORM. As we move forward, we need entities as per our requirement we have defined in the first article. We require entities, we will start from user entity But user also require base entity that will automatically handle the timestamps and ID for us.

// src/entities/base.ts

import { ApiProperty } from '@nestjs/swagger';
import {
  BaseEntity as _BaseEntity,
  CreateDateColumn,
  DeleteDateColumn,
  PrimaryGeneratedColumn,
  UpdateDateColumn,
} from 'typeorm';

export abstract class BaseEntity extends _BaseEntity {
  // we are using uuid instead of integers
  @ApiProperty()
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @ApiProperty()
  @CreateDateColumn()
  created_at: Date;

  @ApiProperty()
  @UpdateDateColumn()
  updated_at: Date;

  @DeleteDateColumn()
  deleted_at: Date;
}

I have introduced swagger decorator above, You can see ApiProperty decorator that handles Swagger doc generation. deleted_at will not be exposed in swagger doc, So we are not adding decorator above for it. One little thing you might have noticed that I have created an abstract class, reason behind that is we don’t want any table related to Base entity or any other tracking from TypeORM. Now we move to user entity and user token entity.

// src/entities/user.entity.ts

import { Column, Entity } from 'typeorm';
import { ApiHideProperty, ApiProperty } from '@nestjs/swagger';
import { BaseEntity } from './base';

@Entity({ name: 'users' })
export class User extends BaseEntity {
  @ApiProperty({ example: 'Danimai' })
  @Column({ type: 'varchar', length: 50 })
  first_name: string;

  @ApiProperty({ example: 'Mandal' })
  @Column({ type: 'varchar', length: 50, nullable: true })
  last_name: string;

  @ApiProperty({ example: 'example@danimai.com' })
  @Column({ type: 'varchar', length: 255, unique: true })
  email: string;

  @ApiProperty({ example: 'Password@123' })
  @Column({ type: 'varchar', length: 255, nullable: true })
  password: string;

  @ApiHideProperty()
  @Column({ type: 'timestamp with time zone', nullable: true })
  email_verified_at: Date;

  @ApiHideProperty()
  @Column({ type: 'boolean', default: false })
  is_active: boolean;
}

import { randomStringGenerator } from '@nestjs/common/utils/random-string-generator.util';
import { BeforeInsert, Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
import { User } from './user.entity';
import { BaseEntity } from './base';

export enum TokenType {
  REGISTER_VERIFY = 'REGISTER_VERIFY',
  RESET_PASSWORD = 'RESET_PASSWORD',
}

@Entity({ name: 'user_tokens' })
export class Token extends BaseEntity {
  @Column({ type: 'varchar', length: 100 })
  token: string;

  @Column({ type: 'boolean', default: false })
  is_used: boolean;

  @Column({ type: 'enum', enum: TokenType })
  type: TokenType;

  @Column({ type: 'timestamp' })
  expires_at: Date;

  @Column({ type: 'uuid' })
  user_id: string;

  @ManyToOne(() => User, (user) => user.tokens)
  @JoinColumn({ name: 'user_id' })
  user: User;

  // This decorator allows to run before insert command
  // setting up token automatically before insert
  @BeforeInsert()
  async generateToken() {
    // generate long token for registration and forgot password
    this.token = `${randomStringGenerator()}-${randomStringGenerator()}`;
  }
}

We also need something we called migration files to be generated for these entities So everyone can sync their DB. to do that we are going to add scripts for migration in package.json

{
  ...
  "scripts": {
    ...
    "migration:generate": "typeorm-ts-node-commonjs migration:generate src/modules/database/migrations/migrations -d ormconfig.ts",
    "migration:run": "typeorm-ts-node-commonjs -d ormconfig.ts migration:run",
    "migration:revert": "typeorm-ts-node-commonjs -d ormconfig.ts migration:revert"
  },
  ...
}

After adding above command in package.json file we now can generate migration file using npm run migration:generate command and then to migrate them npm run migration:run, if we think that migration was wrong Or wanted to edit just revert the migration in DB by npm run migration:revert. So if you wanted to follow the migration, you can just follow me. Run below command.

npm run migration:generate
npm run migration:run

After running generate command, we will get a migration file in src/modules/database/migrations folder, mine is.

// src/modules/database/migrations/1712332008837-migrations.ts

import { MigrationInterface, QueryRunner } from 'typeorm';

export class Migrations1712332008837 implements MigrationInterface {
  name = 'Migrations1712332008837';

  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(
      `CREATE TYPE "public"."user_tokens_type_enum" AS ENUM('REGISTER_VERIFY', 'RESET_PASSWORD')`,
    );
    await queryRunner.query(
      `CREATE TABLE "user_tokens" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "deleted_at" TIMESTAMP, "token" character varying(100) NOT NULL, "is_used" boolean NOT NULL DEFAULT false, "type" "public"."user_tokens_type_enum" NOT NULL, "expires_at" TIMESTAMP NOT NULL, "user_id" uuid NOT NULL, CONSTRAINT "PK_63764db9d9aaa4af33e07b2f4bf" PRIMARY KEY ("id"))`,
    );
    await queryRunner.query(
      `CREATE TABLE "users" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "deleted_at" TIMESTAMP, "first_name" character varying(50) NOT NULL, "last_name" character varying(50), "email" character varying(255) NOT NULL, "password" character varying(255), "email_verified_at" TIMESTAMP WITH TIME ZONE, "is_active" boolean NOT NULL DEFAULT false, CONSTRAINT "UQ_97672ac88f789774dd47f7c8be3" UNIQUE ("email"), CONSTRAINT "PK_a3ffb1c0c8416b9fc6f907b7433" PRIMARY KEY ("id"))`,
    );
    await queryRunner.query(
      `ALTER TABLE "user_tokens" ADD CONSTRAINT "FK_9e144a67be49e5bba91195ef5de" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(
      `ALTER TABLE "user_tokens" DROP CONSTRAINT "FK_9e144a67be49e5bba91195ef5de"`,
    );
    await queryRunner.query(`DROP TABLE "users"`);
    await queryRunner.query(`DROP TABLE "user_tokens"`);
    await queryRunner.query(`DROP TYPE "public"."user_tokens_type_enum"`);
  }
}

And after npm run migration:run it should fill up your DB like mine

As we are moving forward, we are arranging our structure, So the current structure looks pretty good and convincing in terms of clean code.

src
├── entities
│   ├── base.ts
│   ├── user.entity.ts
│   └── user_token.entity.ts
├── main.ts
└── modules
    ├── app
    │   └── app.module.ts
    ├── auth
    ├── config
    │   ├── app.config.ts
    │   ├── database.config.ts
    │   └── index.ts
    ├── database
    │   ├── migrations
    │   │   └── 1712332008837-migrations.ts
    │   └── typeorm.factory.ts
    └── user

If you run the npm run start:dev You will see below If having any doubts or issues, please mention them in comments.

[9:23:31 PM] Starting compilation in watch mode...

[9:23:33 PM] Found 0 errors. Watching for file changes.

[Nest] 26803  - 04/05/2024, 9:23:34 PM     LOG [NestFactory] Starting Nest application...
[Nest] 26803  - 04/05/2024, 9:23:34 PM     LOG [InstanceLoader] AppModule dependencies initialized +11ms
[Nest] 26803  - 04/05/2024, 9:23:34 PM     LOG [InstanceLoader] TypeOrmModule dependencies initialized +1ms
[Nest] 26803  - 04/05/2024, 9:23:34 PM     LOG [InstanceLoader] ConfigHostModule dependencies initialized +0ms
[Nest] 26803  - 04/05/2024, 9:23:34 PM     LOG [InstanceLoader] ConfigModule dependencies initialized +9ms
[Nest] 26803  - 04/05/2024, 9:23:35 PM     LOG [InstanceLoader] TypeOrmCoreModule dependencies initialized +183ms
[Nest] 26803  - 04/05/2024, 9:23:35 PM     LOG [NestApplication] Nest application successfully started +6ms

In the next article, we will be having our controllers and validation in place. So we can attach our Service in next series of articles.

Load .env using Config Module in NestJS

depak379mandal — Tue, 28 May 2024 19:37:04 +0000

Love to work with you, You can hire me on Upwork.

We are moving towards something that will give us a very good idea how to maintain our all global environment variable. NestJs have solution library for that.



npm i --save @nestjs/config

We will have config folder inside modules that will contain all the config from .env in separate files according to concern, i.e., database env variables will be in database.config.ts and get imported from .env file from local. @nestjs/config loads data from .env file, but we can actually define from it can fetch more variables according to our requirement. But I would suggest to use only .env as it is very easy to understand and maintain in between developers.

Below just an example how you can use and register Config Module from NestJS standard config library to maintain the segregation between different types of .env variable and can use them accordingly in any module as ConfigModule. Starting this process with defining some config variables in src/modules/config/app.config.ts and src/modules/config/database.config.ts. app.config.ts will contain some normal global metadata for app and database.config.ts will contain data related to database. They both are defined below.



// src/modules/config/app.config.ts

import { registerAs } from '@nestjs/config';

export default registerAs('app', () => ({
  nodeEnv: process.env.NODE_ENV,
  name: process.env.APP_NAME,
  workingDirectory: process.env.PWD || process.cwd(),
  port: process.env.APP_PORT,
}));



// src/modules/config/database.config.ts

import { registerAs } from '@nestjs/config';

export default registerAs('database', () => ({
  url: process.env.DATABASE_URL,
}));

And inside src/modules/config/index.ts we will export them as an array So they can be loaded in ConfigModule in app module.



// src/modules/config/index.ts

import appConfig from './app.config';
import databaseConfig from './database.config';

export const configLoads = [databaseConfig, appConfig];

Now we have to load them in app module, App module is center of everything, So to use every module in system you have to register it there. We will import config module there, and we will go with two types of module, both are global and normal modules. Both will have different array, so we will now have very clear understanding which modules’ feature can be used as global.



// src/modules/app/app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { configLoads } from '../config';

const modules = [];

export const global_modules = [
  ConfigModule.forRoot({
    load: configLoads,
    isGlobal: true,
    envFilePath: ['.env'],
  }),
];

@Module({
  imports: [...global_modules, ...modules],
})
export class AppModule {}

To define ConfigModule as global, we have passed isGlobal as true and we also passed our configLoads with envFilePath but you don’t have to pass .env separately, it automatically loads .env for us. We have used forRoot function to registering the module. Most of the module does provide us these type of interface to register them.

Now time to use them for use cases, We are going to use port from app config in main.ts to set port dynamically from .env file for application.



// src/main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './modules/app/app.module';
import { ConfigService } from '@nestjs/config';

async function bootstrap() {
  // created application instance using NestFactory
  const app = await NestFactory.create(AppModule);

  // getting configService from application 
  // to fetch port from app.config.ts config load
  const configService = app.get(ConfigService);

  // used the port value here
  await app.listen(configService.get('app.port') || 8000);
}
bootstrap();

Now we can define .env file in our working directory that will hold our environment variables that can be used in further application.
Below is a sample .env file you can use.



NODE_ENV=development
APP_PORT=8000
APP_NAME="NestJS Series"

# Database Configuration
DATABASE_URL=postgresql://localhost:5432

After adding .env file run npm run start:dev it will show you output, you can see it is running without error.

In the next article, we will see how we can utilize particular .env variables inside other modules using ConfigService injection through TypeORM introduction.

Thank you for reading, see you in the next.

Getting started with Nest JS

depak379mandal — Tue, 28 May 2024 19:26:12 +0000

Love to work with you, You can hire me on Upwork.

You can just have a look into NestJS doc for more basics but yeah we will be covering all over the tutorial series. It is a practical guide to understand whole NestJS framework for beginner and intermediate to advanced.

Before anything else we need a starting point and NestJS covered that for us. We can use their CLI tool to create new project. First, we need to install nest CLI as global command. You can use the below command to install and start your own NestJS project.

npm i -g @nestjs/cli
nest new nestjs-series

Now we have a project, just open it up your liked text editor, I am using VS Code. Defining a layout/architecture of project is very crucial part, you can see src folder inside just create this particular folder and file structure that we will be using for entire project.

src
├── entities
├── main.ts
└── modules
    ├── app
    ├── auth
    ├── config
    ├── database
    ├── mail
    ├── media
    └── user

Let me describe them one by one, entities will have all the models/entities that will take care of our communication with DB and those will be injected accordingly into services as used for. We will be discussing more on Dependency Injection and services and many more things coming in this series.
What we want to achieve

We want to achieve a boilerplate or small project that will be guided to understand whole NestJS frameworks. NestJS is more like library instead of framework not as framework as it does provide you very much flexibility in terms of everything you wanted to achieve in any way.

So what we want to create is very important to even start any project. Because without what you want to build, doing anything is time taking and dumping things to create a pile of bugs.

Let us start with some API doc, what we wanted to achieve in this series. I will not be able to write e2e test cases as it will be slowing down our series progress.

Here are our APIs’ and there documentation to be made, we can first define the Auth API docs that we can start our work with

POST /v1/auth/email/register

// body
{
  "email": "example@danimai.com",
  "password": "Password@123",
  "first_name": "Danimai",
  "last_name": "Mandal"
}

// response code
201 Created Successfully

Verify email address

POST /v1/auth/email/verify

// body 
{
  "verify_token": "vhsbdjsdfsd-dfmsdfjsd-sdfnsdk"
}

// response code
200 Verified Successfully

POST /v1/auth/email/login

// body
{
  "email": "example@danimai.com",
  "password": "Password@123"
}
// response code
200 Logged in Successfully

// response body
{
  "auth_token": "vhsbdjsdfsd-dfmsdfjsd-sdfnsdk"
}

Send verify email

POST /v1/auth/email/send-verify-email

// body
{
  "email": "example@danimai.com"
}

// response code
204 
Sent Verification mail.

Request reset password

POST /v1/auth/email/reset-password-request

// body 
{
  "email": "example@danimai.com"
}

Reset Password

POST /v1/auth/email/reset-password

// body
{
  "password": "Password@123",
  "reset_token": "vhsbdjsdfsd-dfmsdfjsd-sdfnsdk"
}

Log out user

GET /v1/auth/logout // authenticated route

Now as we go ahead we need more of brain mapping structure that we wanted to create modules for. I also wanted to explain the structure that we are going to use. So the list of what we require are and what we are going to

validation

class-validator and class-transformer those are two libraries we are going to use for validation, so we can just run

npm i --save class-validator class-transformer

Swagger doc

We have very cool library from NestJS that handles all our requirement by attaching Swagger decorator in validator classes, and we can just use that as extension not as whole separate setup that requires maintenance. You can run below command to install swagger library by NestJS.

npm install --save @nestjs/swagger

SQL ORM (TypeORM)

We are going to use TypeORM as it supports very well with NestJS, but I would suggest Drizzle or Knex Or anything else that are very fast and allow us more control over raw SQL. But you also have to remember TypeORM is not enemy, you don’t have to migrate to any other ORM or library if you don’t face any critical issues. To install TypeORM use the below command. The command includes TypeORM, TypeORM wrapper for NestJS and pg driver for PostgreSQL.

npm install --save @nestjs/typeorm typeorm pg

Platform (Express)

Indeed, NestJS is a separate framework, but It uses platform library like express or Fastify to use to run everything. NestJS actually provides its own wrapper to run everything. We will go forward with express.

npm i @nestjs/platform-express // it should be installed with nest new command

Above are basic library we need to proceed Or to just gain more idea what are we dealing with. In the next article, we will set up things with TypeORM and create some commands to run migration. We will go over each of the things mentioned above, So see you in the next.

Code for every article are provided in this repo.

Getting started with NestJS

depak379mandal — Tue, 28 May 2024 19:26:12 +0000

Love to work with you, You can hire me on Upwork.

You can just take a look into NestJS doc for more basics but yeah we will be covering all over the tutorial series. It is a practical guide to understand whole NestJS framework for beginner and intermediate to advanced.

npm i -g @nestjs/cli
nest new nestjs-series

src
├── entities
├── main.ts
└── modules
    ├── app
    ├── auth
    ├── config
    ├── database
    ├── mail
    ├── media
    └── user

So what we want to create is very important to even start any project. Because without what you want to build, doing anything is time taking and dumping things to create a pile of bugs.

Let us start with some API doc, what we wanted to achieve in this series. I will not be able to write e2e test cases as it will be slowing down our series progress.

Here are our APIs’ and there documentation to be made, we can first define the Auth API docs that we can start our work with

POST /v1/auth/email/register

// body
{
  "email": "example@danimai.com",
  "password": "Password@123",
  "first_name": "Danimai",
  "last_name": "Mandal"
}

// response code
201 Created Successfully

Verify email address

POST /v1/auth/email/verify

// body 
{
  "verify_token": "vhsbdjsdfsd-dfmsdfjsd-sdfnsdk"
}

// response code
200 Verified Successfully

POST /v1/auth/email/login

// body
{
  "email": "example@danimai.com",
  "password": "Password@123"
}
// response code
200 Logged in Successfully

// response body
{
  "auth_token": "vhsbdjsdfsd-dfmsdfjsd-sdfnsdk"
}

Send verify email

POST /v1/auth/email/send-verify-email

// body
{
  "email": "example@danimai.com"
}

// response code
204 
Sent Verification mail.

Request reset password

POST /v1/auth/email/reset-password-request

// body 
{
  "email": "example@danimai.com"
}

Reset Password

POST /v1/auth/email/reset-password

// body
{
  "password": "Password@123",
  "reset_token": "vhsbdjsdfsd-dfmsdfjsd-sdfnsdk"
}

Log out user

GET /v1/auth/logout // authenticated route

validation

class-validator and class-transformer those are two libraries we are going to use for validation, so we can just run

npm i --save class-validator class-transformer

Swagger doc

npm install --save @nestjs/swagger

SQL ORM (TypeORM)

npm install --save @nestjs/typeorm typeorm pg

Platform (Express)

npm i @nestjs/platform-express // it should be installed with nest new command

Code for every article are provided in this repo.