exp-node-server 1.1.7 → 2.0.0

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

@@ -1,127 +0,0 @@
-import { configs } from "../../configs";
-import catchAsync from "../../utils/catch_async";
-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);
-    manageResponse(res, {
-        success: true,
-        message: "Account created successful",
-        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",
-        httpOnly: true,
-    });
-    manageResponse(res, {
-        statusCode: 200,
-        success: true,
-        message: "User is logged in successful !",
-        data: {
-            accessToken: result.accessToken,
-            role: result?.role,
-        },
-    });
-});
-
-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: 200,
-        success: true,
-        message: "User profile fetched successfully!",
-        data: result,
-    });
-});
-
-const refresh_token = catchAsync(async (req, res) => {
-    const { refreshToken } = req.cookies;
-    const result = await auth_services.refresh_token_from_db(refreshToken);
-    manageResponse(res, {
-        statusCode: 200,
-        success: true,
-        message: "Refresh token generated successfully!",
-        data: result,
-    });
-});
-
-const change_password = catchAsync(async (req, res) => {
-    const user = req?.user;
-    const result = await auth_services.change_password_from_db(user!, req.body);
-
-    manageResponse(res, {
-        statusCode: 200,
-        success: true,
-        message: "Password changed successfully!",
-        data: result,
-    });
-});
-
-const forget_password = catchAsync(async (req, res) => {
-    const { email } = req?.body;
-    await auth_services.forget_password_from_db(email);
-    manageResponse(res, {
-        statusCode: 200,
-        success: true,
-        message: "Reset password link sent to your email!",
-        data: null,
-    });
-});
-
-const reset_password = catchAsync(async (req, res) => {
-    const { token, newPassword, email } = req.body;
-    const result = await auth_services.reset_password_into_db(
-        token,
-        email,
-        newPassword,
-    );
-    manageResponse(res, {
-        statusCode: 200,
-        success: true,
-        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);
-
-    manageResponse(res, {
-        statusCode: 200,
-        success: true,
-        message: "Account Verification successful.",
-        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,
-    );
-    manageResponse(res, {
-        statusCode: 200,
-        success: true,
-        message: "New Verification link is send on email.",
-        data: result,
-    });
-});
-
-export const auth_controllers = {
-    register_user,
-    login_user,
-    get_my_profile,
-    refresh_token,
-    change_password,
-    reset_password,
-    forget_password,
-    verified_account,
-    get_new_verification_link,
-};

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

@@ -1,24 +0,0 @@
-export type TAccount = {
-    email: string;
-    password: string;
-    lastPasswordChange?: Date;
-    isDeleted?: boolean;
-    accountStatus?: "ACTIVE" | "INACTIVE" | "SUSPENDED";
-    role?: "USER" | "ADMIN",
-    isVerified?: boolean,
-}
-
-
-export interface TRegisterPayload extends TAccount {
-    name: string
-}
-
-export type TLoginPayload = {
-    email: string;
-    password: string
-}
-
-export type TJwtUser = {
-    email: string,
-    role?: "USER" | "ADMIN",
-}

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

@@ -1,46 +0,0 @@
-import { Router } from "express";
-import { auth_controllers } from "./auth.controller";
-import RequestValidator from "../../middlewares/request_validator";
-import { auth_validation } from "./auth.validation";
-import auth from "../../middlewares/auth";
-
-const authRoute = Router()
-
-authRoute.post("/register", RequestValidator(auth_validation.register_validation), auth_controllers.register_user)
-authRoute.post("/login", RequestValidator(auth_validation.login_validation), auth_controllers.login_user)
-
-authRoute.get(
-    '/me',
-    auth("ADMIN", "USER"),
-    auth_controllers.get_my_profile,
-);
-
-authRoute.post('/refresh-token', auth_controllers.refresh_token);
-authRoute.post(
-    '/change-password',
-    auth("ADMIN", "USER"),
-    RequestValidator(auth_validation.changePassword),
-    auth_controllers.change_password,
-);
-authRoute.post(
-    '/forgot-password',
-    RequestValidator(auth_validation.forgotPassword),
-    auth_controllers.forget_password,
-);
-authRoute.post(
-    '/reset-password',
-    RequestValidator(auth_validation.resetPassword),
-    auth_controllers.reset_password,
-);
-
-authRoute.post(
-    "/verified-account",
-    RequestValidator(auth_validation.verified_account),
-    auth_controllers.verified_account
-)
-authRoute.post(
-    "/new-verification-link",
-    RequestValidator(auth_validation.forgotPassword),
-    auth_controllers.get_new_verification_link
-)
-export default authRoute;

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

@@ -1,19 +0,0 @@
-import { model, Schema } from "mongoose";
-import { TAccount } from "./auth.interface";
-
-
-const authSchema = new Schema<TAccount>({
-    email: { type: String, required: true },
-    password: { type: String, required: true },
-    lastPasswordChange: { type: String },
-    isDeleted: { type: Boolean, default: false },
-    accountStatus: { type: String, default: "ACTIVE" },
-    role: { type: String, default: "USER" },
-    isVerified: { type: Boolean, default: false }
-}, {
-    versionKey: false,
-    timestamps: true
-});
-
-
-export const Account_Model = model("account", authSchema)

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

@@ -1,324 +0,0 @@
-import bcrypt from "bcrypt";
-import { JwtPayload, Secret } from "jsonwebtoken";
-import mongoose from "mongoose";
-import { configs } from "../../configs";
-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!!", 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>
-
-
-            <div style="text-align: center; margin: 30px 0;">
-                <a href="${verificationLink}" target="_blank"
-                    style="background-color: #4CAF50; color: #ffffff; padding: 14px 28px; text-decoration: none; font-weight: bold; border-radius: 5px; display: inline-block; font-size: 18px;"
-                    class="btn">
-                    Verify My Email
-                </a>
-            </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();
-  }
-};
-
-// 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", 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 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,
-  );
-
-  return accessToken;
-};
-
-const change_password_from_db = async (
-  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", 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 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,
-  });
-
-  return "Check your email for reset link";
-};
-
-const reset_password_into_db = async (
-  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!!",
-      403,
-    );
-  }
-
-  const isAccountExists = await isAccountExist(email);
-
-  const hashedPassword: string = await bcrypt.hash(newPassword, 10);
-
-  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!!", 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 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>
-
-
-            <div style="text-align: center; margin: 30px 0;">
-                <a href="${verificationLink}" target="_blank"
-                    style="background-color: #4CAF50; color: #ffffff; padding: 14px 28px; text-decoration: none; font-weight: bold; border-radius: 5px; display: inline-block; font-size: 18px;"
-                    class="btn">
-                    Verify My Email
-                </a>
-            </div>
-
-            <p>If you did not create this account, please ignore this email.</p>
-            `,
-  });
-
-  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,
-};