complete: complete login process

src/modules/auth/controller/loginWithPassword.controller.ts

@@ -1,31 +1,41 @@
-import { Context } from "elysia";
-import { loginWithPasswordService } from "../services/loginWithPassword.service";
-import { loginWithPasswordSchema } from "../auth.schema";
 import {
   returnErrorResponse,
   returnWriteResponse,
 } from "../../../helpers/callback/httpResponse";
+import { Context } from "elysia";
+import { loginWithPasswordService } from "../services/loginWithPassword.service";
 import { LoginWithPasswordRequest } from "../auth.types";
 import { mainErrorHandler } from "../../../helpers/error/handler";
 import { getUserHeaderInformation } from "../../../helpers/http/userHeader/getUserHeaderInformation";
 import { setCookie } from "../../../helpers/http/userHeader/cookies/setCookies";
 import { COOKIE_KEYS } from "../../../constants/cookie.keys";
+import { loginWithPasswordSchema } from "../schemas/loginWithPassword";
 
 export const loginWithPassword = async (
   ctx: Context & { body: LoginWithPasswordRequest }
 ) => {
+  // Validate the request body against the schema
   const { error } = loginWithPasswordSchema.validate(ctx.body);
   if (error || !ctx.body)
     return returnErrorResponse(ctx.set, 400, "Invalid user input", error);
 
+  // Extract user header information
   const userHeaderInfo = getUserHeaderInformation(ctx);
 
   try {
+    // Call the service to handle login with password
     const jwtToken = await loginWithPasswordService(ctx.body, userHeaderInfo);
 
+    // Set the authentication cookie with the JWT token
     const cookie = setCookie(ctx.set, COOKIE_KEYS.AUTH, jwtToken);
-    return returnWriteResponse(ctx.set, 200, "Authentication Success", cookie);
+    return returnWriteResponse(
+      ctx.set,
+      200,
+      "Authentication Success",
+      jwtToken
+    );
   } catch (error) {
+    // Handle any errors that occur during the login process
     return mainErrorHandler(ctx.set, error);
   }
 };

src/modules/auth/services/loginWithPassword.service.ts

@@ -5,6 +5,7 @@ import { AppError } from "../../../helpers/error/instances/app";
 import { UserHeaderInformation } from "../../../helpers/http/userHeader/getUserHeaderInformation/types";
 import { createUserSessionService } from "../../userSession/services/createUserSession.service";
 import { jwtEncode } from "../../../helpers/http/jwt/encode";
+import { ErrorForwarder } from "../../../helpers/error/instances/forwarder";
 
 export const loginWithPasswordService = async (
   request: LoginWithPasswordRequest,
@@ -14,6 +15,9 @@ export const loginWithPasswordService = async (
     // search for user data using an identifier (username or email)
     const userData = await findUserByEmailOrUsernameService(request.identifier);
 
+    // if user data is not found, throw an error
+    if (!userData) throw new AppError(404, "User not found");
+
     // validate the password in the request with the existing one
     if (!(await bcrypt.compare(request.password, userData.password)))
       throw new AppError(401, "Password incorrect");
@@ -26,9 +30,8 @@ export const loginWithPasswordService = async (
 
     // create JWT token that contain user session
     const jwtToken = jwtEncode(userSession);
-
     return jwtToken;
   } catch (error) {
-    throw error;
+    ErrorForwarder(error);
   }
 };

src/modules/user/repositories/findUserByEmailOrUsername.repository.ts

@@ -2,34 +2,38 @@ import { AppError } from "../../../helpers/error/instances/app";
 import { userModel } from "../user.model";
 
 export const findUserByEmailOrUsernameRepo = async (identifier: string) => {
-  const userData =
+  try {
-    (await userModel.findUnique({
+    const userData =
-      where: { email: identifier },
+      (await userModel.findUnique({
-      include: {
+        where: { email: identifier },
-        roles: {
+        include: {
-          omit: {
+          roles: {
-            createdBy: true,
+            omit: {
-            createdAt: true,
+              createdBy: true,
-            updatedAt: true,
+              createdAt: true,
-            deletedAt: true,
+              updatedAt: true,
+              deletedAt: true,
+            },
           },
         },
-      },
+      })) ||
-    })) ||
+      (await userModel.findUnique({
-    (await userModel.findUnique({
+        where: { username: identifier },
-      where: { username: identifier },
+        include: {
-      include: {
+          roles: {
-        roles: {
+            omit: {
-          omit: {
+              createdBy: true,
-            createdBy: true,
+              createdAt: true,
-            createdAt: true,
+              updatedAt: true,
-            updatedAt: true,
+              deletedAt: true,
-            deletedAt: true,
+            },
           },
         },
-      },
+      }));
-    }));
 
-  if (!userData) throw new AppError(404, "User not exist");
+    if (!userData) return false;
-  return userData;
+    return userData;
+  } catch (error) {
+    throw new AppError(500, "Database error", error);
+  }
 };

src/modules/user/services/findUserByEmailOrUsername.service.ts

@@ -1,3 +1,4 @@
+import { ErrorForwarder } from "../../../helpers/error/instances/forwarder";
 import { findUserByEmailOrUsernameRepo } from "../repositories/findUserByEmailOrUsername.repository";
 
 export const findUserByEmailOrUsernameService = async (identifier: string) => {
@@ -5,6 +6,6 @@ export const findUserByEmailOrUsernameService = async (identifier: string) => {
     const userData = await findUserByEmailOrUsernameRepo(identifier);
     return userData;
   } catch (error) {
-    throw error;
+    ErrorForwarder(error);
   }
 };