feat: crud service

src/common/enums/authenticatable-type.enum.ts

@@ -0,0 +1,4 @@
+export enum AuthenticatableType {
+  USER = "user",
+  ADMIN = "admin",
+}

src/common/enums/fitness-goal.enum.ts

@@ -0,0 +1,5 @@
+export enum FitnessGoal {
+  LOSE_WEIGHT = "lose weight",
+  GAIN_MUSCLE = "gain muscle",
+  GET_FITTER = "get fitter",
+}

src/common/enums/fitness-level.enum.ts

@@ -0,0 +1,5 @@
+export enum FitnessLevel {
+  BEGINNER = "beginner",
+  INTERMEDIATE = "intermediate",
+  ADVANCED = "advanced",
+}

src/common/enums/gender.enum.ts

@@ -0,0 +1,4 @@
+export enum Gender {
+  MALE = "male",
+  FEMALE = "female",
+}

src/common/enums/injury.enum.ts

@@ -0,0 +1,7 @@
+export enum Injury {
+  NECK = "neck",
+  SHOULDERS = "shoulders",
+  BACK = "back",
+  ARMS = "arms",
+  KNEES = "knees",
+}

src/common/enums/preferred-day.enum.ts

@@ -0,0 +1,9 @@
+export enum PreferredDay {
+  SATURDAY = "saturday",
+  SUNDAY = "sunday",
+  MONDAY = "monday",
+  TUESDAY = "tuesday",
+  WEDNESDAY = "wednesday",
+  THURSDAY = "thursday",
+  FRIDAY = "friday",
+}

src/common/enums/preferred-equipment.enum.ts

@@ -0,0 +1,7 @@
+export enum PreferredEquipment {
+  BARBELLS = "barbells",
+  DUMBBELLS = "dumbbells",
+  GYM_MACHINES = "gym machines",
+  RESISTANCE_BAND = "resistance band",
+  BODYWEIGHT = "bodyweight",
+}

src/common/enums/workout-place.enum.ts

@@ -0,0 +1,5 @@
+export enum WorkoutPlace {
+  GYM = "gym",
+  HOME = "home",
+  BOTH = "both",
+}

src/common/models/user.model.ts

@@ -0,0 +1,103 @@
+import mongoose from "mongoose";
+import bcrypt from "bcrypt";
+import { AuthenticatableType } from "@common/enums/authenticatable-type.enum";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Gender } from "@common/enums/gender.enum";
+import { Injury } from "@common/enums/injury.enum";
+import { PreferredDay } from "@common/enums/preferred-day.enum";
+import { PreferredEquipment } from "@common/enums/preferred-equipment.enum";
+import { WorkoutPlace } from "@common/enums/workout-place.enum";
+export const saltrounds = 5;
+const { Schema } = mongoose;
+
+export interface IUser {
+  name: string;
+  email: string;
+  password: string;
+  image: object;
+  role: AuthenticatableType;
+  gender: string;
+  dob: Date;
+  height: number;
+  weight: number;
+  fitness_level: string;
+  preferences: {
+    fitness_goal: FitnessGoal;
+    target_weight: number;
+    workout_frequency: number;
+    preferred_days: [PreferredDay];
+    workout_place: WorkoutPlace;
+    preferred_equipment: [PreferredEquipment];
+  };
+  injuries: [Injury];
+}
+
+const userSchema = new Schema({
+  name: { type: String, required: true },
+  email: { type: String, required: true, unique: true, dropDups: true },
+  password: { type: String, required: true },
+  image: { type: Object },
+  gender: {
+    type: String,
+    enum: Gender,
+    required: true,
+  },
+  height: { type: Number, required: true },
+  weight: { type: Number, required: true },
+  fitness_level: {
+    type: String,
+    enum: FitnessLevel,
+    required: true,
+  },
+  preferences: {
+    fitness_goal: {
+      type: String,
+      enum: FitnessGoal,
+      required: true,
+    },
+    target_weight: { type: Number, required: true },
+    workout_frequency: { type: Number, required: true },
+    preferred_days: [
+      {
+        type: String,
+        enum: PreferredDay,
+        required: true,
+      },
+    ],
+    workout_place: {
+      type: String,
+      enum: WorkoutPlace,
+      required: true,
+    },
+    preferred_equipment: [
+      {
+        type: String,
+        enum: PreferredEquipment,
+        required: true,
+      },
+    ],
+  },
+  injuries: [
+    {
+      type: String,
+      enum: Injury,
+      required: true,
+    },
+  ],
+  dob: { type: Date },
+  role: {
+    type: String,
+    enum: AuthenticatableType,
+    default: AuthenticatableType.USER,
+  },
+});
+
+userSchema.pre("save", async function (next) {
+  this.password = await bcrypt.hash(this.password, saltrounds);
+  next();
+});
+
+export type UserDocument = IUser & mongoose.Document;
+
+export const userModel = mongoose.model<UserDocument>("users", userSchema);

src/{modules/common/users → common}/services/users.base.service.ts

@@ -1,6 +1,6 @@
-import { FilterQuery, QueryWithHelpers } from "mongoose";
-import { IUser, UserDocument, userModel } from "../models/user.model";
+import { FilterQuery } from "mongoose";
 import { HttpError } from "src/lib/error-handling/http-error";
+import { UserDocument, userModel, IUser } from "../models/user.model";
 
 export abstract class BaseUsersService {
   async findOne(filterObject: FilterQuery<UserDocument>) {

src/{modules/common/users/validation → common/validations}/user-register.validation.ts

@@ -1,14 +1,12 @@
+import { AuthenticatableType } from "@common/enums/authenticatable-type.enum";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Gender } from "@common/enums/gender.enum";
+import { Injury } from "@common/enums/injury.enum";
+import { PreferredDay } from "@common/enums/preferred-day.enum";
+import { PreferredEquipment } from "@common/enums/preferred-equipment.enum";
+import { WorkoutPlace } from "@common/enums/workout-place.enum";
 import * as joi from "joi";
-import {
-  Role,
-  Gender,
-  FitnessLevel,
-  FitnessGoal,
-  WorkoutPlace,
-  PreferredDay,
-  PreferredEquipment,
-  Injury,
-} from "../enums/roles.enum";
 import { createSchema } from "src/helpers/create-schema";
 
 export interface IUserRegister {
@@ -34,7 +32,6 @@ export interface IUserRegister {
   };
   injuries: string[];
   dob?: Date;
-  role?: Role;
 }
 
 export const userRegisterKeys = {
@@ -185,7 +182,7 @@ export const userRegisterKeys = {
   }),
   role: joi
     .string()
-    .valid(...Object.values(Role))
+    .valid(...Object.values(AuthenticatableType))
     .optional()
     .messages({
       "string.base": "please enter a valid role",

src/configs/config.ts

@@ -1,5 +1,5 @@
-import { Env } from "./env";
 import dotenv from "dotenv";
+import { Env } from "src/lib/env/env";
 dotenv.config();
 
 export interface Config {

src/configs/env.ts

@@ -1,25 +0,0 @@
-export class EnvValue {
-  constructor(public value: string | number | boolean) {}
-
-  toString(): string {
-    return String(this.value);
-  }
-  toNumber(): number {
-    return Number(this.value);
-  }
-  toBoolean(): boolean {
-    return this.value === "true";
-  }
-}
-
-export class Env {
-  static get(key: string, defaultValue?: string | number | boolean): EnvValue {
-    const value = process.env[key] || defaultValue;
-
-    if (!value) {
-      throw new Error(`Environment variable ${key} not found`);
-    }
-
-    return new EnvValue(value);
-  }
-}

src/helpers/jwt.helper.ts

@@ -12,23 +12,23 @@ export class JwtHelper {
     return (req: any, res: any, next: any) => {
       let authHeader = req.headers["authorization"];
       const token = authHeader && authHeader.split(" ")[1];
-      if (token) {
-        jwt.verify(token, config.jwt.secret, (err: any, tokenData: any) => {
-          if (err)
-            return res
-              .status(403)
-              .json({ success: false, code: 403, message: "Invalid Token!" });
-          if (!role.includes(tokenData.role))
-            return res
-              .status(401)
-              .json({ success: false, code: 401, message: "Unauthorized" });
-          req.tokenData = tokenData;
-          next();
-        });
-      } else
+      if (!token) {
         return res
           .status(401)
           .json({ success: false, code: 401, message: "Unauthorized" });
+      }
+      jwt.verify(token, config.jwt.secret, (err: any, tokenData: any) => {
+        if (err)
+          return res
+            .status(403)
+            .json({ success: false, code: 403, message: "Invalid Token!" });
+        if (!role.includes(tokenData.role))
+          return res
+            .status(401)
+            .json({ success: false, code: 401, message: "Unauthorized" });
+        req.tokenData = tokenData;
+        next();
+      });
     };
   }
 }

src/helpers/pagination.ts

@@ -0,0 +1,11 @@
+import { Request } from "express";
+
+export const parsePaginationQuery = (query: Request["query"]) => {
+  const limit = query.take && parseInt(query.limit as string);
+  const skip = query.skip && parseInt(query.skip as string);
+
+  return {
+    limit,
+    skip,
+  };
+};

src/lib/responses/json-response.ts

@@ -1,23 +1,21 @@
-export class JsonResponse {
-  public status: number;
-  public message: string;
-  public data: Record<string, any> | Record<string, any>[];
-  public meta?: {
+interface JsonResponseProps {
+  status?: number;
+  message?: string;
+  data?: Record<string, any> | Record<string, any>[];
+  meta?: {
     total: number;
     page: number;
     perPage: number;
   };
+}
+
+export class JsonResponse {
+  public status: JsonResponseProps["status"];
+  public message: JsonResponseProps["message"];
+  public data: JsonResponseProps["data"];
+  public meta?: JsonResponseProps["meta"];
 
-  constructor(props: {
-    status?: number;
-    message?: string;
-    data?: Record<string, any> | Record<string, any>[];
-    meta?: {
-      total: number;
-      page: number;
-      perPage: number;
-    };
-  }) {
+  constructor(props: JsonResponseProps) {
     this.status = props.status || 200;
     this.message = props.message || "Success";
     this.data = props.data || {};

src/lib/services/crud.service.ts

@@ -0,0 +1,68 @@
+import { HttpError } from "@lib/error-handling/http-error";
+import { AnyKeys, Document, FilterQuery, Model } from "mongoose";
+
+export const CrudService = <ModelDoc extends Document>(
+  model: Model<ModelDoc>
+) => {
+  return class CrudServiceClass {
+    protected model: Model<ModelDoc> = model;
+
+    async create(data: AnyKeys<ModelDoc>): Promise<ModelDoc> {
+      return this.model.create(data);
+    }
+
+    async update(
+      filter: FilterQuery<ModelDoc>,
+      data: AnyKeys<ModelDoc>
+    ): Promise<ModelDoc> {
+      return this.model.findOneAndUpdate(filter, data, { new: true });
+    }
+
+    async delete(filter: FilterQuery<ModelDoc>): Promise<ModelDoc> {
+      return this.model.findOneAndDelete(filter);
+    }
+
+    async list(
+      filter: FilterQuery<ModelDoc>,
+      paginationOptions: {
+        limit?: number;
+        skip?: number;
+      } = {
+        limit: 10,
+        skip: 0,
+      }
+    ): Promise<{
+      docs: ModelDoc[];
+      paginationData: {
+        total: number;
+        page: number;
+        perPage: number;
+      };
+    }> {
+      const docs = await this.model
+        .find(filter)
+        .limit(paginationOptions.limit)
+        .skip(paginationOptions.skip);
+
+      const total = await this.model.countDocuments(filter);
+      const paginationData = {
+        total: total,
+        page: paginationOptions.skip,
+        perPage: paginationOptions.limit,
+      };
+
+      return { docs, paginationData };
+    }
+
+    async findOne(filter: FilterQuery<ModelDoc>): Promise<ModelDoc | null> {
+      return this.model.findOne(filter);
+    }
+
+    async findOneOrFail(filter: FilterQuery<ModelDoc>): Promise<ModelDoc> {
+      const document = await this.findOne(filter);
+      if (!document) throw new HttpError(404, "No Matching Result Found.");
+
+      return document;
+    }
+  };
+};

src/modules/common/users/enums/roles.enum.ts

@@ -1,45 +0,0 @@
-export enum Role {
-  USER = "user"
-}
-export enum Gender {
-  MALE = "male",
-  FEMALE = "female"
-}
-export enum FitnessLevel {
-  BEGINNER = "beginner",
-  INTERMEDIATE = "intermediate",
-  ADVANCED = "advanced"
-}
-export enum FitnessGoal {
-  LOSE_WEIGHT = "lose weight",
-  GAIN_MUSCLE = "gain muscle",
-  GET_FITTER = "get fitter"
-}
-export enum WorkoutPlace {
-  GYM = "gym",
-  HOME = "home",
-  BOTH = "both"
-}
-export enum PreferredDay {
-  SATURDAY = "saturday",
-  SUNDAY = "sunday",
-  MONDAY = "monday",
-  TUESDAY = "tuesday",
-  WEDNESDAY = "wednesday",
-  THURSDAY = "thursday",
-  FRIDAY = "friday"
-}
-export enum PreferredEquipment {
-  BARBELLS = "barbells",
-  DUMBBELLS = "dumbbells",
-  GYM_MACHINES = "gym machines",
-  RESISTANCE_BAND = "resistance band",
-  BODYWEIGHT = "bodyweight"
-}
-export enum Injury {
-  NECK = "neck",
-  SHOULDERS = "shoulders",
-  BACK = "back",
-  ARMS = "arms",
-  KNEES = "knees"
-}

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

@@ -1,90 +0,0 @@
-import mongoose from "mongoose";
-import bcrypt from "bcrypt";
-export const saltrounds = 5;
-import { Role, Gender, FitnessLevel, FitnessGoal, WorkoutPlace, PreferredDay, PreferredEquipment, Injury } from "../enums/roles.enum";
-const { Schema } = mongoose;
-
-export interface IUser {
-    name: string;
-    email: string;
-    password: string;
-    image: object;
-    role: Role;
-    gender: string;
-    dob: Date;
-    height: number;
-    weight: number;
-    fitness_level: string;
-    preferences: {
-        fitness_goal: FitnessGoal;
-        target_weight: number;
-        workout_frequency: number;
-        preferred_days: [PreferredDay];
-        workout_place: WorkoutPlace;
-        preferred_equipment: [PreferredEquipment];
-    };
-    injuries: [Injury];
-  }
-  
-const userSchema = new Schema({
-    name: { type: String, required: true },
-    email: { type: String, required: true, unique: true, dropDups: true },
-    password: { type: String, required: true },
-    image: { type: Object },
-    gender: {
-        type: String,
-        enum: Gender,
-        required: true
-    },
-    height: { type: Number, required: true },
-    weight: { type: Number, required: true },
-    fitness_level: {
-        type: String,
-        enum: FitnessLevel,
-        required: true
-    },
-    preferences: {
-        fitness_goal: {
-            type: String,
-            enum: FitnessGoal,
-            required: true
-        },
-        target_weight: { type: Number, required: true },
-        workout_frequency: { type: Number, required: true },
-        preferred_days: [{
-            type: String,
-            enum: PreferredDay,
-            required: true
-        }],
-        workout_place: {
-            type: String,
-            enum: WorkoutPlace,
-            required: true
-        },
-        preferred_equipment: [{
-            type: String,
-            enum: PreferredEquipment,
-            required: true
-        }]
-    },
-    injuries: [{
-        type: String,
-        enum: Injury,
-        required: true
-    }],
-    dob: { type: Date },
-    role: {
-        type: String,
-        enum: Role,
-        default: Role.USER
-    }
-});
-
-userSchema.pre("save", async function (next) {
-    this.password = await bcrypt.hash(this.password, saltrounds);
-    next();
-});
-
-export type UserDocument = IUser & mongoose.Document;
-
-export const userModel = mongoose.model<IUser>("users", userSchema);

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

@@ -1,13 +1,12 @@
+import { asyncHandler } from "@helpers/async-handler";
+import { paramsValidator, bodyValidator } from "@helpers/validation.helper";
+import { BaseController } from "@lib/controllers/controller.base";
+import { Prefix } from "@lib/decorators/prefix.decorator";
 import { Request, Response, Router } from "express";
-import { BaseController } from "../../../../lib/controllers/controller.base";
 import { AdminsService } from "../services/admins.service";
 import { createAdminSchema } from "../validations/create-admin.validation";
-import {
-  bodyValidator,
-  paramsValidator,
-} from "../../../../helpers/validation.helper";
-import { asyncHandler } from "../../../../helpers/async-handler";
-import { Prefix } from "../../../../lib/decorators/prefix.decorator";
+import { parsePaginationQuery } from "@helpers/pagination";
+import { JsonResponse } from "@lib/responses/json-response";
 
 @Prefix("/console/admins")
 export class AdminsController extends BaseController {
@@ -34,36 +33,61 @@ export class AdminsController extends BaseController {
     );
   }
 
-  list = (_, res: Response) => {
-    this.adminsService
-      .list({})
-      .then((result) => {
-        res.status(result.code).json(result);
-      })
-      .catch((err) => {
-        res.status(500).json(err);
-      });
+  list = async (req: Request, res: Response) => {
+    const paginationQuery = parsePaginationQuery(req.query);
+    const { docs, paginationData } = await this.adminsService.list(
+      {},
+      paginationQuery
+    );
+    const response = new JsonResponse({
+      data: docs,
+      meta: paginationData,
+    });
+    return res.json(response);
   };
 
   get = async (req: Request, res: Response) => {
-    const data = await this.adminsService.get({
+    const data = await this.adminsService.findOneOrFail({
       _id: req.params.id,
     });
-    res.json(data);
+    const response = new JsonResponse({
+      data,
+    });
+    res.json(response);
   };
 
   create = async (req: Request, res: Response) => {
-    const data = await this.adminsService.create(req.body);
-    res.json(data);
+    const admin = await this.adminsService.create(req.body);
+    const response = new JsonResponse({
+      data: admin,
+    });
+    res.json(response);
   };
 
   update = async (req: Request, res: Response) => {
-    const data = await this.adminsService.update(req.params.id, req.body);
-    res.json(data);
+    const admin = await this.adminsService.update(
+      {
+        _id: req.params.id,
+      },
+      req.body
+    );
+
+    const response = new JsonResponse({
+      data: admin,
+    });
+
+    res.json(response);
   };
 
   delete = async (req: Request, res: Response) => {
-    const data = await this.adminsService.remove(req.params.id);
-    res.json(data);
+    const admin = await this.adminsService.delete({
+      _id: req.params.id,
+    });
+
+    const response = new JsonResponse({
+      data: admin,
+    });
+
+    res.json(response);
   };
 }

src/modules/console/admins/models/admin.model.ts

@@ -1,6 +1,5 @@
 import mongoose from "mongoose";
 import bcrypt from "bcrypt";
-import { Role } from "../enums/roles.enum";
 import { config } from "../../../../configs/config";
 const { Schema } = mongoose;
 
@@ -9,7 +8,6 @@ export interface IAdmin {
   email: string;
   password: string;
   image: object;
-  role: Role;
   gender: string;
   dob: Date;
 }
@@ -19,10 +17,6 @@ const AdminSchema = new Schema({
   email: { type: String, required: true, unique: true, dropDups: true },
   password: { type: String, required: true },
   image: { type: Object, default: {} },
-  role: {
-    type: String,
-    enum: Role,
-  },
   gender: { type: String, required: true },
   dob: { type: Date },
 });
@@ -32,4 +26,6 @@ AdminSchema.pre("save", async function (next) {
   next();
 });
 
-export const Admin = mongoose.model<IAdmin>("admins", AdminSchema);
+export type AdminDocument = mongoose.Document & IAdmin;
+
+export const Admin = mongoose.model<AdminDocument>("admins", AdminSchema);

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

@@ -1,267 +1,4 @@
-import bcrypt from "bcrypt";
-import { Admin, IAdmin } from "../models/admin.model";
-import { config } from "../../../../configs/config";
-import { FilterQuery } from "mongoose";
+import { Admin } from "../models/admin.model";
+import { CrudService } from "@lib/services/crud.service";
 
-export class AdminsService {
-  async find(filterObject) {
-    try {
-      const resultObject = await Admin.findOne(filterObject).lean();
-
-      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: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async get(filterObject: FilterQuery<IAdmin>) {
-    try {
-      const resultObject = await Admin.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: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async list(filterObject) {
-    try {
-      const resultArray = await Admin.find(filterObject)
-        .lean()
-        .select("-password");
-
-      if (!resultArray)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      const count = await Admin.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 create(formObject) {
-    try {
-      if (formObject.email) formObject.email = formObject.email.toLowerCase();
-      const resultObject = new Admin(formObject);
-      await resultObject.save();
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 500,
-          error: "Unexpected Error Happened.",
-        };
-
-      return {
-        success: true,
-        code: 201,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async update(_id, formObject) {
-    try {
-      const existingObject = await this.find({ _id });
-      if (!existingObject.success)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      if (formObject.email) {
-        formObject.email = formObject.email.toLowerCase();
-        const duplicate = await this.find({ email: formObject.email });
-        if (
-          duplicate.success &&
-          duplicate.record._id.toString() !=
-            existingObject.record._id.toString()
-        )
-          return {
-            success: false,
-            error: "This Email is taken by another user",
-            code: 409,
-          };
-      }
-
-      const resultObject = await Admin.findByIdAndUpdate({ _id }, formObject);
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 500,
-          error: "Unexpected Error Happened.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async remove(_id) {
-    try {
-      const resultObject = await Admin.findByIdAndDelete({ _id });
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async comparePassword(emailString, passwordString) {
-    try {
-      emailString = emailString.toLowerCase();
-      const existingObject = await this.find({ email: emailString });
-
-      if (!existingObject.success)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      const matchingPasswords = await bcrypt.compare(
-        passwordString,
-        existingObject.record.password
-      );
-      if (!matchingPasswords)
-        return {
-          success: false,
-          code: 409,
-          error: "Incorrect Password.",
-        };
-
-      return {
-        success: true,
-        record: existingObject.record,
-        code: 200,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async resetPassword(emailString, newPasswordString) {
-    try {
-      emailString = emailString.toLowerCase();
-      const existingObject = await this.find({ email: emailString });
-
-      if (!existingObject.success)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      const hashedPassword = await bcrypt.hash(
-        newPasswordString,
-        config.saltRounds
-      );
-      const resultObject = await Admin.findOneAndUpdate(
-        { email: emailString },
-        { password: hashedPassword }
-      );
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 500,
-          error: "Unexpected Error Happened.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-}
+export class AdminsService extends CrudService(Admin) {}

src/modules/console/admins/validations/create-admin.validation.ts

@@ -1,5 +1,5 @@
+import { Role } from "@common/enums/role.enum";
 import * as joi from "joi";
-import { Role } from "../enums/roles.enum";
 import { createSchema } from "src/helpers/create-schema";
 
 export interface ICreateAdmin {

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

@@ -1,4 +1,4 @@
-import { userRegisterSchema } from "src/modules/common/users/validation/user-register.validation";
+import { userRegisterSchema } from "src/common/validations/user-register.validation";
 import { asyncHandler } from "../../../../helpers/async-handler";
 import { JwtHelper } from "../../../../helpers/jwt.helper";
 import { bodyValidator } from "../../../../helpers/validation.helper";
@@ -6,6 +6,7 @@ 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";
+import { Request, Response } from "express";
 
 const allowedRoles = ["superAdmin", "admin"];
 
@@ -22,10 +23,11 @@ export class AdminUsersController extends BaseController {
     );
   }
 
-  create = async (req, res) => {
+  create = async (req: Request, res: Response) => {
     let user = await this.usersService.create(req.body);
-    return new JsonResponse({
+    const response = new JsonResponse({
       data: user,
     });
+    return res.json(response);
   };
 }

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

@@ -1,3 +1,4 @@
-import { BaseUsersService } from "../../../common/users/services/users.base.service";
+import { userModel } from "@common/models/user.model";
+import { CrudService } from "@lib/services/crud.service";
 
-export class UsersService extends BaseUsersService {}
+export class UsersService extends CrudService(userModel) {}

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

@@ -4,10 +4,9 @@ import { bodyValidator } from "../../../../helpers/validation.helper";
 import { asyncHandler } from "../../../../helpers/async-handler";
 import { Prefix } from "../../../../lib/decorators/prefix.decorator";
 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";
+import { userRegisterSchema, IUserRegister } from "src/common/validations/user-register.validation";
 
 @Prefix("/users/auth")
 export class UsersAuthController extends BaseController {
@@ -27,16 +26,18 @@ export class UsersAuthController extends BaseController {
   }
 
   register = async (req: Request, res: Response) => {
-    let user = await this.authService.create(req.body as IUser);
-    return new JsonResponse({
+    const user = await this.authService.register(req.body as IUserRegister);
+    const response = new JsonResponse({
       data: user,
     });
+    return res.json(response);
   };
 
-  login = async (req, res) => {
+  login = async (req: Request, res: Response) => {
     const { user, token } = await this.authService.login(req.body);
-    return new JsonResponse({
+    const response = new JsonResponse({
       data: { user, token },
     });
+    return res.json(response);
   };
 }

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

@@ -1,10 +1,16 @@
-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";
+import { userModel } from "src/common/models/user.model";
+import { IUserRegister } from "src/common/validations/user-register.validation";
+import { CrudService } from "@lib/services/crud.service";
+
+export class UsersAuthService extends CrudService(userModel) {
+  async register(createParams: IUserRegister) {
+    return this.create(createParams);
+  }
 
-export class UsersAuthService extends BaseUsersService {
   async login(loginRequest: ILogin) {
     const user = await this.findOneOrFail({ email: loginRequest.email });
     const isPasswordCorrect = await bcrypt.compare(

tsconfig.json

@@ -10,7 +10,6 @@
     "experimentalDecorators": true,
     "baseUrl": ".",
     "paths": {
-      "src/*": ["src/*"],
       "@lib/*": ["src/lib/*"],
       "@common/*": ["src/common/*"],
       "@configs/*": ["src/configs/*"],