feat: confirm maill auth

src/app.module.ts

@@ -8,13 +8,15 @@ import { AuthModule } from './auth/auth.module';
 import { PrismaService } from './prisma.service';
 import { UserModule } from './user/user.module';
 import { EmailModule } from './email/email.module';
+import { EmailConfirmationModule } from './email/confirmation/emailConfirmation.module';
 
 @Module({
   imports: [
     PrismaService,
     AuthModule,
     ConfigModule,
     ScheduleModule.forRoot(),
+    EmailConfirmationModule,
     EmailModule,
     CityModule,
     UserModule,

src/dtos/auth/auth-token.ts

@@ -1,6 +1,9 @@
 import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString } from 'class-validator';
 
 export class AuthTokenDto {
   @ApiProperty()
+  @IsString()
+  @IsNotEmpty()
   public token!: string;
 }

src/email/confirmation/emailConfirmation.controller.ts

@@ -0,0 +1,33 @@
+import {
+  Controller,
+  ClassSerializerInterceptor,
+  UseInterceptors,
+  Post,
+  Body,
+} from '@nestjs/common';
+import { AuthTokenDto } from 'src/dtos';
+import { EmailConfirmationService } from './emailConfirmation.service';
+// import JwtAuthenticationGuard from '../authentication/jwt-authentication.guard';
+// import RequestWithUser from '../emailSchedule.controller';
+
+@Controller('email-confirmation')
+@UseInterceptors(ClassSerializerInterceptor)
+export class EmailConfirmationController {
+  constructor(
+    private readonly emailConfirmationService: EmailConfirmationService,
+  ) {}
+
+  @Post('confirm')
+  async confirm(@Body() confirmationData: AuthTokenDto) {
+    const email = await this.emailConfirmationService.decodeConfirmationToken(
+      confirmationData.token,
+    );
+    await this.emailConfirmationService.confirmEmail(email);
+  }
+
+  // @Post('resend-confirmation-link')
+  // @UseGuards(JwtAuthenticationGuard)
+  // async resendConfirmationLink(@Req() request: RequestWithUser) {
+  //   await this.emailConfirmationService.resendConfirmationLink(request.user.id);
+  // }
+}

src/email/confirmation/emailConfirmation.guard.ts

@@ -0,0 +1,25 @@
+import {
+  Injectable,
+  CanActivate,
+  ExecutionContext,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Request } from 'express';
+import { UserDto } from 'src/dtos';
+
+export interface RequestWithUser extends Request {
+  user: UserDto;
+}
+
+@Injectable()
+export class EmailConfirmationGuard implements CanActivate {
+  canActivate(context: ExecutionContext) {
+    const request: RequestWithUser = context.switchToHttp().getRequest();
+
+    if (!request.user?.isEmailConfirmed) {
+      throw new UnauthorizedException('Confirm your email first');
+    }
+
+    return true;
+  }
+}

src/email/confirmation/emailConfirmation.module.ts

@@ -0,0 +1,34 @@
+import { Module } from '@nestjs/common';
+import { PrismaService } from 'src/prisma.service';
+import { UserService } from 'src/user/user.service';
+import EmailService from '../email.service';
+import { EmailConfirmationController } from './emailConfirmation.controller';
+import { EmailConfirmationService } from 'src/email/confirmation/emailConfirmation.service';
+import { JwtModule, JwtService } from '@nestjs/jwt';
+import { AuthService } from 'src/auth/auth.service';
+import { AuthController } from 'src/auth/auth.controller';
+import { AuthModule } from 'src/auth/auth.module';
+import { JwtStrategy } from 'src/auth/jwt-strategy';
+import { ConfigService } from 'config/config.service';
+
+@Module({
+  imports: [
+    JwtModule.registerAsync({
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => ({
+        secret: configService.jwtSecret,
+        signOptions: { expiresIn: '8h' },
+      }),
+    }),
+  ],
+  controllers: [EmailConfirmationController, AuthController],
+  providers: [
+    AuthService,
+    EmailService,
+    JwtStrategy,
+    EmailConfirmationService,
+    PrismaService,
+    UserService,
+  ],
+})
+export class EmailConfirmationModule {}

src/email/confirmation/emailConfirmation.service.ts

@@ -1,5 +1,7 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
+import { Id } from 'src/dtos';
+import { UserService } from 'src/user/user.service';
 import EmailService from '../email.service';
 
 interface VerificationTokenPayload {
@@ -11,6 +13,7 @@ export class EmailConfirmationService {
   constructor(
     private readonly jwtService: JwtService,
     private readonly emailService: EmailService,
+    private readonly usersService: UserService,
   ) {}
 
   public sendVerificationLink(email: string) {
@@ -30,4 +33,38 @@ export class EmailConfirmationService {
       text,
     });
   }
+
+  public async resendConfirmationLink(userId: Id) {
+    const user = await this.usersService.get(userId);
+    if (user.isEmailConfirmed) {
+      throw new BadRequestException('Email already confirmed');
+    }
+    await this.sendVerificationLink(user.email);
+  }
+
+  public async confirmEmail(email: string) {
+    const user = await this.usersService.getByEmail(email);
+    if (user.isEmailConfirmed) {
+      throw new BadRequestException('Email already confirmed');
+    }
+    await this.usersService.markEmailAsConfirmed(email);
+  }
+
+  public async decodeConfirmationToken(token: string) {
+    try {
+      const payload = await this.jwtService.verify(token, {
+        secret: process.env.JWT_VERIFICATION_TOKEN_SECRET,
+      });
+
+      if (typeof payload === 'object' && 'email' in payload) {
+        return payload.email;
+      }
+      throw new BadRequestException();
+    } catch (error) {
+      if (error?.name === 'TokenExpiredError') {
+        throw new BadRequestException('Email confirmation token expired');
+      }
+      throw new BadRequestException('Bad confirmation token');
+    }
+  }
 }

src/email/email.module.ts

@@ -7,6 +7,5 @@ import { PrismaService } from '../prisma.service';
 @Module({
   controllers: [EmailSchedulingController],
   providers: [EmailService, EmailSchedulingService, PrismaService],
-  exports: [EmailService],
 })
 export class EmailModule {}

src/user/user.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
 import { PrismaService } from '../prisma.service';
 import { User, Prisma, File } from '@prisma/client';
 @Injectable()
@@ -101,6 +101,24 @@ export class UserService {
       where: { id: fileId },
     });
   }
+
+  async getByEmail(email: string) {
+    const user = await this.prisma.user.findFirst({ where: { email: email } });
+    if (user) {
+      return user;
+    }
+    throw new HttpException(
+      'User with this email does not exist',
+      HttpStatus.NOT_FOUND,
+    );
+  }
+
+  async markEmailAsConfirmed(email: string) {
+    return this.prisma.user.update({
+      where: { email: email },
+      data: { email: email, isEmailConfirmed: true },
+    });
+  }
 }
 
 //This function takes in latitude and longitude of two location and returns the distance between them as the crow flies (in km)