merged with fix-migration

Author: laxman-aqw

src/analytics/analytics.controller.ts

@@ -10,14 +10,14 @@ import {
 } from '@nestjs/common';
 import { FilterAnalyticsRequestData } from './dto/filter-analytics-request-data';
 import { AnalyticsService } from './analytics.service';
-import { AuthGuard } from 'src/auth/auth.guard';
 import type { RequestWithUser } from 'src/types/RequestWithUser';
+import { GuardService } from 'src/guard/guard.service';
 
 @Controller('analytics')
 export class AnalyticsController {
   constructor(private readonly analyticsService: AnalyticsService) {}
 
-  @UseGuards(AuthGuard)
+  @UseGuards(GuardService)
   @HttpCode(HttpStatus.OK)
   @Get()
   async filterUrlAnalytics(

src/app.module.ts

@@ -9,6 +9,8 @@ import dataSource from './data-source';
 import { ScheduleModule } from '@nestjs/schedule';
 import { CronModule } from './cron/cron.module';
 import { AnalyticsModule } from './analytics/analytics.module';
+import { GuardService } from './guard/guard.service';
+import { GuardModule } from './guard/guard.module';
 import { EventEmitterModule } from '@nestjs/event-emitter';
 
 @Module({
@@ -22,8 +24,9 @@ import { EventEmitterModule } from '@nestjs/event-emitter';
     UrlModule,
     CronModule,
     AnalyticsModule,
+    GuardModule,
   ],
   controllers: [AppController],
-  providers: [],
+  providers: [GuardService],
 })
 export class AppModule {}

src/auth/auth.controller.ts

@@ -10,8 +10,9 @@ import {
 import { AuthService } from './auth.service';
 import { SignupRequestData } from './dto/signup-user-dto';
 
+import { ResendEmailVerificationRequestData } from './dto/resend-verification-dto';
+
 import { LoginRequestData } from './dto/login-user-dto';
-import { ResendVerificationRequestData } from './dto/resend-verification-request-data';
 import { VerifyTokenRequestData } from './dto/verify-token-request-data';
 
 @Controller('auth')
@@ -31,8 +32,13 @@ export class AuthController {
   }
 
   @Post('resend-verification')
-  async reSendVerification(@Body() requestData: ResendVerificationRequestData) {
-    return await this.authService.sendVerificationLink(requestData);
+  async reSendVerification(
+    @Body()
+    resendEmailVerificationRequestData: ResendEmailVerificationRequestData,
+  ) {
+    return await this.authService.sendVerificationLink(
+      resendEmailVerificationRequestData,
+    );
   }
 
   @Get('verify-email')

src/auth/auth.module.ts

@@ -4,15 +4,13 @@ import { AuthController } from './auth.controller';
 import { JwtModule } from '@nestjs/jwt';
 import { CryptoService } from './crypto.service';
 import { EmailModule } from 'src/email/email.module';
-import { AuthGuard } from './auth.guard';
 import { EmailVerification } from './email-verification.entity';
-import { User } from 'src/user/user.entity';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { UserModule } from 'src/user/user.module';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([User, EmailVerification]),
+    TypeOrmModule.forFeature([EmailVerification]),
     EmailModule,
     UserModule,
     JwtModule.register({
@@ -21,8 +19,8 @@ import { UserModule } from 'src/user/user.module';
       signOptions: { expiresIn: '7d' },
     }),
   ],
-  providers: [AuthService, CryptoService, AuthGuard],
+  providers: [AuthService, CryptoService],
   controllers: [AuthController],
-  exports: [AuthService, AuthGuard],
+  exports: [AuthService],
 })
 export class AuthModule {}

src/auth/auth.service.ts

@@ -1,5 +1,6 @@
 import {
   BadRequestException,
+  ConflictException,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
@@ -9,84 +10,62 @@ import { EmailService } from 'src/email/email.service';
 import { CryptoService } from './crypto.service';
 import { LoginRequestData } from './dto/login-user-dto';
 import * as bcrypt from 'bcrypt';
-import { MoreThan, Repository } from 'typeorm';
+import { LessThan, Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 import { EmailVerification } from './email-verification.entity';
 import { EmailVerificationPayload } from './interface';
-import { EmailMessages } from './messages';
 import { JwtPayload } from 'src/types/JwtPayload';
-import { ResendVerificationRequestData } from './dto/resend-verification-request-data';
-import { VerifyTokenRequestData } from './dto/verify-token-request-data';
+import { EmailMessages } from '../config/messages';
+import { ResendEmailVerificationRequestData } from './dto/resend-verification-dto';
 import { SendMailRequestData } from '../email/dto/send-mail-request-data';
-import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';
-import { SendVerificationMailEvent } from 'src/event/send-verification-mail.event';
 import { UserService } from '../user/user.service';
+import { VerifyTokenRequestData } from './dto/verify-token-request-data';
 
 @Injectable()
 export class AuthService {
   constructor(
-    private readonly userService: UserService,
     private readonly jwtService: JwtService,
     private readonly emailService: EmailService,
+    private readonly userService: UserService,
     @InjectRepository(EmailVerification)
     private readonly emailVerificationRepo: Repository<EmailVerification>,
     private readonly cryptoService: CryptoService,
-    private readonly eventEmitter: EventEmitter2,
   ) {}
 
   async signUp(signUpUserDto: SignupRequestData): Promise<{ message: string }> {
-    const existingUser = await this.userService.findByUserNameAndEmail(
-      signUpUserDto.username,
-      signUpUserDto.email,
-    );
-
-    if (existingUser) {
-      if (existingUser.username === signUpUserDto.username) {
-        throw new BadRequestException(EmailMessages.usernameTaken);
-      }
-
-      if (existingUser.email === signUpUserDto.email) {
-        throw new BadRequestException(EmailMessages.emailTaken);
-      }
-    }
-
     const hashedPassword = await this.cryptoService.hashPassword(
       signUpUserDto.password,
     );
 
-    const { email, fullName, username } = signUpUserDto;
-
-    await this.userService.create({
+    const createUserRequestData: SignupRequestData = {
+      ...signUpUserDto,
       password: hashedPassword,
-      email,
-      fullName,
-      username,
-    });
-
-    const resendVerificationRequestData: ResendVerificationRequestData = {
-      email: email,
     };
 
-    const event = new SendVerificationMailEvent(
-      resendVerificationRequestData.email,
-    );
-    this.eventEmitter.emit('send.mail', event);
+    const user = await this.userService.create(createUserRequestData);
 
-    return { message: 'Sign up succesfull. Verification mail has been sent.' };
+    const requestData: ResendEmailVerificationRequestData = {
+      email: user.email,
+    };
+    await this.sendVerificationLink(requestData);
+
+    return {
+      message:
+        'Sign Up successful. Verification mail has been sent. Please verify',
+    };
   }
 
-  @OnEvent('send.mail')
   async sendVerificationLink(
-    resendVerificationRequestData: ResendVerificationRequestData,
+    resendEmailVerificationRequestData: ResendEmailVerificationRequestData,
   ) {
-    const email = resendVerificationRequestData.email;
+    const email = resendEmailVerificationRequestData.email;
     const user = await this.userService.findOneByField('email', email);
     if (!user) {
-      throw new BadRequestException('User not found');
+      throw new NotFoundException('User not found');
     }
 
-    if (user.verifiedAt !== null) {
-      throw new BadRequestException('User is already verified');
+    if (user.verifiedAt) {
+      throw new ConflictException('User is already verified');
     }
 
     await this.emailVerificationRepo.softDelete({
@@ -128,22 +107,19 @@ export class AuthService {
       message: EmailMessages.emailSendSuccess,
     };
   }
+
   async verify(verifyTokenRequestData: VerifyTokenRequestData) {
     const token = verifyTokenRequestData.token;
-
     const payload = this.jwtService.verify<EmailVerificationPayload>(token, {
       secret: process.env.JWT_VERIFICATION_TOKEN_SECRET,
     });
 
     const record = await this.emailVerificationRepo.findOne({
-      where: {
-        token,
-        expiresAt: MoreThan(new Date()),
-      },
+      where: { token, expiresAt: LessThan(new Date()) },
     });
 
     if (!record) {
-      throw new BadRequestException('Token has expired');
+      throw new NotFoundException('Token not found or has expired');
     }
 
     await this.emailVerificationRepo.save(record);
@@ -172,7 +148,7 @@ export class AuthService {
       throw new NotFoundException('User not found');
     }
 
-    if (user.verifiedAt === null) {
+    if (!user.verifiedAt) {
       throw new BadRequestException(
         'User not verified. Please verify before login',
       );
@@ -192,9 +168,9 @@ export class AuthService {
     return { accessToken: await this.jwtService.signAsync(payload) };
   }
 
-  async validateToken(
-    verifyTokenRequestData: VerifyTokenRequestData,
-  ): Promise<JwtPayload> {
+  async validateToken(verifyTokenRequestData: {
+    token: string;
+  }): Promise<JwtPayload> {
     const decoded = await this.jwtService.verifyAsync<JwtPayload>(
       verifyTokenRequestData.token,
       {

src/auth/dto/resend-verification-dto.ts

@@ -0,0 +1,6 @@
+import { IsEmail, IsNotEmpty } from 'class-validator';
+export class ResendEmailVerificationRequestData {
+  @IsEmail()
+  @IsNotEmpty({ message: 'Email is required' })
+  email: string;
+}

src/auth/email-verification.entity.ts

@@ -15,7 +15,7 @@ export class EmailVerification {
   @PrimaryGeneratedColumn('uuid')
   readonly id: string;
 
-  @Column({ name: 'user_id' })
+  @Column({ name: 'user_id', type: 'uuid' })
   readonly userId: string;
 
   @OneToOne(() => User, (user) => user.id, {

src/auth/messages.ts renamed to src/config/messages.ts

@@ -1,43 +1,35 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { Cron, CronExpression } from '@nestjs/schedule';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Url } from 'src/url/url.entity';
-import { IsNull, LessThan, Repository } from 'typeorm';
 import { EmailService } from '../email/email.service';
-import { User } from 'src/user/user.entity';
+import { UserService } from '../user/user.service';
+import { UrlService } from '../url/url.service';
 
 @Injectable()
 export class CheckUrlExpiry {
   constructor(
-    @InjectRepository(Url)
-    private readonly urlRepository: Repository<Url>,
-    @InjectRepository(User)
-    private readonly userRepository: Repository<User>,
     private readonly emailService: EmailService,
+    private readonly urlService: UrlService,
+    private readonly userService: UserService,
   ) {}
 
   @Cron(CronExpression.EVERY_30_SECONDS)
   async checkUrls() {
-    const expiredUrls = await this.urlRepository.find({
-      where: { expiresAt: LessThan(new Date()), expiryAlertedAt: IsNull() },
-    });
+    const expiredUrls = await this.urlService.checkExpiredUrl();
     for (const url of expiredUrls) {
-      const user = await this.userRepository.findOne({
-        where: {
-          id: url.userId,
-        },
-      });
+      const user = await this.userService.findOneByField('id', url.userId);
       if (!user) {
-        return new NotFoundException('User not found');
+        continue; // skip if user not found
       }
+
       await this.emailService.sendMail({
         to: user.email,
         subject: `Your ${url.title} URL has expired`,
-        text: `Hi ${user.fullName} your ${url.title} url has expired!`,
+        text: `Hi ${user.fullName}, your ${url.title} URL has expired!`,
       });
-      await this.urlRepository.save({
+
+      await this.urlService.update(user.id, url.id, {
         ...url,
-        expiryAlertedAt: new Date(Date.now()),
+        expiryAlertedAt: new Date(),
       });
     }
   }

src/cron/check-url-expiry.service.ts

@@ -1,12 +1,11 @@
 import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { Url } from 'src/url/url.entity';
-import { User } from 'src/user/user.entity';
 import { EmailModule } from 'src/email/email.module';
 import { CheckUrlExpiry } from './check-url-expiry.service';
+import { UserModule } from 'src/user/user.module';
+import { UrlModule } from 'src/url/url.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Url, User]), EmailModule],
+  imports: [EmailModule, UserModule, UrlModule],
   controllers: [],
   providers: [CheckUrlExpiry],
   exports: [],