update: users service

src/helpers/jwt.helper.ts

@@ -1,7 +1,7 @@
 import jwt from "jsonwebtoken";
 import { config } from "../configs/config";
 
-export class jwtHelper {
+export class JwtHelper {
   static generateToken(payload: any) {
     return jwt.sign(payload, config.jwt.secret, {
       expiresIn: config.jwt.expiresIn,

src/lib/error-handling/http-error.ts

@@ -0,0 +1,13 @@
+import http from "http";
+
+export class HttpError extends Error {
+  status: number;
+  constructor(status: number, message?: string | object) {
+    if (typeof message === "object") {
+      message = JSON.stringify(message);
+    }
+
+    super(message || http.STATUS_CODES[status] || "Error");
+    this.status = status;
+  }
+}

src/modules/common/users/models/user.model.ts

@@ -85,4 +85,6 @@ userSchema.pre("save", async function (next) {
     next();
 });
 
+export type UserDocument = IUser & mongoose.Document;
+
 export const userModel = mongoose.model<IUser>("users", userSchema);

src/modules/common/users/services/users.base.service.ts

@@ -1,114 +1,54 @@
-import { userModel } from "../models/user.model";
+import { FilterQuery, QueryWithHelpers } from "mongoose";
+import { IUser, UserDocument, userModel } from "../models/user.model";
+import { HttpError } from "src/lib/error-handling/http-error";
 
-export abstract class UsersBaseService {
-  async find(filterObject) {
-    try {
-      const resultObject = await userModel.findOne(filterObject).lean();
+export abstract class BaseUsersService {
+  async findOne(filterObject: FilterQuery<UserDocument>) {
+    return userModel.findOne(filterObject);
+  }
 
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
+  async findOneOrFail(
+    filterObject: FilterQuery<UserDocument>
+  ): Promise<UserDocument> {
+    try {
+      const document = await this.findOne(filterObject);
+      if (!document) throw new HttpError(404, "No Matching Result Found.");
 
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
+      return document;
     } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
+      console.error(err);
+      throw new HttpError(500, "Unexpected Error Happened.");
     }
   }
 
-  async create(form: any) {
-    try {
-      if (form.email) {
-        form.email = form.email.toLowerCase();
-        let user = await this.find({ email: form.email });
-        if (user.success)
-          return {
-            success: false,
-            error: "This email already exists",
-            code: 409,
-          };
-      }
-      let newUser = new userModel(form);
-      await newUser.save();
-      return {
-        success: true,
-        code: 201,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
-    }
+  async userExists(filterObject: FilterQuery<UserDocument>): Promise<boolean> {
+    return (await this.findOne(filterObject)) !== null;
   }
 
-  async get(filterObject) {
-    try {
-      const resultObject = await userModel
-        .findOne(filterObject)
-        .lean()
-        .select("-password");
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
-    }
+  async create(createParams: IUser): Promise<UserDocument> {
+    if (await this.userExists({ email: createParams.email }))
+      throw new HttpError(409, "Email Already Exists.");
+
+    const newUser = new userModel(createParams) as UserDocument;
+    return newUser.save();
   }
 
-  async list(filterObject) {
-    try {
-      const resultArray = await userModel
-        .find(filterObject)
-        .lean()
-        .select("-password");
+  async get(filterObject: FilterQuery<UserDocument>): Promise<UserDocument> {
+    const user: UserDocument = await userModel
+      .findOne(filterObject)
+      .select("-password");
+    if (!user) throw new HttpError(404, "No Matching Result Found.");
+    return user;
+  }
 
-      if (!resultArray)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      const count = await userModel.countDocuments(filterObject);
-      return {
-        success: true,
-        code: 200,
-        record: resultArray,
-        count,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
+  async list(filterObject: FilterQuery<UserDocument>): Promise<{
+    docs: UserDocument[];
+    count: number;
+  }> {
+    const users = (await userModel
+      .find(filterObject)
+      .select("-password")) as UserDocument[];
+    const count = await userModel.countDocuments(filterObject);
+    return { docs: users, count };
   }
 }

src/modules/console/users/controllers/users.controller.ts

@@ -1,10 +1,11 @@
 import { userRegisterSchema } from "src/modules/common/users/validation/user-register.validation";
 import { asyncHandler } from "../../../../helpers/async-handler";
-import { jwtHelper } from "../../../../helpers/jwt.helper";
+import { JwtHelper } from "../../../../helpers/jwt.helper";
 import { bodyValidator } from "../../../../helpers/validation.helper";
 import { BaseController } from "../../../../lib/controllers/controller.base";
 import { Prefix } from "../../../../lib/decorators/prefix.decorator";
 import { UsersService } from "../services/users.service";
+import { JsonResponse } from "src/lib/responses/json-response";
 
 const allowedRoles = ["superAdmin", "admin"];
 
@@ -15,23 +16,16 @@ export class AdminUsersController extends BaseController {
   setRoutes() {
     this.router.post(
       "/create",
-      jwtHelper.verifyToken(allowedRoles),
+      JwtHelper.verifyToken(allowedRoles),
       bodyValidator(userRegisterSchema),
       asyncHandler(this.create)
     );
   }
 
   create = async (req, res) => {
-    try {
-      let result = await this.usersService.create(req.body);
-      return res.status(result.code).json(result);
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return res.status(500).json({
-        success: false,
-        code: 500,
-        error: err.message,
-      });
-    }
+    let user = await this.usersService.create(req.body);
+    return new JsonResponse({
+      data: user,
+    });
   };
 }

src/modules/console/users/services/users.service.ts

@@ -1,3 +1,3 @@
-import { UsersBaseService } from "../../../common/users/services/users.base.service";
+import { BaseUsersService } from "../../../common/users/services/users.base.service";
 
-export class UsersService extends UsersBaseService {}
+export class UsersService extends BaseUsersService {}

src/modules/users/auth/controllers/auth.controller.ts

@@ -1,15 +1,17 @@
 import { UsersAuthService } from "../services/users.service";
-import { jwtHelper } from "../../../../helpers/jwt.helper";
 import { BaseController } from "../../../../lib/controllers/controller.base";
 import { bodyValidator } from "../../../../helpers/validation.helper";
 import { asyncHandler } from "../../../../helpers/async-handler";
 import { Prefix } from "../../../../lib/decorators/prefix.decorator";
-import { loginValidationSchema } from "../validation/user.Validation";
+import { loginValidationSchema } from "../validation/login.validation";
 import { userRegisterSchema } from "src/modules/common/users/validation/user-register.validation";
+import { Request, Response } from "express";
+import { IUser } from "src/modules/common/users/models/user.model";
+import { JsonResponse } from "src/lib/responses/json-response";
 
 @Prefix("/users/auth")
 export class UsersAuthController extends BaseController {
-  private usersService = new UsersAuthService();
+  private authService = new UsersAuthService();
 
   setRoutes(): void {
     this.router.post(
@@ -24,50 +26,17 @@ export class UsersAuthController extends BaseController {
     );
   }
 
-  register = async (req, res) => {
-    try {
-      let result = await this.usersService.create(req.body);
-      return res.status(result.code).json(result);
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return res.status(500).json({
-        success: false,
-        code: 500,
-        error: err.message,
-      });
-    }
+  register = async (req: Request, res: Response) => {
+    let user = await this.authService.create(req.body as IUser);
+    return new JsonResponse({
+      data: user,
+    });
   };
 
   login = async (req, res) => {
-    try {
-      const { email, password } = req.body;
-      let result: {
-        success: boolean;
-        code: number;
-        record?: any;
-        message?: string;
-      } = await this.usersService.comparePassword(email, password);
-      if (!result.success) return res.status(result.code).json(result);
-      let payload = {
-        _id: result.record?._id,
-        name: result.record?.name,
-        email: result.record?.email,
-        number: result.record?.number,
-        role: result.record?.role,
-      };
-      const token = jwtHelper.generateToken(payload);
-      return res.status(result.code).json({
-        success: result.success,
-        token,
-        code: result.code,
-        record: result.record,
-      });
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return res.status(500).json({
-        success: false,
-        message: err.message,
-      });
-    }
+    const { user, token } = await this.authService.login(req.body);
+    return new JsonResponse({
+      data: { user, token },
+    });
   };
 }

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

@@ -1,37 +1,18 @@
-import { UsersBaseService } from "../../../common/users/services/users.base.service";
+import { BaseUsersService } from "../../../common/users/services/users.base.service";
 import bcrypt from "bcrypt";
+import { ILogin } from "../validation/login.validation";
+import { HttpError } from "src/lib/error-handling/http-error";
+import { JwtHelper } from "src/helpers/jwt.helper";
 
-export class UsersAuthService extends UsersBaseService {
-  async comparePassword(email: string, password: string) {
-    try {
-      if (email != undefined) {
-        email = email.toLowerCase();
-      }
-      let result = await this.find({ email });
-      if (!result.success) return result;
-
-      let match = await bcrypt.compare(password, result.record.password);
-      delete result.record.password;
-
-      if (!match)
-        return {
-          success: false,
-          code: 409,
-          message: "password isn't correct",
-        };
-
-      return {
-        success: true,
-        code: 200,
-        record: result.record,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
-    }
+export class UsersAuthService extends BaseUsersService {
+  async login(loginRequest: ILogin) {
+    const user = await this.findOneOrFail({ email: loginRequest.email });
+    const isPasswordCorrect = await bcrypt.compare(
+      loginRequest.password,
+      user.password
+    );
+    if (!isPasswordCorrect) throw new HttpError(401, "Incorrect Password");
+    const token = JwtHelper.generateToken({ id: user._id, role: user.role });
+    return { user, token };
   }
 }