chore(api): refactoring

Fixes #49

Author: akdasa

modules/services/api/src/auth/auth.module.ts

@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { RedisService } from '@vidya/api/shared/services';
 import { Role, User, UserRole } from '@vidya/entities';
 
 import { OtpController } from './controllers/otp.controller';
@@ -24,6 +25,7 @@ import { RevokedTokensService } from './services/revokedTokens.service';
     AuthService,
     RevokedTokensService,
     AuthRolesMappingProfile,
+    RedisService,
   ],
 })
 export class AuthModule {}

modules/services/api/src/auth/controllers/user-authentication.controller.ts

@@ -16,17 +16,19 @@ import {
   ApiTooManyRequestsResponse,
   ApiUnauthorizedResponse,
 } from '@nestjs/swagger';
-import { UserAccessToken } from '@vidya/api/auth/decorators';
 import * as dto from '@vidya/api/auth/dto';
-import { AuthenticatedUser } from '@vidya/api/auth/guards';
+import { AuthenticatedUserGuard } from '@vidya/api/auth/guards';
 import {
   AuthService,
   AuthUsersService,
   OtpService,
   RevokedTokensService,
 } from '@vidya/api/auth/services';
 import { AuthConfig } from '@vidya/api/configs';
-import { JwtToken, OtpType, Routes } from '@vidya/protocol';
+import { OtpType, Routes } from '@vidya/protocol';
+
+import { Authentication } from '../decorators';
+import { UserAuthentication } from '../utils';
 
 @Controller()
 @ApiTags('🔐 Authentication')
@@ -102,7 +104,7 @@ export class UserAuthenticationController {
   /* -------------------------------------------------------------------------- */
 
   @Post(Routes().auth.signOut())
-  @UseGuards(AuthenticatedUser)
+  @UseGuards(AuthenticatedUserGuard)
   @ApiBearerAuth()
   @ApiOperation({
     summary: 'Signs user out',
@@ -125,10 +127,10 @@ export class UserAuthenticationController {
   })
   async logoutUser(
     @Body() request: dto.SignOutRequest,
-    @UserAccessToken() userAccessToken: JwtToken,
+    @Authentication() auth: UserAuthentication,
   ): Promise<dto.SignOutResponse> {
     // revoke access token to prevent reusing it
-    await this.revokedTokensService.revoke(userAccessToken);
+    await this.revokedTokensService.revoke(auth.accessToken);
 
     // revoke refresh token if still valid
     const token = await this.authService.verifyToken(request.refreshToken);

modules/services/api/src/auth/decorators/authentication.decorator.ts

@@ -0,0 +1,10 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { UserAuthentication, VidyaRequest } from '@vidya/api/auth/utils';
+
+export const Authentication = createParamDecorator(
+  (data, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest<VidyaRequest>();
+    const accessToken = request.accessToken;
+    return new UserAuthentication(accessToken);
+  },
+);

modules/services/api/src/auth/decorators/index.ts

@@ -1,2 +1 @@
-export * from './user-id.decorator';
-export * from './user-permissions.decorator';
+export * from './authentication.decorator';

modules/services/api/src/auth/decorators/user-id.decorator.ts

@@ -16,7 +16,7 @@ import { JwtConfig } from '@vidya/api/configs';
 import { AccessToken } from '@vidya/protocol';
 
 @Injectable()
-export class AuthenticatedUser implements CanActivate {
+export class AuthenticatedUserGuard implements CanActivate {
   constructor(
     @Inject(JwtConfig.KEY)
     private readonly jwtConfig: ConfigType<typeof JwtConfig>,

modules/services/api/src/auth/decorators/user-permissions.decorator.ts

@@ -4,18 +4,17 @@ import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
 import { InjectRepository } from '@nestjs/typeorm';
 import * as dto from '@vidya/api/auth/dto';
-import { AuthConfig, RedisConfig } from '@vidya/api/configs';
+import { AuthConfig } from '@vidya/api/configs';
+import { RedisService } from '@vidya/api/shared/services';
 import { Role, User } from '@vidya/entities';
 import * as entities from '@vidya/entities';
 import { UserPermission, UserPermissionsStorageKey } from '@vidya/protocol';
-import Redis from 'ioredis';
 import { Repository } from 'typeorm';
 
 export type LoginField = 'email' | 'phone';
 
 @Injectable()
 export class AuthUsersService {
-  private readonly redis: Redis;
   private readonly logger = new Logger(AuthUsersService.name);
 
   /**
@@ -25,19 +24,13 @@ export class AuthUsersService {
    * @param mapper Mapper instance
    */
   constructor(
+    private readonly redis: RedisService,
     @InjectRepository(User) private readonly users: Repository<User>,
     @InjectRepository(Role) private readonly roles: Repository<Role>,
     @InjectMapper() private readonly mapper: Mapper,
-    @Inject(RedisConfig.KEY)
-    private readonly redisConfig: ConfigType<typeof RedisConfig>,
     @Inject(AuthConfig.KEY)
     private readonly authConfig: ConfigType<typeof AuthConfig>,
-  ) {
-    this.redis = new Redis({
-      host: redisConfig.host,
-      port: redisConfig.port,
-    });
-  }
+  ) {}
 
   /**
    * Finds a user by id.
@@ -113,7 +106,6 @@ export class AuthUsersService {
         await this.redis.set(
           UserPermissionsStorageKey(userId),
           JSON.stringify(permissions),
-          'EX',
           this.authConfig.userPermissionsCacheTtl,
         );
       }

modules/services/api/src/auth/guards/authenticated-user.guard.ts

@@ -1,32 +1,24 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
-import { OtpConfig, RedisConfig } from '@vidya/api/configs';
+import { OtpConfig } from '@vidya/api/configs';
+import { RedisService } from '@vidya/api/shared/services';
 import { Otp, OtpStorageKey, OtpType } from '@vidya/protocol';
-import { Redis } from 'ioredis';
 
 /**
  * Service for generating and validating one-time passwords (OTPs) using Redis.
  */
 @Injectable()
 export class OtpService {
-  private readonly client: Redis;
-
   /**
    * Constructs an instance of the OTP service.
    *
    * @param redisConfig - The configuration for connecting to the Redis server.
    */
   constructor(
-    @Inject(RedisConfig.KEY)
-    private readonly redisConfig: ConfigType<typeof RedisConfig>,
+    private readonly redis: RedisService,
     @Inject(OtpConfig.KEY)
     private readonly otpConfig: ConfigType<typeof OtpConfig>,
-  ) {
-    this.client = new Redis({
-      host: redisConfig.host,
-      port: redisConfig.port,
-    });
-  }
+  ) {}
 
   /**
    * Generates a one-time password for the given login and type.
@@ -40,7 +32,7 @@ export class OtpService {
       code: this.generateCode(),
       type: type,
     };
-    await this.client.set(OtpStorageKey(login), JSON.stringify(otp), 'EX', 300);
+    await this.redis.set(OtpStorageKey(login), JSON.stringify(otp), 300);
     return otp;
   }
 
@@ -52,7 +44,7 @@ export class OtpService {
    */
   async isExpired(login: string): Promise<boolean> {
     const key = OtpStorageKey(login);
-    return !(await this.client.exists(key));
+    return !(await this.redis.exists(key));
   }
 
   /**
@@ -69,13 +61,13 @@ export class OtpService {
    */
   async validate(login: string, code: string): Promise<Otp | undefined> {
     const key = OtpStorageKey(login);
-    const stored: Otp = JSON.parse(await this.client.get(key));
+    const stored: Otp = JSON.parse(await this.redis.get(key));
     if (!stored) return undefined;
 
     // if code is correct, expire it immediately
     // to prevent replay attacks and multiple logins
     if (code === stored.code) {
-      await this.client.expire(key, 0);
+      await this.redis.del(key);
       return stored;
     }
 

modules/services/api/src/auth/services/auth-users.service.ts

@@ -1,28 +1,16 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { ConfigType } from '@nestjs/config';
-import RedisConfig from '@vidya/api/configs/redis.config';
+import { Injectable } from '@nestjs/common';
+import { RedisService } from '@vidya/api/shared/services';
 import { RevokedTokenStorageKey } from '@vidya/protocol';
 import { JwtToken } from '@vidya/protocol';
-import { Redis } from 'ioredis';
 
 @Injectable()
 export class RevokedTokensService {
-  private readonly client: Redis;
-
   /**
    * Constructs an instance of the service with the provided Redis configuration.
    *
    * @param redisConfig The configuration object for Redis
    */
-  constructor(
-    @Inject(RedisConfig.KEY)
-    private readonly redisConfig: ConfigType<typeof RedisConfig>,
-  ) {
-    this.client = new Redis({
-      host: redisConfig.host,
-      port: redisConfig.port,
-    });
-  }
+  constructor(private readonly redis: RedisService) {}
 
   /**
    * Checks if the given JWT token has been revoked.
@@ -31,7 +19,7 @@ export class RevokedTokensService {
    * @returns A promise that resolves to a boolean indicating whether the token is revoked.
    */
   async isRevoked(token: JwtToken): Promise<boolean> {
-    return (await this.client.exists(RevokedTokenStorageKey(token))) === 1;
+    return await this.redis.exists(RevokedTokenStorageKey(token));
   }
 
   /**
@@ -41,10 +29,9 @@ export class RevokedTokensService {
    * @returns A promise that resolves when the token has been successfully revoked.
    */
   async revoke(token: JwtToken): Promise<void> {
-    await this.client.set(
+    await this.redis.set(
       RevokedTokenStorageKey(token),
       'revoked',
-      'EX',
       token.exp - token.iat,
     );
   }