Merge pull request #29 from Modarb-Ai-Trainer:feat/admin-auth

src/common/models/user.model.ts

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

src/helpers/jwt.helper.ts

@@ -1,8 +1,9 @@
 import jwt from "jsonwebtoken";
 import { config } from "../configs/config";
+import { IJwtLoginPayload } from "@common/interfaces/jwt-payload.interface";
 
 export class JwtHelper {
-  static generateToken(payload: any) {
+  static generateToken(payload: IJwtLoginPayload) {
     return jwt.sign(payload, config.jwt.secret, {
       expiresIn: config.jwt.expiresIn,
     });

src/lib/guards/gen-guard.ts

@@ -0,0 +1,49 @@
+import { IJwtLoginPayload } from "@common/interfaces/jwt-payload.interface";
+import { JwtPayload, verify } from "jsonwebtoken";
+import { HttpError } from "@lib/error-handling/http-error";
+import { NextFunction, Request, Response } from "express";
+import { config } from "@configs/config";
+
+type OptionalIfUndefined<T> = [T] extends [undefined]
+  ? (args?: T) => void
+  : (args: T) => void;
+
+export const genGuard =
+  <T = undefined>(
+    validationMethod?: (
+      validationArgs: T,
+      payload: IJwtLoginPayload,
+      req: Request,
+      res: Response
+    ) => boolean | Promise<boolean>
+  ): OptionalIfUndefined<T> =>
+  (args: T) =>
+  async (req: Request, res: Response, next: NextFunction) => {
+    // get token from cookie
+    const token = req.headers.authorization?.split(" ")[1];
+    let payload: IJwtLoginPayload;
+
+    // validate token
+    if (!token) {
+      throw new HttpError(401, "Unauthorized");
+    }
+
+    try {
+      payload = verify(token, config.jwt.secret);
+    } catch (err) {
+      throw new HttpError(401, "Unauthorized");
+    }
+
+    if (
+      validationMethod &&
+      !(await validationMethod(args, payload, req, res))
+    ) {
+      throw new HttpError(401, "Unauthorized");
+    }
+
+    // inject payload in request
+    (req as unknown as { jwtPayload: JwtPayload }).jwtPayload = payload;
+
+    // go on
+    next();
+  };

src/modules/console/common/guards/admins.guard.ts

@@ -1,45 +1,23 @@
-import { JwtPayload, verify } from "jsonwebtoken";
-import { Request } from "express";
 import { Role } from "@common/enums/role.enum";
-import { HttpError } from "@lib/error-handling/http-error";
-import { config } from "@configs/config";
 import { IJwtLoginPayload } from "@common/interfaces/jwt-payload.interface";
+import { genGuard } from "@lib/guards/gen-guard";
 
 type AdminGuardMiddlewareProps = {
   roles?: Role[];
 };
 
-export const AdminGuardMiddleware =
-  (props?: AdminGuardMiddlewareProps) => (req: Request, res, next) => {
-    // get token from cookie
-    const token = req.headers.authorization?.split(" ")[1];
-    let payload: IJwtLoginPayload;
-
-    // validate token
-    if (!token) {
-      throw new HttpError(401, "Unauthorized");
-    }
-
-    try {
-      payload = verify(token, config.jwt.secret);
-    } catch (err) {
-      throw new HttpError(401, "Unauthorized");
-    }
-
+export const AdminGuardMiddleware = genGuard(
+  async (args: AdminGuardMiddlewareProps, payload: IJwtLoginPayload) => {
     if (payload.type !== "admin") {
-      throw new HttpError(401, "Unauthorized");
+      return false;
     }
 
-    // check roles
-    if (props?.roles && props?.roles.length > 0) {
-      if (!props.roles.includes(payload.role)) {
-        throw new HttpError(401, "Unauthorized");
+    if (args?.roles && args?.roles.length > 0) {
+      if (!args.roles.includes(payload.role)) {
+        return false;
       }
     }
 
-    // inject payload in request
-    (req as unknown as { jwtPayload: JwtPayload }).jwtPayload = payload;
-
-    // go on
-    next();
-  };
+    return true;
+  }
+);

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

@@ -0,0 +1,34 @@
+import { asyncHandler } from "@helpers/async-handler";
+import { serialize } from "@helpers/serialize";
+import { bodyValidator } from "@helpers/validation.helper";
+import { BaseController } from "@lib/controllers/controller.base";
+import { Prefix } from "@lib/decorators/prefix.decorator";
+import { JsonResponse } from "@lib/responses/json-response";
+import { Request, Response } from "express";
+import { loginValidationSchema } from "modules/users/modules/auth/validation/login.validation";
+import { ConsoleAuthService } from "../services/auth.service";
+import { AdminSerialization } from "modules/console/common/serializers/admin.serialization";
+
+@Prefix("/console/auth")
+export class ConsoleAuthController extends BaseController {
+  private authService = new ConsoleAuthService();
+
+  public setRoutes(): void {
+    this.router.post(
+      "/login",
+      bodyValidator(loginValidationSchema),
+      asyncHandler(this.login)
+    );
+  }
+
+  login = async (req: Request, res: Response): Promise<Response> => {
+    const { admin, token } = await this.authService.login(req.body);
+
+    return JsonResponse.success(
+      {
+        data: { admin: serialize(admin, AdminSerialization), token },
+      },
+      res
+    );
+  };
+}

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

@@ -0,0 +1,25 @@
+import { CrudService } from "@lib/services/crud.service";
+import { Admin } from "modules/console/common/models/admin.model";
+import { ILogin } from "modules/users/modules/auth/validation/login.validation";
+import bcrypt from "bcrypt";
+import { HttpError } from "@lib/error-handling/http-error";
+import { JwtHelper } from "@helpers/jwt.helper";
+
+export class ConsoleAuthService extends CrudService(Admin) {
+  async login(loginRequest: ILogin) {
+    const admin = await this.findOneOrFail({ email: loginRequest.email });
+    const isPasswordCorrect = await bcrypt.compare(
+      loginRequest.password,
+      admin.password
+    );
+    if (!isPasswordCorrect) throw new HttpError(401, "Incorrect Password");
+    const token = JwtHelper.generateToken({
+      id: admin._id,
+      email: admin.email,
+      name: admin.name,
+      type: "admin",
+      role: admin.role,
+    });
+    return { admin: admin, token };
+  }
+}

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

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

src/modules/users/common/guards/users.guard.ts

@@ -1,34 +1,6 @@
-import { JwtPayload, verify } from "jsonwebtoken";
-import { Request } from "express";
-import { HttpError } from "@lib/error-handling/http-error";
-import { config } from "@configs/config";
 import { IJwtLoginPayload } from "@common/interfaces/jwt-payload.interface";
+import { genGuard } from "@lib/guards/gen-guard";
 
-export const UsersGuardMiddleware =
-  () => (req: Request, res, next) => {
-    // get token from cookie
-    const token = req.headers.authorization?.split(" ")[1];
-    let payload: IJwtLoginPayload;
-
-    // validate token
-    if (!token) {
-      throw new HttpError(401, "Unauthorized");
-    }
-
-    try {
-      payload = verify(token, config.jwt.secret);
-    } catch (err) {
-      throw new HttpError(401, "Unauthorized");
-    }
-
-    if (payload.type !== "user") {
-      throw new HttpError(401, "Unauthorized");
-    }
-
-
-    // inject payload in request
-    (req as unknown as { jwtPayload: JwtPayload }).jwtPayload = payload;
-
-    // go on
-    next();
-  };
+export const UsersGuardMiddleware = genGuard(
+  async (args, payload: IJwtLoginPayload) => payload.type === "user"
+);

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

@@ -2,11 +2,11 @@ import bcrypt from "bcrypt";
 import { ILogin } from "../validation/login.validation";
 import { HttpError } from "@lib/error-handling/http-error";
 import { JwtHelper } from "@helpers/jwt.helper";
-import { userModel } from "@common/models/user.model";
+import { User } from "@common/models/user.model";
 import { IUserRegister } from "@common/validations/user-register.validation";
 import { CrudService } from "@lib/services/crud.service";
 
-export class UsersAuthService extends CrudService(userModel) {
+export class UsersAuthService extends CrudService(User) {
   async register(createParams: IUserRegister) {
     return this.create(createParams);
   }
@@ -18,7 +18,12 @@ export class UsersAuthService extends CrudService(userModel) {
       user.password
     );
     if (!isPasswordCorrect) throw new HttpError(401, "Incorrect Password");
-    const token = JwtHelper.generateToken({ id: user._id, role: user.role });
+    const token = JwtHelper.generateToken({
+      id: user._id,
+      email: user.email,
+      name: user.name,
+      type: "user",
+    });
     return { user, token };
   }
 }

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

@@ -2,11 +2,11 @@ import bcrypt from "bcrypt";
 import { ILogin } from "../validation/login.validation";
 import { HttpError } from "@lib/error-handling/http-error";
 import { JwtHelper } from "@helpers/jwt.helper";
-import { userModel } from "@common/models/user.model";
+import { User } from "@common/models/user.model";
 import { IUserRegister } from "@common/validations/user-register.validation";
 import { CrudService } from "@lib/services/crud.service";
 
-export class UsersAuthService extends CrudService(userModel) {
+export class UsersAuthService extends CrudService(User) {
   async register(createParams: IUserRegister) {
     return this.create(createParams);
   }
@@ -18,7 +18,12 @@ export class UsersAuthService extends CrudService(userModel) {
       user.password
     );
     if (!isPasswordCorrect) throw new HttpError(401, "Incorrect Password");
-    const token = JwtHelper.generateToken({ id: user._id, role: user.role });
+    const token = JwtHelper.generateToken({
+      id: user._id,
+      email: user.email,
+      name: user.name,
+      type: "user",
+    });
     return { user, token };
   }
 }