LIME-69: Add Profile Settings

backend/src/bundles/users/enums/enums.ts

@@ -1,3 +1,9 @@
 export { UserAttributes } from './user-attributes.enum.js';
 export { UserDetailsAttributes } from './user-details-attributes.enum.js';
 export { Gender, UsersApiPath } from 'shared';
+export {
+    AuthApiPath,
+    HttpCode,
+    HttpError,
+    UserValidationMessage,
+} from 'shared';

backend/src/bundles/users/types/types.ts

@@ -2,5 +2,6 @@ export {
     type UserAuthRequestDto,
     type UserAuthResponseDto,
     type UserGetAllResponseDto,
+    type UserUpdateProfileRequestDto,
     type ValueOf,
 } from 'shared';

backend/src/bundles/users/user-details.model.ts

@@ -26,6 +26,8 @@ class UserDetailsModel extends AbstractModel {
     public static override get tableName(): string {
         return DatabaseTableName.USER_DETAILS;
     }
+
+    [key: string]: unknown;
 }
 
 export { UserDetailsModel };

backend/src/bundles/users/user.controller.ts

@@ -1,12 +1,17 @@
+import { UserValidationMessage } from 'shared';
+
 import { type UserService } from '~/bundles/users/user.service.js';
-import { type UserAuthResponseDto } from '~/bundles/users/users.js';
+import {
+    type UserAuthResponseDto,
+    type UserUpdateProfileRequestDto,
+} from '~/bundles/users/users.js';
 import {
     type ApiHandlerOptions,
     type ApiHandlerResponse,
-    BaseController,
 } from '~/common/controller/controller.js';
+import { BaseController } from '~/common/controller/controller.js';
 import { ApiPath } from '~/common/enums/enums.js';
-import { HttpCode } from '~/common/http/http.js';
+import { HttpCode, HttpError } from '~/common/http/http.js';
 import { type Logger } from '~/common/logger/logger.js';
 
 import { UsersApiPath } from './enums/enums.js';
@@ -95,6 +100,20 @@ class UserController extends BaseController {
                     }>,
                 ),
         });
+
+        this.addRoute({
+            path: `${UsersApiPath.UPDATE_USER}/:userId`,
+            method: 'PATCH',
+            isProtected: true,
+            handler: (options) =>
+                this.updateUser(
+                    options as ApiHandlerOptions<{
+                        user: UserAuthResponseDto;
+                        body: UserUpdateProfileRequestDto;
+                        params: { userId: string };
+                    }>,
+                ),
+        });
     }
 
     /**
@@ -167,6 +186,53 @@ class UserController extends BaseController {
             payload: user,
         };
     }
+
+    private async updateUser(
+        options: ApiHandlerOptions<{
+            user: UserAuthResponseDto;
+            body: UserUpdateProfileRequestDto;
+            params: { userId: string };
+        }>,
+    ): Promise<ApiHandlerResponse> {
+        const { user, body, params } = options;
+        const userId = params.userId;
+
+        try {
+            if (Number(userId) !== Number(user.id)) {
+                throw new Error('Token mismatch');
+            }
+            const updatedUser = await this.userService.update(
+                Number(userId),
+                body,
+            );
+            if (updatedUser && body.dateOfBirth) {
+                const [day, month, year] = body.dateOfBirth.split('/');
+                const parsedDate = new Date(`${year}-${month}-${day}`);
+
+                if (Number.isNaN(parsedDate.getTime())) {
+                    throw new HttpError({
+                        message: UserValidationMessage.BIRTHDATE_FORMAT,
+                        status: HttpCode.BAD_REQUEST,
+                    });
+                } else {
+                    const formattedDate =
+                        parsedDate.toLocaleDateString('en-GB');
+
+                    updatedUser.dateOfBirth = formattedDate;
+                }
+            }
+
+            return {
+                status: HttpCode.OK,
+                payload: updatedUser,
+            };
+        } catch (error) {
+            throw new HttpError({
+                message: `Something went wrong ${error}`,
+                status: HttpCode.BAD_REQUEST,
+            });
+        }
+    }
 }
 
 export { UserController };

backend/src/bundles/users/user.repository.ts

@@ -2,6 +2,9 @@ import { UserEntity } from '~/bundles/users/user.entity.js';
 import { type UserModel } from '~/bundles/users/user.model.js';
 import { type Repository } from '~/common/types/types.js';
 
+import { HttpCode, HttpError, UserValidationMessage } from './enums/enums.js';
+import { type UserDetailsModel } from './user-details.model.js';
+
 class UserRepository implements Repository {
     private userModel: typeof UserModel;
 
@@ -96,8 +99,43 @@ class UserRepository implements Repository {
         }
     }
 
-    public update(): ReturnType<Repository['update']> {
-        return Promise.resolve(null);
+    public async update(
+        userId: number,
+        updatedUserDetails: Partial<UserDetailsModel>,
+    ): Promise<UserEntity> {
+        const trx = await this.userModel.startTransaction();
+
+        try {
+            const user = await this.userModel.query(trx).findById(userId);
+
+            if (!user) {
+                throw new HttpError({
+                    message: UserValidationMessage.USER_NOT_FOUND,
+                    status: HttpCode.NOT_FOUND,
+                });
+            }
+            await user
+                .$relatedQuery('userDetails', trx)
+                .patch(updatedUserDetails);
+
+            const userDetails = await user.$relatedQuery('userDetails', trx);
+
+            await trx.commit();
+
+            return UserEntity.initialize({
+                ...user,
+                fullName: userDetails.fullName,
+                avatarUrl: userDetails.avatarUrl,
+                username: userDetails.username,
+                dateOfBirth: userDetails.dateOfBirth,
+                weight: userDetails.weight,
+                height: userDetails.height,
+                gender: userDetails.gender,
+            });
+        } catch (error) {
+            await trx.rollback();
+            throw new Error(`Error updating user details: ${error}`);
+        }
     }
 
     public delete(): ReturnType<Repository['delete']> {

backend/src/bundles/users/user.service.ts

@@ -3,11 +3,14 @@ import { type UserRepository } from '~/bundles/users/user.repository.js';
 import { cryptService } from '~/common/services/services.js';
 import { type Service } from '~/common/types/types.js';
 
+import { HttpCode, HttpError, UserValidationMessage } from './enums/enums.js';
 import {
     type UserAuthRequestDto,
     type UserAuthResponseDto,
     type UserGetAllResponseDto,
+    type UserUpdateProfileRequestDto,
 } from './types/types.js';
+import { type UserDetailsModel } from './user-details.model.js';
 
 class UserService implements Service {
     private userRepository: UserRepository;
@@ -46,10 +49,49 @@ class UserService implements Service {
         return user.toObject() as UserAuthResponseDto;
     }
 
-    public update(): ReturnType<Service['update']> {
-        return Promise.resolve(null);
+    public async update(
+        userId: number,
+        userRequest: UserUpdateProfileRequestDto,
+    ): Promise<UserAuthResponseDto | null> {
+        try {
+            const existingUser = await this.userRepository.find({
+                id: userId,
+            });
+            if (existingUser) {
+                const updatedUserDetails: Partial<UserDetailsModel> = {};
+                for (const property of Object.keys(userRequest)) {
+                    const value = userRequest[property];
+                    if (this.shouldUpdateProperty(value)) {
+                        updatedUserDetails[property] =
+                            property === 'weight' || property === 'height'
+                                ? Number(userRequest[property])
+                                : userRequest[property];
+                    }
+                }
+                const updatedUser = await this.userRepository.update(
+                    userId,
+                    updatedUserDetails,
+                );
+                if (!updatedUser) {
+                    throw new HttpError({
+                        message: UserValidationMessage.USER_NOT_FOUND,
+                        status: HttpCode.NOT_FOUND,
+                    });
+                }
+                return updatedUser.toObject() as UserAuthResponseDto;
+            } else {
+                throw new HttpError({
+                    message: UserValidationMessage.USER_NOT_FOUND,
+                    status: HttpCode.NOT_FOUND,
+                });
+            }
+        } catch (error) {
+            throw new Error(`Error occured ${error}`);
+        }
+    }
+    private shouldUpdateProperty(value: unknown): boolean {
+        return value !== null && value !== '';
     }
-
     public delete(): ReturnType<Service['delete']> {
         return Promise.resolve(true);
     }

backend/src/bundles/users/users.ts

@@ -13,8 +13,12 @@ export { userController, userService };
 export {
     type UserAuthRequestDto,
     type UserAuthResponseDto,
+    type UserUpdateProfileRequestDto,
 } from './types/types.js';
 export { UserEntity } from './user.entity.js';
 export { UserModel } from './user.model.js';
 export { UserService } from './user.service.js';
-export { userAuthValidationSchema } from './validation-schemas/validation-schemas.js';
+export {
+    userAuthValidationSchema,
+    userUpdateProfileValidationSchema,
+} from './validation-schemas/validation-schemas.js';

backend/src/bundles/users/validation-schemas/validation-schemas.ts

@@ -1 +1,4 @@
-export { userAuthValidationSchema } from 'shared';
+export {
+    userAuthValidationSchema,
+    userUpdateProfileValidationSchema,
+} from 'shared';

backend/src/common/types/repository.type.ts

@@ -2,7 +2,7 @@ type Repository<T = unknown> = {
     find(query: Record<string, T>): Promise<T>;
     findAll(): Promise<T[]>;
     create(payload: unknown): Promise<T>;
-    update(): Promise<T>;
+    update(id: number, payload: object): Promise<T>;
     delete(): Promise<boolean>;
 };
 

backend/src/common/types/service.type.ts

@@ -1,10 +1,15 @@
+import { type UserUpdateProfileRequestDto } from 'shared';
+
 type Service<T = unknown> = {
     find(query: Record<string, T>): Promise<T>;
     findAll(): Promise<{
         items: T[];
     }>;
     create(payload: unknown): Promise<T>;
-    update(): Promise<T>;
+    update(
+        id: number,
+        updatedDetails: UserUpdateProfileRequestDto,
+    ): Promise<T | null>;
     delete(): Promise<boolean>;
 };
 

backend/src/common/types/types.ts

@@ -7,6 +7,7 @@ export {
     type ServerCommonErrorResponse,
     type ServerErrorResponse,
     type ServerValidationErrorResponse,
+    type UserUpdateProfileRequestDto,
     type ValidationSchema,
     type ValueOf,
 } from 'shared';

frontend/src/app/app.tsx

@@ -43,6 +43,9 @@ const App: React.FC = () => {
                 <li>
                     <Link to={AppRoute.SIGN_UP}>Sign up</Link>
                 </li>
+                <li>
+                    <Link to={AppRoute.PROFILE}>Profile</Link>
+                </li>
             </ul>
             <p>Current path: {pathname}</p>
 

frontend/src/bundles/auth/auth.ts

@@ -11,4 +11,7 @@ const authApi = new AuthApi({
 });
 
 export { authApi };
-export { type AuthResponseDto } from './types/types.js';
+export {
+    type AuthResponseDto,
+    type UserAuthResponseDto,
+} from './types/types.js';

frontend/src/bundles/auth/store/actions.ts

@@ -4,7 +4,10 @@ import {
     type AsyncThunkConfig,
     type UserAuthResponseDto,
 } from '~/bundles/common/types/types.js';
-import { type UserAuthRequestDto } from '~/bundles/users/users.js';
+import {
+    type UserAuthRequestDto,
+    type UserUpdateProfileRequestDto,
+} from '~/bundles/users/users.js';
 import { storage, StorageKey } from '~/framework/storage/storage.js';
 
 import { type AuthResponseDto } from '../auth.js';
@@ -46,4 +49,15 @@ const refreshUser = createAsyncThunk<
     return userApi.refreshUser();
 });
 
-export { refreshUser, signIn, signUp };
+const updateUser = createAsyncThunk<
+    UserAuthResponseDto,
+    UserUpdateProfileRequestDto,
+    AsyncThunkConfig
+>(`${sliceName}/update-user`, async (updateUserPayload, { extra }) => {
+    const { userApi } = extra;
+    const { id: userId } = updateUserPayload;
+    const userIdAsString: string = userId ? userId.toString() : '';
+    return await userApi.updateUser(userIdAsString, updateUserPayload);
+});
+
+export { refreshUser, signIn, signUp, updateUser };

frontend/src/bundles/auth/store/auth.ts

@@ -1,10 +1,11 @@
-import { refreshUser, signIn, signUp } from './actions.js';
+import { refreshUser, signIn, signUp, updateUser } from './actions.js';
 import { actions } from './slice.js';
 
 const allActions = {
     ...actions,
     signUp,
     signIn,
+    updateUser,
     refreshUser,
 };
 

frontend/src/bundles/auth/store/slice.ts

@@ -6,7 +6,7 @@ import {
     type ValueOf,
 } from '~/bundles/common/types/types.js';
 
-import { refreshUser, signIn, signUp } from './actions.js';
+import { refreshUser, signIn, signUp, updateUser } from './actions.js';
 
 type State = {
     dataStatus: ValueOf<typeof DataStatus>;
@@ -58,6 +58,16 @@ const { reducer, actions, name } = createSlice({
             state.dataStatus = DataStatus.REJECTED;
             state.isRefreshing = false;
         });
+        builder.addCase(updateUser.pending, (state) => {
+            state.dataStatus = DataStatus.PENDING;
+        });
+        builder.addCase(updateUser.fulfilled, (state, action) => {
+            state.dataStatus = DataStatus.FULFILLED;
+            state.user = action.payload;
+        });
+        builder.addCase(updateUser.rejected, (state) => {
+            state.dataStatus = DataStatus.REJECTED;
+        });
     },
 });
 

frontend/src/bundles/auth/types/types.ts

@@ -1 +1 @@
-export { type AuthResponseDto } from 'shared';
+export { type AuthResponseDto, type UserAuthResponseDto } from 'shared';