Implement: update user password feature

Add validation and checks for Data Transfor Object
properties' values and types

Check business coherence before updating user's
password

Refactor call for database query to retrieve user role by
centralising it in the services folder

Add update user password feature tests and separate them
by semantic, both in the feature folder and in the tests
folder

Implement customised error codes for update user password
feature

Author: Idan

.github/workflows/docker-image.yml

@@ -2,9 +2,9 @@ name: Docker Compose CI
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "feature/update-user-password" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "feature/update-user-password" ]
   workflow_dispatch:
 
 jobs:

app.ts

@@ -3,12 +3,14 @@ import { RegisterUserRouter } from "./features/RegisterUser/RegisterUserMain/rou
 import { AuthenticateUserRouter } from './features/AuthenticateUser/AuthenticateUserMain/router';
 import { RetrieveUserRouter } from './features/RetrieveUser/RetrieveUserMain/router';
 import { UpdateUserInformationRouter } from './features/UpdateUserInformation/UpdateUserInformationMain/router';
+import { UpdateUserPasswordRouter } from './features/UpdateUserPassword/UpdateUserPasswordMain/router';
 
 const app: Express = express();
 
 app.use("/user", RegisterUserRouter);
 app.use("/user", RetrieveUserRouter);
 app.use("/user", UpdateUserInformationRouter);
+app.use("/user", UpdateUserPasswordRouter);
 app.use("/login", AuthenticateUserRouter);
 
 export { app };

features/AuthenticateUser/AuthenticateUserMain/router.ts

@@ -49,7 +49,7 @@ AuthenticateUserRouter.post("/", jsonParser, async (request: Request, response:
                 })
             });
         } else {
-            response.status(500)
+            response.status(401)
             .json("Couldn't log in");
         }
 

features/UpdateUserInformation/UpdateUserInformationMain/database/UserInformationUpdateOnPostgreSQLDatabase.ts

@@ -48,21 +48,6 @@ export default class UserInformationUpdateOnPostgreSQLDatabase implements Update
 
     public async getUserRole(userId: string): Promise<string|false>
     {
-        const queryResult: QueryResult|undefined = await this.postgreSQLDatabase.query(
-            "SELECT role FROM application_users WHERE id = $1",
-            [userId]
-        );
-
-        if (queryResult !== undefined && queryResult.rowCount !== null && queryResult.rowCount > 0) {
-            switch(queryResult.rows[0].role) {
-                case "USER_ROLE":
-                    return "User";
-                
-                default:
-                    return false;
-            }
-        } else {
-            return false;
-        }
+        return await this.postgreSQLDatabase.getUserRole(userId);
     }
 }

features/UpdateUserInformation/UpdateUserInformationMain/router.ts

@@ -3,29 +3,29 @@ import type { Request, Response, Router } from "express";
 import bodyParser from "body-parser";
 import type { NextHandleFunction } from "connect";
 
-import UpdateUserInformationAuthenticationMiddleware from "./middleware/UpdateUserInformationAuthenticationMiddleware";
 import UserInformationUpdateOnPostgreSQLDatabase from "./database/UserInformationUpdateOnPostgreSQLDatabase";
 import UpdateUserInformationInputJoiValidation from "./validation/UpdateUserInformationInputJoiValidation";
 import UpdateUserInformationRequest from "../UpdateUserInformationController/UpdateUserInformationRequest";
 import UpdateUserInformationController from "../UpdateUserInformationController/UpdateUserInformationController";
 import UpdateUserInformationResponse from "../UpdateUserInformationController/UpdateUserInformationResponse";
 
+import AuthenticationMiddleware from "../../../services/middleware/AuthenticationMiddleware";
+
 import BadRequestError from "../../../services/errors/BadRequestError";
 import UnauthorisedActionError from "../../../services/errors/UnauthorisedActionError";
 
-
 const UpdateUserInformationRouter: Router = express.Router();
 const jsonParser: NextHandleFunction = bodyParser.json();
 
-UpdateUserInformationRouter.put("/", jsonParser, UpdateUserInformationAuthenticationMiddleware, async (request: Request, response: Response) => {
+UpdateUserInformationRouter.put("/", jsonParser, AuthenticationMiddleware, async (request: Request, response: Response) => {
     const userInformationUpdateOnPostgreSQLDatabase: UserInformationUpdateOnPostgreSQLDatabase = new UserInformationUpdateOnPostgreSQLDatabase();
 
     try {
         const updateUserInformationInputJoiValidation: UpdateUserInformationInputJoiValidation = new UpdateUserInformationInputJoiValidation();
 
         await userInformationUpdateOnPostgreSQLDatabase.connect();
 
-        const updateUserInformationRequest = composeRetrieveUserRequest(request.body, request.params.userId);
+        const updateUserInformationRequest = composeUpdateUserInformationRequest(request.body, request.params.userId);
 
         const updateUserInformationController: UpdateUserInformationController = new UpdateUserInformationController();
         const updateUserInformationResponse: UpdateUserInformationResponse = await updateUserInformationController.handleUpdateUserInformationRequest(updateUserInformationRequest, userInformationUpdateOnPostgreSQLDatabase, updateUserInformationInputJoiValidation);
@@ -53,7 +53,7 @@ UpdateUserInformationRouter.put("/", jsonParser, UpdateUserInformationAuthentica
     }
 });
 
-const composeRetrieveUserRequest = (requestBody: any, userId: string): UpdateUserInformationRequest => {
+const composeUpdateUserInformationRequest = (requestBody: any, userId: string): UpdateUserInformationRequest => {
     const updateUserInformationRequest = new UpdateUserInformationRequest();
     updateUserInformationRequest.setUserId(userId)
     .setUpdatedUserId(requestBody.updatedUserId)

features/UpdateUserPassword/UpdateUserPasswordController/UpdateUserPasswordController.ts

@@ -0,0 +1,43 @@
+import UserPasswordUpdateInput from "../UpdateUserPasswordUseCase/UserPasswordUpdateInput";
+import UpdateUserPasswordInput from "../UpdateUserPasswordUseCase/UpdateUserPasswordInput";
+import UserPasswordUpdateOutput from "../UpdateUserPasswordUseCase/UserPasswordUpdateOutput";
+import UpdateUserPasswordRequest from "./UpdateUserPasswordRequest";
+import UpdateUserPasswordResponse from "./UpdateUserPasswordResponse";
+import UpdateUserPasswordGateway from "../UpdateUserPasswordUseCase/UpdateUserPasswordGateway";
+import UserPasswordUpdateInputValidator from "../UpdateUserPasswordUseCase/UserPasswordUpdateInputValidator";
+import UpdateUserPasswordPresenter from "./UpdateUserPasswordPresenter";
+import UpdateUserPasswordUseCase from "../UpdateUserPasswordUseCase/UpdateUserPasswordUseCase";
+
+export default class UpdateUserPasswordController implements UpdateUserPasswordInput
+{
+    public async handleUpdateUserPasswordRequest(updateUserPasswordRequest: UpdateUserPasswordRequest, updateUserPasswordGateway: UpdateUserPasswordGateway, userPasswordUpdateInputValidator: UserPasswordUpdateInputValidator): Promise<UpdateUserPasswordResponse>
+    {
+        const userPasswordUpdateInput: UserPasswordUpdateInput = await this.composeUserPasswordUpdateInput(updateUserPasswordRequest, userPasswordUpdateInputValidator);
+        const userPasswordUpdateOutput: UserPasswordUpdateOutput = await this.updateUserPassword(userPasswordUpdateInput, updateUserPasswordGateway);
+
+        const updateUserPasswordPresenter: UpdateUserPasswordPresenter = new UpdateUserPasswordPresenter();
+        updateUserPasswordPresenter.retrieveUserPasswordUpdateOutput(userPasswordUpdateOutput);
+
+        return updateUserPasswordPresenter.getUpdateUserPasswordResponse();
+    }
+
+    public async updateUserPassword(userPasswordUpdateInput: UserPasswordUpdateInput, updateUserPasswordGateway: UpdateUserPasswordGateway): Promise<UserPasswordUpdateOutput>
+    {
+        const updateUserPasswordUseCase: UpdateUserPasswordUseCase = new UpdateUserPasswordUseCase();
+        const userPasswordUpdateOutput: UserPasswordUpdateOutput = await updateUserPasswordUseCase.updateUserPassword(userPasswordUpdateInput, updateUserPasswordGateway);
+
+        return userPasswordUpdateOutput;
+    }
+
+    private async composeUserPasswordUpdateInput(updateUserPasswordRequest: UpdateUserPasswordRequest, userPasswordUpdateInputValidator: UserPasswordUpdateInputValidator): Promise<UserPasswordUpdateInput>
+    {
+        const userPasswordUpdateInput: UserPasswordUpdateInput = new UserPasswordUpdateInput(userPasswordUpdateInputValidator);
+        await userPasswordUpdateInput.setUserId(updateUserPasswordRequest.getUserId());
+        await userPasswordUpdateInput.setUpdatedUserId(updateUserPasswordRequest.getUpdatedUserId());
+        await userPasswordUpdateInput.setOrignalPassword(updateUserPasswordRequest.getOrignalPassword());
+        await userPasswordUpdateInput.setChangedPassword(updateUserPasswordRequest.getChangedPassword());
+        await userPasswordUpdateInput.setChangedPasswordConfirmation(updateUserPasswordRequest.getChangedPasswordConfirmation());
+
+        return userPasswordUpdateInput;
+    }
+}

features/UpdateUserPassword/UpdateUserPasswordController/UpdateUserPasswordPresenter.ts

@@ -0,0 +1,22 @@
+import UpdateUserPasswordResponse from "./UpdateUserPasswordResponse";
+import UserPasswordUpdateOutput from "../UpdateUserPasswordUseCase/UserPasswordUpdateOutput";
+import UpdateUserPasswordOutput from "../UpdateUserPasswordUseCase/UpdateUserPasswordOutput";
+
+export default class UpdateUserPasswordPresenter implements UpdateUserPasswordOutput
+{
+    private updateUserPasswordResponse!: UpdateUserPasswordResponse;
+
+    public getUpdateUserPasswordResponse(): UpdateUserPasswordResponse
+    {
+        return this.updateUserPasswordResponse;
+    }
+    
+    public retrieveUserPasswordUpdateOutput(userPasswordUpdateOutput: UserPasswordUpdateOutput): void
+    {
+        const updateUserPasswordResponse = new UpdateUserPasswordResponse();
+
+        updateUserPasswordResponse.setWetherTheUserPasswordWasUpdated(userPasswordUpdateOutput.userPasswordWasUpdated());
+
+        this.updateUserPasswordResponse = updateUserPasswordResponse;
+    }
+}

features/UpdateUserPassword/UpdateUserPasswordController/UpdateUserPasswordRequest.ts

@@ -0,0 +1,107 @@
+import BadRequestError from "../../../services/errors/BadRequestError";
+import UpdateUserPasswordTypeValidation from "./UpdateUserPasswordTypeValidation";
+
+export default class UpdateUserPasswordRequest
+{
+    private userId!: string;
+    private updatedUserId!: string;
+    private orignalPassword!: string;
+    private changedPassword!: string;
+    private changedPasswordConfirmation!: string;
+    private updateUserPasswordTypeValidation: UpdateUserPasswordTypeValidation
+
+    constructor(updateUserPasswordTypeValidation: UpdateUserPasswordTypeValidation)
+    {
+        this.updateUserPasswordTypeValidation = updateUserPasswordTypeValidation;
+    }
+
+    public getUserId(): string
+    {
+        return this.userId;
+    }
+
+    public setUserId(userId: string): UpdateUserPasswordRequest
+    {
+        this.updateUserPasswordTypeValidation.isString(userId, "User id");
+
+        if (userId.length === 0) {
+            throw new BadRequestError("Cannot update a user's password without a user id", "user_id_not_informed");
+        }
+
+        this.userId = userId;
+
+        return this;
+    }
+
+    public getUpdatedUserId(): string
+    {
+        return this.updatedUserId;
+    }
+
+    public setUpdatedUserId(updatedUserId: string): UpdateUserPasswordRequest
+    {
+        this.updateUserPasswordTypeValidation.isString(updatedUserId, "Updated user id");
+
+        if (updatedUserId.length === 0) {
+            throw new BadRequestError("Cannot update a user's password without an updated user id", "updated_user_id_not_informed");
+        }
+
+        this.updatedUserId = updatedUserId;
+
+        return this;
+    }
+
+    public getOrignalPassword(): string 
+    {
+        return this.orignalPassword;
+    }
+
+    public setOrignalPassword(orignalPassword: string): UpdateUserPasswordRequest
+    {
+        this.updateUserPasswordTypeValidation.isString(orignalPassword, "Original Password");
+
+        if (orignalPassword.length === 0) {
+            throw new BadRequestError("Cannot update a user's password without an original password informed", "original_password_not_informed");
+        }
+
+        this.orignalPassword = orignalPassword;
+
+        return this;
+    }
+
+    public getChangedPassword(): string
+    {
+        return this.changedPassword;
+    }
+
+    public setChangedPassword(changedPassword: string): UpdateUserPasswordRequest
+    {
+        this.updateUserPasswordTypeValidation.isString(changedPassword, "Changed Password");
+
+        if (changedPassword.length === 0) {
+            throw new BadRequestError("Cannot update a user's password without a changed password informed", "changed_password_not_informed");
+        }
+
+        this.changedPassword = changedPassword;
+
+        return this;
+    }
+
+    public getChangedPasswordConfirmation(): string
+    {
+        return this.changedPasswordConfirmation;
+    }
+
+    public setChangedPasswordConfirmation(changedPasswordConfirmation: string): UpdateUserPasswordRequest 
+    {
+        this.updateUserPasswordTypeValidation.isString(changedPasswordConfirmation, "Changed password confirmation");
+
+        if (changedPasswordConfirmation.length === 0) {
+            throw new BadRequestError("Cannot update a user's password without a changed password confirmation informed", "changed_password_confirmation_not_informed");
+        }
+
+        this.changedPasswordConfirmation = changedPasswordConfirmation;
+
+        return this;
+    }
+}

features/UpdateUserPassword/UpdateUserPasswordController/UpdateUserPasswordResponse.ts

@@ -0,0 +1,16 @@
+export default class UpdateUserPasswordResponse
+{
+    private _userPasswordWasUpdated!: boolean;
+
+    public userPasswordWasUpdated(): boolean
+    {
+        return this._userPasswordWasUpdated;
+    }
+
+    public setWetherTheUserPasswordWasUpdated(userPasswordWasUpdated: boolean): UpdateUserPasswordResponse
+    {
+        this._userPasswordWasUpdated = userPasswordWasUpdated;
+
+        return this;
+    }
+}

features/UpdateUserPassword/UpdateUserPasswordController/UpdateUserPasswordTypeValidation.ts

@@ -0,0 +1,4 @@
+export default interface UpdateUserPasswordTypeValidation 
+{
+    isString(testedVariable: any, variableName: string): boolean;
+}