exp-node-server 1.1.0

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

@@ -0,0 +1,125 @@
+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: httpStatus.OK,
+        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: httpStatus.OK,
+        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: httpStatus.OK,
+        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: httpStatus.OK,
+        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: httpStatus.OK,
+        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: httpStatus.OK,
+        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: httpStatus.OK,
+        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: httpStatus.OK,
+        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: httpStatus.OK,
+        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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,306 @@
+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 mongoose from "mongoose";
+import { jwtHelpers } from "../../utils/JWT";
+import { configs } from "../../configs";
+import { JwtPayload, Secret } from "jsonwebtoken";
+import sendMail from "../../utils/mail_sender";
+import { isAccountExist } from "../../utils/isAccountExist";
+// 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: `
+            <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', 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
+    };
+
+}
+
+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', 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 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!!',
+            httpStatus.UNAUTHORIZED,
+        );
+    }
+
+    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!!", 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)
+    }
+
+}
+
+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
+}