feat: onboarding signup journey

src/auth/auth.module.ts

@@ -3,14 +3,14 @@ import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 import { JuniorModule } from '~/junior/junior.module';
 import { UserModule } from '~/user/user.module';
-import { AuthController } from './controllers';
+import { AuthController, AuthV2Controller } from './controllers';
 import { AuthService, Oauth2Service } from './services';
 import { AccessTokenStrategy } from './strategies';
 
 @Module({
   imports: [JwtModule.register({}), UserModule, JuniorModule, HttpModule],
   providers: [AuthService, AccessTokenStrategy, Oauth2Service],
-  controllers: [AuthController],
+  controllers: [AuthController, AuthV2Controller],
   exports: [],
 })
 export class AuthModule {}

src/auth/controllers/auth.v2.controller.ts

@@ -0,0 +1,24 @@
+import { Body, Controller, Post } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { ResponseFactory } from '~/core/utils';
+import { CreateUnverifiedUserV2RequestDto, VerifyUserV2RequestDto } from '../dtos/request';
+import { LoginResponseDto } from '../dtos/response/login.response.dto';
+import { SendRegisterOtpV2ResponseDto } from '../dtos/response/send-register-otp.v2.response.dto';
+import { AuthService } from '../services';
+
+@Controller('auth/v2')
+@ApiTags('Auth V2')
+export class AuthV2Controller {
+  constructor(private readonly authService: AuthService) {}
+  @Post('register/otp')
+  async register(@Body() createUnverifiedUserDto: CreateUnverifiedUserV2RequestDto) {
+    const phoneNumber = await this.authService.sendPhoneRegisterOtp(createUnverifiedUserDto);
+    return ResponseFactory.data(new SendRegisterOtpV2ResponseDto(phoneNumber));
+  }
+
+  @Post('register/verify')
+  async verifyUser(@Body() verifyUserDto: VerifyUserV2RequestDto) {
+    const [loginResponse, user] = await this.authService.verifyUserV2(verifyUserDto);
+    return ResponseFactory.data(new LoginResponseDto(loginResponse, user));
+  }
+}

src/auth/controllers/index.ts

@@ -1 +1,2 @@
 export * from './auth.controller';
+export * from './auth.v2.controller';

src/auth/dtos/request/create-unverified-user.request.v2.dto.ts

@@ -0,0 +1,4 @@
+import { OmitType } from '@nestjs/swagger';
+import { VerifyUserV2RequestDto } from './verify-user.v2.request.dto';
+
+export class CreateUnverifiedUserV2RequestDto extends OmitType(VerifyUserV2RequestDto, ['otp']) {}

src/auth/dtos/request/index.ts

@@ -1,5 +1,6 @@
 export * from './apple-login.request.dto';
 export * from './create-unverified-user.request.dto';
+export * from './create-unverified-user.request.v2.dto';
 export * from './disable-biometric.request.dto';
 export * from './enable-biometric.request.dto';
 export * from './forget-password.request.dto';
@@ -14,3 +15,4 @@ export * from './set-passcode.request.dto';
 export * from './verify-login-otp.request.dto';
 export * from './verify-otp.request.dto';
 export * from './verify-user.request.dto';
+export * from './verify-user.v2.request.dto';

src/auth/dtos/request/verify-user.v2.request.dto.ts

@@ -0,0 +1,71 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsDateString,
+  IsEmail,
+  IsEnum,
+  IsNotEmpty,
+  IsNumberString,
+  IsOptional,
+  IsString,
+  Matches,
+  MaxLength,
+  MinLength,
+} from 'class-validator';
+import { i18nValidationMessage as i18n } from 'nestjs-i18n';
+import { COUNTRY_CODE_REGEX } from '~/auth/constants';
+import { CountryIso } from '~/common/enums';
+import { DEFAULT_OTP_LENGTH } from '~/common/modules/otp/constants';
+import { IsAbove18, IsValidPhoneNumber } from '~/core/decorators/validations';
+
+export class VerifyUserV2RequestDto {
+  @ApiProperty({ example: '+962' })
+  @Matches(COUNTRY_CODE_REGEX, {
+    message: i18n('validation.Matches', { path: 'general', property: 'auth.countryCode' }),
+  })
+  countryCode!: string;
+
+  @ApiProperty({ example: '787259134' })
+  @IsValidPhoneNumber({
+    message: i18n('validation.IsValidPhoneNumber', { path: 'general', property: 'auth.phoneNumber' }),
+  })
+  phoneNumber!: string;
+  @ApiProperty({ example: 'John' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.firstName' }) })
+  @IsNotEmpty({ message: i18n('validation.IsNotEmpty', { path: 'general', property: 'customer.firstName' }) })
+  firstName!: string;
+
+  @ApiProperty({ example: 'Doe' })
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'customer.lastName' }) })
+  @IsNotEmpty({ message: i18n('validation.IsNotEmpty', { path: 'general', property: 'customer.lastName' }) })
+  lastName!: string;
+
+  @ApiProperty({ example: '2021-01-01' })
+  @IsDateString({}, { message: i18n('validation.IsDateString', { path: 'general', property: 'customer.dateOfBirth' }) })
+  @IsAbove18({ message: i18n('validation.IsAbove18', { path: 'general', property: 'customer.dateOfBirth' }) })
+  dateOfBirth!: Date;
+
+  @ApiProperty({ example: 'JO' })
+  @IsEnum(CountryIso, {
+    message: i18n('validation.IsEnum', { path: 'general', property: 'customer.countryOfResidence' }),
+  })
+  @IsOptional()
+  countryOfResidence: CountryIso = CountryIso.SAUDI_ARABIA;
+
+  @ApiProperty({ example: '[email protected]' })
+  @IsEmail({}, { message: i18n('validation.IsEmail', { path: 'general', property: 'auth.email' }) })
+  @IsOptional()
+  email!: string;
+
+  @ApiProperty({ example: '111111' })
+  @IsNumberString(
+    { no_symbols: true },
+    { message: i18n('validation.IsNumberString', { path: 'general', property: 'auth.otp' }) },
+  )
+  @MaxLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MaxLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  @MinLength(DEFAULT_OTP_LENGTH, {
+    message: i18n('validation.MinLength', { path: 'general', property: 'auth.otp', length: DEFAULT_OTP_LENGTH }),
+  })
+  otp!: string;
+}

src/auth/dtos/response/send-register-otp.v2.response.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class SendRegisterOtpV2ResponseDto {
+  @ApiProperty()
+  maskedNumber!: string;
+
+  constructor(maskedNumber: string) {
+    this.maskedNumber = maskedNumber;
+  }
+}

src/auth/services/auth.service.ts

@@ -14,6 +14,7 @@ import { PASSCODE_REGEX } from '../constants';
 import {
   AppleLoginRequestDto,
   CreateUnverifiedUserRequestDto,
+  CreateUnverifiedUserV2RequestDto,
   DisableBiometricRequestDto,
   EnableBiometricRequestDto,
   ForgetPasswordRequestDto,
@@ -25,6 +26,7 @@ import {
   setJuniorPasswordRequestDto,
   VerifyLoginOtpRequestDto,
   VerifyUserRequestDto,
+  VerifyUserV2RequestDto,
 } from '../dtos/request';
 import { Roles } from '../enums';
 import { IJwtPayload, ILoginResponse } from '../interfaces';
@@ -59,6 +61,25 @@ export class AuthService {
     });
   }
 
+  async sendPhoneRegisterOtp(body: CreateUnverifiedUserV2RequestDto) {
+    if (body.email) {
+      const isEmailUsed = await this.userService.findUser({ email: body.email, isEmailVerified: true });
+      if (isEmailUsed) {
+        this.logger.error(`Email ${body.email} is already used`);
+        throw new BadRequestException('USER.EMAIL_ALREADY_TAKEN');
+      }
+    }
+
+    this.logger.log(`Sending OTP to ${body.countryCode + body.phoneNumber}`);
+    const user = await this.userService.findOrCreateByPhoneNumber(body);
+    return this.otpService.generateAndSendOtp({
+      userId: user.id,
+      recipient: user.fullPhoneNumber,
+      scope: OtpScope.VERIFY_PHONE,
+      otpType: OtpType.SMS,
+    });
+  }
+
   async verifyUser(verifyUserDto: VerifyUserRequestDto): Promise<[ILoginResponse, User]> {
     this.logger.log(`Verifying user with email ${verifyUserDto.email}`);
     const user = await this.userService.findUserOrThrow({ email: verifyUserDto.email });
@@ -89,6 +110,39 @@ export class AuthService {
     return [tokens, user];
   }
 
+  async verifyUserV2(verifyUserDto: VerifyUserV2RequestDto): Promise<[ILoginResponse, User]> {
+    this.logger.log(`Verifying user with phone number ${verifyUserDto.countryCode + verifyUserDto.phoneNumber}`);
+    const user = await this.userService.findUserOrThrow({
+      phoneNumber: verifyUserDto.phoneNumber,
+      countryCode: verifyUserDto.countryCode,
+    });
+
+    if (user.isPhoneVerified) {
+      this.logger.error(`User with phone number ${user.fullPhoneNumber} already verified`);
+      throw new BadRequestException('USER.PHONE_NUMBER_ALREADY_VERIFIED');
+    }
+
+    const isOtpValid = await this.otpService.verifyOtp({
+      userId: user.id,
+      scope: OtpScope.VERIFY_PHONE,
+      otpType: OtpType.SMS,
+      value: verifyUserDto.otp,
+    });
+
+    if (!isOtpValid) {
+      this.logger.error(`Invalid OTP for user with phone number ${user.fullPhoneNumber}`);
+      throw new BadRequestException('OTP.INVALID_OTP');
+    }
+
+    await this.userService.verifyUserV2(user.id, verifyUserDto);
+
+    await user.reload();
+
+    const tokens = await this.generateAuthToken(user);
+    this.logger.log(`User with phone number ${user.fullPhoneNumber} verified successfully`);
+    return [tokens, user];
+  }
+
   async setEmail(userId: string, { email }: SetEmailRequestDto) {
     this.logger.log(`Setting email for user with id ${userId}`);
     const user = await this.userService.findUserOrThrow({ id: userId });