Add Arkesel phone verification library

Author: adzamkomladev

apps/main-service/src/app/@common/modules/global.module.ts

@@ -32,6 +32,7 @@ import { Match } from '../validators/match.validator';
       useFactory: () =>
         ({
           ...environment.database,
+          logging: true,
         } as TypeOrmModuleOptions),
     }),
     CacheModule.register<ClientOpts>({

apps/main-service/src/app/users/entities/user.entity.ts

@@ -24,6 +24,9 @@ export class User {
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
+  @Column({ nullable: true })
+  profileId: number;
+
   @Field({ description: 'User Profile' })
   @OneToOne(() => Profile, (profile) => profile.user)
   @JoinColumn()

apps/main-service/src/app/verification/dto/send-otp.input.ts

@@ -0,0 +1,15 @@
+import { InputType, Field } from '@nestjs/graphql';
+
+import { IsEnum, IsNotEmpty } from 'class-validator';
+
+import { OtpType } from '../enums/otp-type.enum';
+
+@InputType()
+export class SendOtpInput {
+  @Field(() => OtpType, {
+    description: 'Type of medium the otp code is going to be sent via',
+  })
+  @IsNotEmpty()
+  @IsEnum(OtpType)
+  readonly type: OtpType;
+}

apps/main-service/src/app/verification/entities/verification.entity.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ProfileResolver } from './profile.resolver';
+
+describe('ProfileResolver', () => {
+  let resolver: ProfileResolver;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ProfileResolver],
+    }).compile();
+
+    resolver = module.get<ProfileResolver>(ProfileResolver);
+  });
+
+  it('should be defined', () => {
+    expect(resolver).toBeDefined();
+  });
+});

apps/main-service/src/app/verification/resolvers/profile.resolver.spec.ts

@@ -0,0 +1,16 @@
+import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+
+import { Profile } from '../../users/entities/profile.entity';
+import { User } from '../../users/entities/user.entity';
+
+import { ProfileService } from '../services/profile.service';
+
+@Resolver(() => Profile)
+export class ProfileResolver {
+  constructor(private readonly profileService: ProfileService) {}
+
+  @ResolveField('profile', () => Profile)
+  profile(@Parent() user: User) {
+    return this.profileService.findProfileById(user.profileId);
+  }
+}

apps/main-service/src/app/verification/resolvers/profile.resolver.ts

@@ -1,6 +1,6 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { VerificationResolver } from './verification.resolver';
-import { VerificationService } from './verification.service';
+import { VerificationService } from '../services/verification.service';
 
 describe('VerificationResolver', () => {
   let resolver: VerificationResolver;

apps/main-service/src/app/verification/verification.resolver.spec.ts apps/main-service/src/app/verification/resolvers/verification.resolver.spec.ts

@@ -0,0 +1,56 @@
+import { Resolver, Mutation, Args } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+
+import { User } from '../../users/entities/user.entity';
+
+import { VerifyEmailViaOtpInput } from '../dto/verify-email-via-otp.input';
+import { VerifyPhoneViaOtpInput } from '../dto/verify-phone-via-otp.input';
+
+import { CurrentUser } from '../../@common/decorators/current-user.decorator';
+
+import { GqlAuthGuard } from '../../@common/guards/gql-auth.guard';
+
+import { VerificationService } from '../services/verification.service';
+import { SendOtpInput } from '../dto/send-otp.input';
+
+@Resolver()
+@UseGuards(GqlAuthGuard)
+export class VerificationResolver {
+  constructor(private readonly verificationService: VerificationService) {}
+
+  @Mutation(() => User, { name: 'verifyEmailViaOtp' })
+  verifyEmailViaOtp(
+    @CurrentUser() user: User,
+    @Args('verifyEmailViaOtpInput')
+    verifyEmailViaOtpInput: VerifyEmailViaOtpInput
+  ) {
+    return this.verificationService.verifyEmailViaOtp(
+      verifyEmailViaOtpInput,
+      user
+    );
+  }
+
+  @Mutation(() => User, { name: 'verifyPhoneViaOtp' })
+  verifyPhoneViaOtp(
+    @CurrentUser() user: User,
+    @Args('verifyPhoneViaOtpInput')
+    verifyPhoneViaOtpInput: VerifyPhoneViaOtpInput
+  ) {
+    return this.verificationService.verifyPhoneViaOtp(
+      verifyPhoneViaOtpInput,
+      user
+    );
+  }
+
+  @Mutation(() => User, { name: 'sendOtpForPhoneVerification' })
+  sendOtpForPhoneVerification(
+    @CurrentUser() user: User,
+    @Args('sendOtpInput')
+    sendOtpInput: SendOtpInput
+  ) {
+    return this.verificationService.sendOtpForPhoneVerification(
+      sendOtpInput,
+      user
+    );
+  }
+}

apps/main-service/src/app/verification/resolvers/verification.resolver.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ProfileService } from './profile.service';
+
+describe('ProfileService', () => {
+  let service: ProfileService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ProfileService],
+    }).compile();
+
+    service = module.get<ProfileService>(ProfileService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

apps/main-service/src/app/verification/services/profile.service.spec.ts

@@ -0,0 +1,26 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import { Profile } from '../../users/entities/profile.entity';
+
+@Injectable()
+export class ProfileService {
+  constructor(
+    @InjectRepository(Profile)
+    private readonly profileRepository: Repository<Profile>
+  ) {}
+
+  async findProfileById(id: number) {
+    try {
+      return await this.profileRepository.findOneOrFail({
+        where: {
+          id,
+        },
+      });
+    } catch (e) {
+      throw new NotFoundException('Profile not found!');
+    }
+  }
+}

apps/main-service/src/app/verification/services/profile.service.ts

@@ -10,18 +10,23 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Cache } from 'cache-manager';
 import { Repository } from 'typeorm';
 
-import { User } from '../users/entities/user.entity';
-import { UserVerification } from './entities/user-verification.entity';
+import { User } from '../../users/entities/user.entity';
+import { UserVerification } from '../entities/user-verification.entity';
 
-import { VerifyEmailViaOtpInput } from './dto/verify-email-via-otp.input';
-import { VerifyPhoneViaOtpInput } from './dto/verify-phone-via-otp.input';
+import { VerifyEmailViaOtpInput } from '../dto/verify-email-via-otp.input';
+import { VerifyPhoneViaOtpInput } from '../dto/verify-phone-via-otp.input';
+import { PhoneVerificationService } from '@laze/nestjs-phone-verification';
+import { SendOtpInput } from '../dto/send-otp.input';
+import { OtpType } from '../enums/otp-type.enum';
+import { environment } from '../../../environments/environment';
 
 @Injectable()
 export class VerificationService {
   private readonly logger: Logger;
 
   constructor(
     @Inject(CACHE_MANAGER) private readonly cache: Cache,
+    private readonly phoneVerificationService: PhoneVerificationService,
     @InjectRepository(UserVerification)
     private readonly userVerificationRepository: Repository<UserVerification>,
     @InjectRepository(User)
@@ -72,12 +77,15 @@ export class VerificationService {
     verifyPhoneViaOtpInput: VerifyPhoneViaOtpInput,
     user: User
   ) {
-    const { code, type } = verifyPhoneViaOtpInput;
-    const key = `users.${user.id}.otp.${type}`;
+    const { code } = verifyPhoneViaOtpInput;
 
-    const otp = await this.cache.get<string>(key);
+    const res = await this.phoneVerificationService.verifyCode({
+      code,
+      number: user.phone,
+    });
 
-    if (otp !== code) {
+    if (!res.success) {
+      this.logger.error(res);
       throw new BadRequestException('OTP Code is not valid!');
     }
 
@@ -96,13 +104,35 @@ export class VerificationService {
 
       fullUser.verification = verification;
 
-      await this.cache.del(key);
-
       return fullUser;
     } catch (e) {
       this.logger.error(e.message, e);
 
       throw new BadRequestException('Failed to verify phone via otp!');
     }
   }
+
+  async sendOtpForPhoneVerification(sendOtpInput: SendOtpInput, user: User) {
+    const { type } = sendOtpInput;
+
+    const res = await this.phoneVerificationService.sendCode({
+      number: user.phone,
+      medium: type === OtpType.SMS ? 'sms' : 'voice',
+      message: `Your ${environment.app.name} phone number verification code is %otp_code%. Do not share this code with anyone. Visit your ${environment.app.name} account now to verify.`,
+    });
+
+    if (!res.success) {
+      this.logger.error(res);
+      throw new BadRequestException(
+        'Failed to send OTP code. Please try again later!'
+      );
+    }
+
+    return await this.userRepository.findOneOrFail({
+      where: {
+        id: user.id,
+      },
+      relations: ['profile', 'verification'],
+    });
+  }
 }

apps/main-service/src/app/verification/verification.service.spec.ts apps/main-service/src/app/verification/services/verification.service.spec.ts

@@ -1,17 +1,30 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 
+import { SharedDataAccessPhoneVerificationModule } from '@laze/nestjs-phone-verification';
+
 import { UsersModule } from '../users/users.module';
 
 import { UserVerification } from './entities/user-verification.entity';
 
-import { VerificationService } from './verification.service';
+import { VerificationService } from './services/verification.service';
+// import { ProfileService } from './services/profile.service';
 
-import { VerificationResolver } from './verification.resolver';
+import { VerificationResolver } from './resolvers/verification.resolver';
+// import { ProfileResolver } from './resolvers/profile.resolver';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([UserVerification]), UsersModule],
-  providers: [VerificationResolver, VerificationService],
+  imports: [
+    SharedDataAccessPhoneVerificationModule,
+    TypeOrmModule.forFeature([UserVerification]),
+    UsersModule,
+  ],
+  providers: [
+    VerificationResolver,
+    VerificationService,
+    // ProfileResolver,
+    // ProfileService,
+  ],
   exports: [TypeOrmModule],
 })
 export class VerificationModule {}

apps/main-service/src/app/verification/verification.service.ts apps/main-service/src/app/verification/services/verification.service.ts

@@ -0,0 +1,18 @@
+{
+  "extends": ["../../../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

apps/main-service/src/app/verification/verification.module.ts

@@ -0,0 +1,7 @@
+# shared-data-access-arkesel
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test shared-data-access-arkesel` to execute the unit tests via [Jest](https://jestjs.io).

apps/main-service/src/app/verification/verification.resolver.ts

@@ -0,0 +1,16 @@
+/* eslint-disable */
+export default {
+  displayName: 'shared-data-access-arkesel',
+  preset: '../../../../jest.preset.js',
+  globals: {
+    'ts-jest': {
+      tsconfig: '<rootDir>/tsconfig.spec.json',
+    },
+  },
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': 'ts-jest',
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../../../coverage/libs/shared/data-access/arkesel',
+};