[PB-2153] feat: remove password prompt in security section

src/modules/folder/folder.usecase.spec.ts

@@ -503,6 +503,8 @@ describe('FolderUseCases', () => {
         },
       });
 
+      jest.spyOn(cryptoService, 'decryptName').mockReturnValueOnce('');
+
       expect(() => service.decryptFolderName(folder)).toThrow(
         'Unable to decrypt folder name',
       );

src/modules/user/dto/update-password.dto.ts

@@ -2,13 +2,6 @@ import { ApiProperty } from '@nestjs/swagger';
 import { IsString } from 'class-validator';
 
 export class UpdatePasswordDto {
-  @IsString()
-  @ApiProperty({
-    example: 'currentPassword',
-    description: 'Current password',
-  })
-  currentPassword: string;
-
   @IsString()
   @ApiProperty({
     example: 'newPassword',

src/modules/user/user.controller.spec.ts

@@ -2,11 +2,16 @@ import { DeepMocked, createMock } from '@golevelup/ts-jest';
 import {
   ForbiddenException,
   InternalServerErrorException,
+  NotFoundException,
   UnauthorizedException,
 } from '@nestjs/common';
 import getEnv from '../../config/configuration';
 import { UserController } from './user.controller';
-import { MailLimitReachedException, UserUseCases } from './user.usecase';
+import {
+  KeyServerNotFoundError,
+  MailLimitReachedException,
+  UserUseCases,
+} from './user.usecase';
 import { NotificationService } from '../../externals/notifications/notification.service';
 import { KeyServerUseCases } from '../keyserver/key-server.usecase';
 import { CryptoService } from '../../externals/crypto/crypto.service';
@@ -205,4 +210,58 @@ describe('User Controller', () => {
       ).resolves.toBeUndefined();
     });
   });
+
+  describe('PATCH /password', () => {
+    const user = newUser();
+    const payload = {
+      newPassword: v4(),
+      newSalt: v4(),
+      mnemonic: v4(),
+      privateKey: v4(),
+      encryptVersion: null,
+    };
+    const mockTokens = {
+      newToken: v4(),
+      token: v4(),
+    };
+
+    it('When a new password is updated it should return the new tokens', async () => {
+      userUseCases.updatePassword.mockResolvedValueOnce();
+      userUseCases.getAuthTokens.mockReturnValueOnce(mockTokens);
+
+      await expect(
+        userController.updatePassword(payload, user),
+      ).resolves.toStrictEqual({ status: 'success', ...mockTokens });
+    });
+
+    it('should throw an error if password update fails', async () => {
+      userUseCases.updatePassword.mockRejectedValueOnce(
+        new UnauthorizedException(),
+      );
+
+      await expect(
+        userController.updatePassword(payload, user),
+      ).rejects.toThrow(UnauthorizedException);
+    });
+
+    it('should throw an error if password update fails', async () => {
+      userUseCases.updatePassword.mockRejectedValueOnce(
+        new KeyServerNotFoundError(),
+      );
+
+      await expect(
+        userController.updatePassword(payload, user),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('should throw an error if fails', async () => {
+      userUseCases.updatePassword.mockRejectedValueOnce(
+        new InternalServerErrorException(),
+      );
+
+      await expect(
+        userController.updatePassword(payload, user),
+      ).rejects.toThrow(InternalServerErrorException);
+    });
+  });
 });

src/modules/user/user.controller.ts

@@ -423,28 +423,18 @@ export class UserController {
   @Patch('password')
   @ApiBearerAuth()
   async updatePassword(
-    @RequestDecorator() req,
     @Body() updatePasswordDto: UpdatePasswordDto,
-    @Res({ passthrough: true }) res: Response,
     @UserDecorator() user: User,
   ) {
     try {
-      const currentPassword = this.cryptoService.decryptText(
-        updatePasswordDto.currentPassword,
-      );
       const newPassword = this.cryptoService.decryptText(
         updatePasswordDto.newPassword,
       );
       const newSalt = this.cryptoService.decryptText(updatePasswordDto.newSalt);
 
       const { mnemonic, privateKey, encryptVersion } = updatePasswordDto;
 
-      if (user.password.toString() !== currentPassword) {
-        throw new UnauthorizedException();
-      }
-
-      await this.userUseCases.updatePassword(req.user, {
-        currentPassword,
+      await this.userUseCases.updatePassword(user, {
         newPassword,
         newSalt,
         mnemonic,
@@ -459,12 +449,10 @@ export class UserController {
 
       return { status: 'success', newToken, token };
     } catch (err) {
-      let errorMessage = err.message;
-
       if (err instanceof UnauthorizedException) {
-        res.status(HttpStatus.BAD_REQUEST);
+        throw new UnauthorizedException();
       } else if (err instanceof KeyServerNotFoundError) {
-        res.status(HttpStatus.NOT_FOUND);
+        throw new NotFoundException();
       } else {
         new Logger().error(
           `[AUTH/UPDATEPASSWORD] ERROR: ${
@@ -473,11 +461,8 @@ export class UserController {
             (err as Error).stack
           }`,
         );
-        res.status(HttpStatus.INTERNAL_SERVER_ERROR);
-        errorMessage = 'Internal Server Error';
+        throw new InternalServerErrorException();
       }
-
-      return { error: errorMessage };
     }
   }