exp-node-server 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exp-node-server",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "type": "module",
   "bin": {
     "exp-node-server": "./bin/cli.js"

package/templates/mongoose/src/app/modules/auth/auth.controller.ts

@@ -4,29 +4,29 @@ import manageResponse from "../../utils/manage_response";
 import { auth_services } from "./auth.service";
 
 const register_user = catchAsync(async (req, res) => {
-    const result = await auth_services.register_user_into_db(req?.body)
+    const result = await auth_services.register_user_into_db(req?.body);
     manageResponse(res, {
         success: true,
         message: "Account created successful",
-        statusCode: httpStatus.OK,
-        data: result
-    })
-})
+        statusCode: 200,
+        data: result,
+    });
+});
 
 const login_user = catchAsync(async (req, res) => {
     const result = await auth_services.login_user_from_db(req.body);
 
-    res.cookie('refreshToken', result.refreshToken, {
-        secure: configs.env == 'production',
+    res.cookie("refreshToken", result.refreshToken, {
+        secure: configs.env == "production",
         httpOnly: true,
     });
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
-        message: 'User is logged in successful !',
+        message: "User is logged in successful !",
         data: {
             accessToken: result.accessToken,
-            role: result?.role
+            role: result?.role,
         },
     });
 });
@@ -35,9 +35,9 @@ const get_my_profile = catchAsync(async (req, res) => {
     const { email } = req.user!;
     const result = await auth_services.get_my_profile_from_db(email);
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
-        message: 'User profile fetched successfully!',
+        message: "User profile fetched successfully!",
         data: result,
     });
 });
@@ -46,9 +46,9 @@ const refresh_token = catchAsync(async (req, res) => {
     const { refreshToken } = req.cookies;
     const result = await auth_services.refresh_token_from_db(refreshToken);
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
-        message: 'Refresh token generated successfully!',
+        message: "Refresh token generated successfully!",
         data: result,
     });
 });
@@ -58,20 +58,20 @@ const change_password = catchAsync(async (req, res) => {
     const result = await auth_services.change_password_from_db(user!, req.body);
 
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
-        message: 'Password changed successfully!',
+        message: "Password changed successfully!",
         data: result,
     });
 });
 
 const forget_password = catchAsync(async (req, res) => {
-    const { email } = req?.body
+    const { email } = req?.body;
     await auth_services.forget_password_from_db(email);
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
-        message: 'Reset password link sent to your email!',
+        message: "Reset password link sent to your email!",
         data: null,
     });
 });
@@ -84,33 +84,35 @@ const reset_password = catchAsync(async (req, res) => {
         newPassword,
     );
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
-        message: 'Password reset successfully!',
+        message: "Password reset successfully!",
         data: result,
     });
 });
 
 const verified_account = catchAsync(async (req, res) => {
-    const result = await auth_services.verified_account_into_db(req?.body?.token)
+    const result = await auth_services.verified_account_into_db(req?.body?.token);
 
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
         message: "Account Verification successful.",
-        data: result
-    })
-})
+        data: result,
+    });
+});
 
 const get_new_verification_link = catchAsync(async (req, res) => {
-    const result = await auth_services.get_new_verification_link_from_db(req?.body?.email)
+    const result = await auth_services.get_new_verification_link_from_db(
+        req?.body?.email,
+    );
     manageResponse(res, {
-        statusCode: httpStatus.OK,
+        statusCode: 200,
         success: true,
         message: "New Verification link is send on email.",
-        data: result
-    })
-})
+        data: result,
+    });
+});
 
 export const auth_controllers = {
     register_user,
@@ -121,5 +123,5 @@ export const auth_controllers = {
     reset_password,
     forget_password,
     verified_account,
-    get_new_verification_link
-}
+    get_new_verification_link,
+};

package/templates/mongoose/src/app/modules/auth/auth.service.ts

@@ -1,64 +1,66 @@
-import { AppError } from "../../utils/app_error";
-import { TAccount, TLoginPayload, TRegisterPayload } from "./auth.interface";
-import { Account_Model } from "./auth.schema";
 import bcrypt from "bcrypt";
-import { TUser } from "../user/user.interface";
-import { User_Model } from "../user/user.schema";
+import { JwtPayload, Secret } from "jsonwebtoken";
 import mongoose from "mongoose";
-import { jwtHelpers } from "../../utils/JWT";
 import { configs } from "../../configs";
-import { JwtPayload, Secret } from "jsonwebtoken";
-import sendMail from "../../utils/mail_sender";
+import { AppError } from "../../utils/app_error";
 import { isAccountExist } from "../../utils/isAccountExist";
+import { jwtHelpers } from "../../utils/JWT";
+import sendMail from "../../utils/mail_sender";
+import { TUser } from "../user/user.interface";
+import { User_Model } from "../user/user.schema";
+import { TAccount, TLoginPayload, TRegisterPayload } from "./auth.interface";
+import { Account_Model } from "./auth.schema";
 // register user
 const register_user_into_db = async (payload: TRegisterPayload) => {
-    const session = await mongoose.startSession();
-    session.startTransaction();
-    try {
-        // Check if the account already exists
-        const isExistAccount = await Account_Model.findOne(
-            { email: payload?.email },
-            null,
-            { session }
-        );
-        if (isExistAccount) {
-            throw new AppError("Account already exist!!", httpStatus.BAD_REQUEST);
-        }
-
-        // Hash the password
-        const hashPassword = bcrypt.hashSync(payload?.password, 10);
-
-        // Create account
-        const accountPayload: TAccount = {
-            email: payload.email,
-            password: hashPassword,
-            lastPasswordChange: new Date()
-        };
-        const newAccount = await Account_Model.create([accountPayload], { session });
-
-        // Create user
-        const userPayload: TUser = {
-            name: payload.name,
-            accountId: newAccount[0]._id,
-        };
-        await User_Model.create([userPayload], { session });
-        // make verified link
-        const verifiedToken = jwtHelpers.generateToken(
-            {
-                email: payload?.email
-            },
-            configs.jwt.verified_token as Secret,
-            '5m'
-        );
-        const verificationLink = `${configs.jwt.front_end_url}/verified?token=${verifiedToken}`;
-        // Commit the transaction
-        await session.commitTransaction();
-        await sendMail({
-            to: payload?.email,
-            subject: "Thanks for creating account!",
-            textBody: `New Account successfully created on ${new Date().toLocaleDateString()}`,
-            name: payload?.name,
-            htmlBody: `
+  const session = await mongoose.startSession();
+  session.startTransaction();
+  try {
+    // Check if the account already exists
+    const isExistAccount = await Account_Model.findOne(
+      { email: payload?.email },
+      null,
+      { session },
+    );
+    if (isExistAccount) {
+      throw new AppError("Account already exist!!", 409);
+    }
+
+    // Hash the password
+    const hashPassword = bcrypt.hashSync(payload?.password, 10);
+
+    // Create account
+    const accountPayload: TAccount = {
+      email: payload.email,
+      password: hashPassword,
+      lastPasswordChange: new Date(),
+    };
+    const newAccount = await Account_Model.create([accountPayload], {
+      session,
+    });
+
+    // Create user
+    const userPayload: TUser = {
+      name: payload.name,
+      accountId: newAccount[0]._id,
+    };
+    await User_Model.create([userPayload], { session });
+    // make verified link
+    const verifiedToken = jwtHelpers.generateToken(
+      {
+        email: payload?.email,
+      },
+      configs.jwt.verified_token as Secret,
+      "5m",
+    );
+    const verificationLink = `${configs.jwt.front_end_url}/verified?token=${verifiedToken}`;
+    // Commit the transaction
+    await session.commitTransaction();
+    await sendMail({
+      to: payload?.email,
+      subject: "Thanks for creating account!",
+      textBody: `New Account successfully created on ${new Date().toLocaleDateString()}`,
+      name: payload?.name,
+      htmlBody: `
             <p>Thanks for creating an account with us. We’re excited to have you on board! Click the button below to
                 verify your email and activate your account:</p>
 
@@ -72,208 +74,224 @@ const register_user_into_db = async (payload: TRegisterPayload) => {
             </div>
 
             <p>If you did not create this account, please ignore this email.</p>
-            `
-        })
-        return newAccount;
-    } catch (error) {
-        console.log(error)
-        // Rollback the transaction
-        await session.abortTransaction();
-        throw error;
-    } finally {
-        session.endSession();
-    }
+            `,
+    });
+    return newAccount;
+  } catch (error) {
+    console.log(error);
+    // Rollback the transaction
+    await session.abortTransaction();
+    throw error;
+  } finally {
+    session.endSession();
+  }
 };
 
-
 // login user
 const login_user_from_db = async (payload: TLoginPayload) => {
-    // check account info 
-    const isExistAccount = await isAccountExist(payload?.email)
-
-    const isPasswordMatch = await bcrypt.compare(
-        payload.password,
-        isExistAccount.password,
-    );
-    if (!isPasswordMatch) {
-        throw new AppError('Invalid password', httpStatus.UNAUTHORIZED);
-    }
-    const accessToken = jwtHelpers.generateToken(
-        {
-            email: isExistAccount.email,
-            role: isExistAccount.role,
-        },
-        configs.jwt.access_token as Secret,
-        configs.jwt.access_expires as string,
-    );
-
-    const refreshToken = jwtHelpers.generateToken(
-        {
-            email: isExistAccount.email,
-            role: isExistAccount.role,
-        },
-        configs.jwt.refresh_token as Secret,
-        configs.jwt.refresh_expires as string,
-    );
-    return {
-        accessToken: accessToken,
-        refreshToken: refreshToken,
-        role: isExistAccount.role
-    };
-
-}
+  // check account info
+  const isExistAccount = await isAccountExist(payload?.email);
+
+  const isPasswordMatch = await bcrypt.compare(
+    payload.password,
+    isExistAccount.password,
+  );
+  if (!isPasswordMatch) {
+    throw new AppError("Invalid password", 401);
+  }
+  const accessToken = jwtHelpers.generateToken(
+    {
+      email: isExistAccount.email,
+      role: isExistAccount.role,
+    },
+    configs.jwt.access_token as Secret,
+    configs.jwt.access_expires as string,
+  );
+
+  const refreshToken = jwtHelpers.generateToken(
+    {
+      email: isExistAccount.email,
+      role: isExistAccount.role,
+    },
+    configs.jwt.refresh_token as Secret,
+    configs.jwt.refresh_expires as string,
+  );
+  return {
+    accessToken: accessToken,
+    refreshToken: refreshToken,
+    role: isExistAccount.role,
+  };
+};
 
 const get_my_profile_from_db = async (email: string) => {
-    const isExistAccount = await isAccountExist(email)
-    const accountProfile = await User_Model.findOne({ accountId: isExistAccount._id })
-    isExistAccount.password = ""
-    return {
-        account: isExistAccount,
-        profile: accountProfile
-    };
+  const isExistAccount = await isAccountExist(email);
+  const accountProfile = await User_Model.findOne({
+    accountId: isExistAccount._id,
+  });
+  isExistAccount.password = "";
+  return {
+    account: isExistAccount,
+    profile: accountProfile,
+  };
 };
 
 const refresh_token_from_db = async (token: string) => {
-    let decodedData;
-    try {
-        decodedData = jwtHelpers.verifyToken(
-            token,
-            configs.jwt.refresh_token as Secret,
-        );
-    } catch (err) {
-        throw new Error('You are not authorized!');
-    }
-
-    const userData = await Account_Model.findOne({ email: decodedData.email, status: "ACTIVE", isDeleted: false })
-
-    const accessToken = jwtHelpers.generateToken(
-        {
-            email: userData!.email,
-            role: userData!.role,
-        },
-        configs.jwt.access_token as Secret,
-        configs.jwt.access_expires as string,
+  let decodedData;
+  try {
+    decodedData = jwtHelpers.verifyToken(
+      token,
+      configs.jwt.refresh_token as Secret,
     );
+  } catch (err) {
+    throw new Error("You are not authorized!");
+  }
+
+  const userData = await Account_Model.findOne({
+    email: decodedData.email,
+    status: "ACTIVE",
+    isDeleted: false,
+  });
+
+  const accessToken = jwtHelpers.generateToken(
+    {
+      email: userData!.email,
+      role: userData!.role,
+    },
+    configs.jwt.access_token as Secret,
+    configs.jwt.access_expires as string,
+  );
 
-    return accessToken;
+  return accessToken;
 };
 
 const change_password_from_db = async (
-    user: JwtPayload,
-    payload: {
-        oldPassword: string;
-        newPassword: string;
-    },
+  user: JwtPayload,
+  payload: {
+    oldPassword: string;
+    newPassword: string;
+  },
 ) => {
-    const isExistAccount = await isAccountExist(user?.email)
-
-    const isCorrectPassword: boolean = await bcrypt.compare(
-        payload.oldPassword,
-        isExistAccount.password,
-    );
-
-    if (!isCorrectPassword) {
-        throw new AppError('Old password is incorrect', httpStatus.UNAUTHORIZED);
-    }
-
-    const hashedPassword: string = await bcrypt.hash(payload.newPassword, 10);
-    await Account_Model.findOneAndUpdate({ email: isExistAccount.email }, {
-        password: hashedPassword,
-        lastPasswordChange: Date()
-    })
-    return 'Password changed successful.';
+  const isExistAccount = await isAccountExist(user?.email);
+
+  const isCorrectPassword: boolean = await bcrypt.compare(
+    payload.oldPassword,
+    isExistAccount.password,
+  );
+
+  if (!isCorrectPassword) {
+    throw new AppError("Old password is incorrect", 401);
+  }
+
+  const hashedPassword: string = await bcrypt.hash(payload.newPassword, 10);
+  await Account_Model.findOneAndUpdate(
+    { email: isExistAccount.email },
+    {
+      password: hashedPassword,
+      lastPasswordChange: Date(),
+    },
+  );
+  return "Password changed successful.";
 };
 
 const forget_password_from_db = async (email: string) => {
-    const isAccountExists = await isAccountExist(email)
-    const resetToken = jwtHelpers.generateToken(
-        {
-            email: isAccountExists.email,
-            role: isAccountExists.role,
-        },
-        configs.jwt.reset_secret as Secret,
-        configs.jwt.reset_expires as string,
-    );
+  const isAccountExists = await isAccountExist(email);
+  const resetToken = jwtHelpers.generateToken(
+    {
+      email: isAccountExists.email,
+      role: isAccountExists.role,
+    },
+    configs.jwt.reset_secret as Secret,
+    configs.jwt.reset_expires as string,
+  );
 
-    const resetPasswordLink = `${configs.jwt.front_end_url}/reset?token=${resetToken}&email=${isAccountExists.email}`;
-    const emailTemplate = `<p>Click the link below to reset your password:</p><a href="${resetPasswordLink}">Reset Password</a>`;
+  const resetPasswordLink = `${configs.jwt.front_end_url}/reset?token=${resetToken}&email=${isAccountExists.email}`;
+  const emailTemplate = `<p>Click the link below to reset your password:</p><a href="${resetPasswordLink}">Reset Password</a>`;
 
-    await sendMail({
-        to: email,
-        subject: "Password reset successful!",
-        textBody: "Your password is successfully reset.",
-        htmlBody: emailTemplate
-    });
+  await sendMail({
+    to: email,
+    subject: "Password reset successful!",
+    textBody: "Your password is successfully reset.",
+    htmlBody: emailTemplate,
+  });
 
-    return 'Check your email for reset link';
+  return "Check your email for reset link";
 };
 
 const reset_password_into_db = async (
-    token: string,
-    email: string,
-    newPassword: string,
+  token: string,
+  email: string,
+  newPassword: string,
 ) => {
-    let decodedData: JwtPayload;
-    try {
-        decodedData = jwtHelpers.verifyToken(
-            token,
-            configs.jwt.reset_secret as Secret,
-        );
-    } catch (err) {
-        throw new AppError(
-            'Your reset link is expire. Submit new link request!!',
-            httpStatus.UNAUTHORIZED,
-        );
-    }
+  let decodedData: JwtPayload;
+  try {
+    decodedData = jwtHelpers.verifyToken(
+      token,
+      configs.jwt.reset_secret as Secret,
+    );
+  } catch (err) {
+    throw new AppError(
+      "Your reset link is expire. Submit new link request!!",
+      403,
+    );
+  }
 
-    const isAccountExists = await isAccountExist(email)
+  const isAccountExists = await isAccountExist(email);
 
-    const hashedPassword: string = await bcrypt.hash(newPassword, 10);
+  const hashedPassword: string = await bcrypt.hash(newPassword, 10);
 
-    await Account_Model.findOneAndUpdate({ email: isAccountExists.email }, {
-        password: hashedPassword,
-        lastPasswordChange: Date()
-    })
-    return 'Password reset successfully!';
+  await Account_Model.findOneAndUpdate(
+    { email: isAccountExists.email },
+    {
+      password: hashedPassword,
+      lastPasswordChange: Date(),
+    },
+  );
+  return "Password reset successfully!";
 };
 
 const verified_account_into_db = async (token: string) => {
-    try {
-        const { email } = jwtHelpers.verifyToken(token, configs.jwt.verified_token as string)
-        // check account is already verified or blocked
-        const isExistAccount = await Account_Model.findOne({ email })
-        // check account
-        if (!isExistAccount) {
-            throw new AppError("Account not found!!", httpStatus.NOT_FOUND)
-        }
-        if (isExistAccount.isDeleted) {
-            throw new AppError("Account deleted !!", httpStatus.BAD_REQUEST)
-        }
-        const result = await Account_Model.findOneAndUpdate({ email }, { isVerified: true }, { new: true })
-
-        return result
-    } catch (error) {
-        throw new AppError("Invalid or Expired token!!!", httpStatus.BAD_REQUEST)
+  try {
+    const { email } = jwtHelpers.verifyToken(
+      token,
+      configs.jwt.verified_token as string,
+    );
+    // check account is already verified or blocked
+    const isExistAccount = await Account_Model.findOne({ email });
+    // check account
+    if (!isExistAccount) {
+      throw new AppError("Account not found!!", 404);
+    }
+    if (isExistAccount.isDeleted) {
+      throw new AppError("Account deleted !!", 403);
     }
+    const result = await Account_Model.findOneAndUpdate(
+      { email },
+      { isVerified: true },
+      { new: true },
+    );
 
-}
+    return result;
+  } catch (error) {
+    throw new AppError("Invalid or Expired token!!!", 403);
+  }
+};
 
 const get_new_verification_link_from_db = async (email: string) => {
-    const isExistAccount = await isAccountExist(email)
+  const isExistAccount = await isAccountExist(email);
 
-    const verifiedToken = jwtHelpers.generateToken(
-        {
-            email
-        },
-        configs.jwt.verified_token as Secret,
-        '5m'
-    );
-    const verificationLink = `${configs.jwt.front_end_url}/verified?token=${verifiedToken}`;
-    await sendMail({
-        to: email,
-        subject: "New Verification link",
-        textBody: `New Account verification link is successfully created on ${new Date().toLocaleDateString()}`,
-        htmlBody: `
+  const verifiedToken = jwtHelpers.generateToken(
+    {
+      email,
+    },
+    configs.jwt.verified_token as Secret,
+    "5m",
+  );
+  const verificationLink = `${configs.jwt.front_end_url}/verified?token=${verifiedToken}`;
+  await sendMail({
+    to: email,
+    subject: "New Verification link",
+    textBody: `New Account verification link is successfully created on ${new Date().toLocaleDateString()}`,
+    htmlBody: `
             <p>Thanks for creating an account with us. We’re excited to have you on board! Click the button below to
                 verify your email and activate your account:</p>
 
@@ -287,20 +305,20 @@ const get_new_verification_link_from_db = async (email: string) => {
             </div>
 
             <p>If you did not create this account, please ignore this email.</p>
-            `
-    })
+            `,
+  });
 
-    return null
-}
+  return null;
+};
 
 export const auth_services = {
-    register_user_into_db,
-    login_user_from_db,
-    get_my_profile_from_db,
-    refresh_token_from_db,
-    change_password_from_db,
-    forget_password_from_db,
-    reset_password_into_db,
-    verified_account_into_db,
-    get_new_verification_link_from_db
-}
+  register_user_into_db,
+  login_user_from_db,
+  get_my_profile_from_db,
+  refresh_token_from_db,
+  change_password_from_db,
+  forget_password_from_db,
+  reset_password_into_db,
+  verified_account_into_db,
+  get_new_verification_link_from_db,
+};