express-mongodb-backend 1.0.1

package/dist/module-templates.js

@@ -0,0 +1,683 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_TEMPLATES = void 0;
+exports.MODULE_TEMPLATES = {
+    controller: `import { Request, Response } from "express";
+import httpStatus from "http-status-codes";
+import { catchAsync } from "../../utils/catchAsync";
+import { sendResponse } from "../../utils/sendResponse";
+import { __NAME__Service } from "./__name__.service";
+
+const create = catchAsync(async (req: Request, res: Response) => {
+  const doc = await __NAME__Service.create(req.body);
+  sendResponse(res, { statusCode: httpStatus.CREATED, success: true, message: "__name__ created", data: doc });
+});
+
+const getAll = catchAsync(async (_req: Request, res: Response) => {
+  const docs = await __NAME__Service.getAll();
+  sendResponse(res, { statusCode: httpStatus.OK, success: true, message: "__name__ list", data: docs });
+});
+
+const getById = catchAsync(async (req: Request, res: Response) => {
+  const doc = await __NAME__Service.getById(req.params.id);
+  sendResponse(res, { statusCode: httpStatus.OK, success: true, message: "__name__ found", data: doc });
+});
+
+const update = catchAsync(async (req: Request, res: Response) => {
+  const doc = await __NAME__Service.update(req.params.id, req.body);
+  sendResponse(res, { statusCode: httpStatus.OK, success: true, message: "__name__ updated", data: doc });
+});
+
+const remove = catchAsync(async (req: Request, res: Response) => {
+  const doc = await __NAME__Service.delete(req.params.id);
+  sendResponse(res, { statusCode: httpStatus.OK, success: true, message: "__name__ deleted", data: doc });
+});
+
+export const __NAME__Controller = { create, getAll, getById, update, remove };
+`,
+    interface: `export type __NAME__Status = "Active" | "Inactive";
+
+export default interface T__NAME__ {
+  name: string;
+  status: __NAME__Status;
+}
+`,
+    model: `import { model, Schema } from "mongoose";
+import type T__NAME__ from "./__name__.interface";
+
+const __name__Schema = new Schema<T__NAME__>(
+  {
+    name: { type: String, required: true, trim: true },
+    status: { type: String, enum: ["Active","Inactive"], default: "Active" }
+  },
+  { timestamps: true }
+);
+
+export const __NAME__ = model<T__NAME__>("__NAME__", __name__Schema);
+export default __NAME__;
+`,
+    service: `import httpStatus from "http-status-codes";
+import AppError from "../../errorHelpers/AppError";
+import { __NAME__ } from "./__name__.model";
+import type T__NAME__ from "./__name__.interface";
+
+export const __NAME__Service = {
+  create: async (payload: T__NAME__) => {
+    const doc = await __NAME__.create(payload);
+    return doc;
+  },
+
+  getAll: async () => {
+    return __NAME__.find().sort({ createdAt: -1 });
+  },
+
+  getById: async (id: string) => {
+    const doc = await __NAME__.findById(id);
+    if (!doc) throw new AppError(httpStatus.NOT_FOUND, "__name__ not found");
+    return doc;
+  },
+
+  update: async (id: string, payload: Partial<T__NAME__>) => {
+    const doc = await __NAME__.findByIdAndUpdate(id, payload, { new: true });
+    if (!doc) throw new AppError(httpStatus.NOT_FOUND, "__name__ not found");
+    return doc;
+  },
+
+  delete: async (id: string) => {
+    const doc = await __NAME__.findByIdAndDelete(id);
+    if (!doc) throw new AppError(httpStatus.NOT_FOUND, "__name__ not found");
+    return doc;
+  }
+};
+`,
+    validation: `import { z } from "zod";
+
+export const create__NAME__ZodSchema = z.object({
+  name: z.string().min(1),
+  status: z.enum(["Active","Inactive"]).optional()
+});
+
+export const update__NAME__ZodSchema = create__NAME__ZodSchema.partial();
+`,
+    route: `import express from "express";
+import { checkAuth } from "../../middlewares/checkAuth";
+import { validateRequest } from "../../middlewares/validateRequest";
+import { Role } from "../user/user.interface";
+import { __NAME__Controller } from "./__name__.controller";
+import { create__NAME__ZodSchema, update__NAME__ZodSchema } from "./__name__.validation";
+
+const router = express.Router();
+
+router.post("/", checkAuth(Role.ADMIN, Role.SUPER_ADMIN), validateRequest(create__NAME__ZodSchema), __NAME__Controller.create);
+router.get("/", checkAuth(Role.ADMIN, Role.SUPER_ADMIN), __NAME__Controller.getAll);
+router.get("/:id", checkAuth(Role.ADMIN, Role.SUPER_ADMIN), __NAME__Controller.getById);
+router.put("/:id", checkAuth(Role.ADMIN, Role.SUPER_ADMIN), validateRequest(update__NAME__ZodSchema), __NAME__Controller.update);
+router.delete("/:id", checkAuth(Role.ADMIN, Role.SUPER_ADMIN), __NAME__Controller.remove);
+
+export const __NAME__Routes = router;
+`,
+    user: {
+        constant: `export const userSearchableFields = ["name", "email", "address"];
+`,
+        interface: `import { Types } from "mongoose";
+
+export enum Role {
+  SUPER_ADMIN = "SUPER_ADMIN",
+  ADMIN = "ADMIN",
+  USER = "USER",
+  GUIDE = "GUIDE",
+}
+
+export interface IAuthProvider {
+  provider: "google" | "credentials";
+  providerId: string;
+}
+
+export enum IsActive {
+  ACTIVE = "ACTIVE",
+  INACTIVE = "INACTIVE",
+  BLOCKED = "BLOCKED",
+}
+
+export interface IUser {
+  _id?: Types.ObjectId;
+  name: string;
+  email: string;
+  password?: string;
+  phone?: string;
+  picture?: string;
+  address?: string;
+  isDeleted?: string;
+  isActive?: IsActive;
+  isVerified?: boolean;
+  role: Role;
+  auths: IAuthProvider[];
+  bookings?: Types.ObjectId[];
+  guides?: Types.ObjectId[];
+  createdAt?: Date;
+}
+`,
+        model: `import { model, Schema } from "mongoose";
+import { IAuthProvider, IsActive, IUser, Role } from "./user.interface";
+
+const authProviderSchema = new Schema<IAuthProvider>(
+  {
+    provider: { type: String, required: true },
+    providerId: { type: String, required: true },
+  },
+  { versionKey: false, _id: false }
+);
+
+const userSchema = new Schema<IUser>(
+  {
+    name: { type: String, required: true },
+    email: { type: String, required: true, unique: true },
+    password: { type: String },
+    role: { type: String, enum: Object.values(Role), default: Role.USER },
+    phone: { type: String },
+    picture: { type: String },
+    address: { type: String },
+    isDeleted: { type: Boolean, default: false },
+    isActive: { type: String, enum: Object.values(IsActive), default: IsActive.ACTIVE },
+    isVerified: { type: Boolean, default: false },
+    auths: [authProviderSchema],
+  },
+  { timestamps: true, versionKey: false }
+);
+
+export const User = model<IUser>("User", userSchema);
+`,
+        service: `import bcryptjs from "bcryptjs";
+import httpStatus from "http-status-codes";
+import { JwtPayload } from "jsonwebtoken";
+import { envVars } from "../../config/env";
+import AppError from "../../errorHelpers/AppError";
+import { QueryBuilder } from "../../utils/QueryBuilder";
+import { userSearchableFields } from "./user.constant";
+import { IAuthProvider, IUser, Role } from "./user.interface";
+import { User } from "./user.model";
+
+const createUser = async (payload: Partial<IUser>) => {
+  const { email, password, ...rest } = payload;
+
+  const isUserExist = await User.findOne({ email });
+  if (isUserExist) {
+    throw new AppError(httpStatus.BAD_REQUEST, "User Already Exist");
+  }
+
+  const hashedPassword = await bcryptjs.hash(
+    password as string,
+    Number(envVars.BCRYPT_SALT_ROUND)
+  );
+
+  const authProvider: IAuthProvider = { provider: "credentials", providerId: email as string };
+
+  const user = await User.create({
+    email,
+    password: hashedPassword,
+    auths: [authProvider],
+    ...rest,
+  });
+
+  return user;
+};
+
+const updateUser = async (userId: string, payload: Partial<IUser>, decodedToken: JwtPayload) => {
+  if (decodedToken.role === Role.USER || decodedToken.role === Role.GUIDE) {
+    if (userId !== decodedToken.userId) {
+      throw new AppError(401, "You are not authorized");
+    }
+  }
+
+  const ifUserExist = await User.findById(userId);
+  if (!ifUserExist) {
+    throw new AppError(httpStatus.NOT_FOUND, "User Not Found");
+  }
+
+  if (decodedToken.role === Role.ADMIN && ifUserExist.role === Role.SUPER_ADMIN) {
+    throw new AppError(401, "You are not authorized");
+  }
+
+  if (payload.role) {
+    if (decodedToken.role === Role.USER || decodedToken.role === Role.GUIDE) {
+      throw new AppError(httpStatus.FORBIDDEN, "You are not authorized");
+    }
+  }
+
+  if (payload.isActive || payload.isDeleted || payload.isVerified) {
+    if (decodedToken.role === Role.USER || decodedToken.role === Role.GUIDE) {
+      throw new AppError(httpStatus.FORBIDDEN, "You are not authorized");
+    }
+  }
+
+  const newUpdatedUser = await User.findByIdAndUpdate(userId, payload, {
+    new: true,
+    runValidators: true,
+  });
+
+  return newUpdatedUser;
+};
+
+const getAllUsers = async (query: Record<string, string>) => {
+  const queryBuilder = new QueryBuilder(User.find(), query);
+
+  const usersData = queryBuilder
+    .filter()
+    .search(userSearchableFields)
+    .sort()
+    .fields()
+    .paginate();
+
+  const [data, meta] = await Promise.all([usersData.build(), queryBuilder.getMeta()]);
+
+  return { data, meta };
+};
+
+const getSingleUser = async (id: string) => {
+  const user = await User.findById(id).select("-password");
+  return { data: user };
+};
+
+const getMe = async (userId: string) => {
+  const user = await User.findById(userId).select("-password");
+  return { data: user };
+};
+
+export const UserServices = {
+  createUser,
+  getAllUsers,
+  getSingleUser,
+  updateUser,
+  getMe,
+};
+`,
+        controller: `/* eslint-disable @typescript-eslint/no-unused-vars */
+import { NextFunction, Request, Response } from "express";
+import httpStatus from "http-status-codes";
+import { JwtPayload } from "jsonwebtoken";
+import { catchAsync } from "../../utils/catchAsync";
+import { sendResponse } from "../../utils/sendResponse";
+import { UserServices } from "./user.service";
+
+const createUser = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const user = await UserServices.createUser(req.body);
+
+  sendResponse(res, {
+    success: true,
+    statusCode: httpStatus.CREATED,
+    message: "User Created Successfully",
+    data: user,
+  });
+});
+
+const updateUser = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const userId = req.params.id;
+  const verifiedToken = req.user;
+  const payload = req.body;
+
+  const user = await UserServices.updateUser(userId, payload, verifiedToken as JwtPayload);
+
+  sendResponse(res, {
+    success: true,
+    statusCode: httpStatus.CREATED,
+    message: "User Updated Successfully",
+    data: user,
+  });
+});
+
+const getAllUsers = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const query = req.query;
+  const result = await UserServices.getAllUsers(query as Record<string, string>);
+
+  sendResponse(res, {
+    success: true,
+    statusCode: httpStatus.CREATED,
+    message: "All Users Retrieved Successfully",
+    data: result.data,
+    meta: result.meta,
+  });
+});
+
+const getMe = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const decodedToken = req.user as JwtPayload;
+  const result = await UserServices.getMe(decodedToken.userId);
+
+  sendResponse(res, {
+    success: true,
+    statusCode: httpStatus.CREATED,
+    message: "Your profile Retrieved Successfully",
+    data: result.data,
+  });
+});
+
+const getSingleUser = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const id = req.params.id;
+  const result = await UserServices.getSingleUser(id);
+
+  sendResponse(res, {
+    success: true,
+    statusCode: httpStatus.CREATED,
+    message: "User Retrieved Successfully",
+    data: result.data,
+  });
+});
+
+export const UserControllers = {
+  createUser,
+  getAllUsers,
+  getSingleUser,
+  updateUser,
+  getMe,
+};
+`,
+        validation: `import z from "zod";
+import { IsActive, Role } from "./user.interface";
+
+export const createUserZodSchema = z.object({
+  name: z.string({ invalid_type_error: "Name must be string" }).min(2).max(50),
+  email: z.string({ invalid_type_error: "Email must be string" }).email().min(5).max(100),
+  password: z
+    .string({ invalid_type_error: "Password must be string" })
+    .min(8)
+    .regex(/^(?=.*[A-Z])/, { message: "Password must contain at least 1 uppercase letter." })
+    .regex(/^(?=.*[!@#$%^&*])/, { message: "Password must contain at least 1 special character." })
+    .regex(/^(?=.*\\d)/, { message: "Password must contain at least 1 number." }),
+  phone: z
+    .string({ invalid_type_error: "Phone Number must be string" })
+    .regex(/^(?:\\+8801\\d{9}|01\\d{9})$/, {
+      message: "Phone number must be valid for Bangladesh. Format: +8801XXXXXXXXX or 01XXXXXXXXX",
+    })
+    .optional(),
+  address: z.string({ invalid_type_error: "Address must be string" }).max(200).optional(),
+});
+
+export const updateUserZodSchema = z.object({
+  name: z.string({ invalid_type_error: "Name must be string" }).min(2).max(50).optional(),
+  phone: z
+    .string({ invalid_type_error: "Phone Number must be string" })
+    .regex(/^(?:\\+8801\\d{9}|01\\d{9})$/, {
+      message: "Phone number must be valid for Bangladesh. Format: +8801XXXXXXXXX or 01XXXXXXXXX",
+    })
+    .optional(),
+  role: z.enum(Object.values(Role) as [string]).optional(),
+  isActive: z.enum(Object.values(IsActive) as [string]).optional(),
+  isDeleted: z.boolean({ invalid_type_error: "isDeleted must be true or false" }).optional(),
+  isVerified: z.boolean({ invalid_type_error: "isVerified must be true or false" }).optional(),
+  address: z.string({ invalid_type_error: "Address must be string" }).max(200).optional(),
+});
+`,
+        route: `import { Router } from "express";
+import { checkAuth } from "../../middlewares/checkAuth";
+import { validateRequest } from "../../middlewares/validateRequest";
+import { UserControllers } from "./user.controller";
+import { Role } from "./user.interface";
+import { updateUserZodSchema } from "./user.validation";
+
+const router = Router();
+
+router.post("/register", UserControllers.createUser);
+
+router.get("/all-users", checkAuth(Role.ADMIN, Role.SUPER_ADMIN), UserControllers.getAllUsers);
+router.get("/me", checkAuth(...Object.values(Role)), UserControllers.getMe);
+router.get("/:id", checkAuth(Role.ADMIN, Role.SUPER_ADMIN), UserControllers.getSingleUser);
+
+router.patch(
+  "/:id",
+  validateRequest(updateUserZodSchema),
+  checkAuth(...Object.values(Role)),
+  UserControllers.updateUser
+);
+
+export const UserRoutes = router;
+`,
+    },
+    auth: {
+        service: `/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import bcryptjs from "bcryptjs";
+import httpStatus from "http-status-codes";
+import jwt, { JwtPayload } from "jsonwebtoken";
+import { envVars } from "../../config/env";
+import AppError from "../../errorHelpers/AppError";
+import { sendEmail } from "../../utils/sendEmail";
+import { createNewAccessTokenWithRefreshToken } from "../../utils/userTokens";
+import { IAuthProvider, IsActive } from "../user/user.interface";
+import { User } from "../user/user.model";
+
+const getNewAccessToken = async (refreshToken: string) => {
+  const newAccessToken = await createNewAccessTokenWithRefreshToken(refreshToken);
+  return { accessToken: newAccessToken };
+};
+
+const resetPassword = async (payload: Record<string, any>, decodedToken: JwtPayload) => {
+  if (payload.id != decodedToken.userId) {
+    throw new AppError(401, "You can not reset your password");
+  }
+
+  const isUserExist = await User.findById(decodedToken.userId);
+  if (!isUserExist) {
+    throw new AppError(401, "User does not exist");
+  }
+
+  const hashedPassword = await bcryptjs.hash(payload.newPassword, Number(envVars.BCRYPT_SALT_ROUND));
+  isUserExist.password = hashedPassword;
+
+  await isUserExist.save();
+};
+
+const forgotPassword = async (email: string) => {
+  const isUserExist = await User.findOne({ email });
+
+  if (!isUserExist) throw new AppError(httpStatus.BAD_REQUEST, "User does not exist");
+  if (!isUserExist.isVerified) throw new AppError(httpStatus.BAD_REQUEST, "User is not verified");
+  if (isUserExist.isActive === IsActive.BLOCKED || isUserExist.isActive === IsActive.INACTIVE) {
+    throw new AppError(httpStatus.BAD_REQUEST, \`User is \${isUserExist.isActive}\`);
+  }
+  if (isUserExist.isDeleted) throw new AppError(httpStatus.BAD_REQUEST, "User is deleted");
+
+  const jwtPayload = { userId: isUserExist._id, email: isUserExist.email, role: isUserExist.role };
+
+  const resetToken = jwt.sign(jwtPayload, envVars.JWT_ACCESS_SECRET, { expiresIn: "10m" });
+
+  const resetUILink = \`\${envVars.FRONTEND_URL}/reset-password?id=\${isUserExist._id}&token=\${resetToken}\`;
+
+  sendEmail({
+    to: isUserExist.email,
+    subject: "Password Reset",
+    templateName: "forgetPassword",
+    templateData: { name: isUserExist.name, resetUILink },
+  });
+};
+
+const setPassword = async (userId: string, plainPassword: string) => {
+  const user = await User.findById(userId);
+  if (!user) throw new AppError(404, "User not found");
+
+  if (user.password && user.auths.some((p) => p.provider === "google")) {
+    throw new AppError(
+      httpStatus.BAD_REQUEST,
+      "You have already set you password. Now you can change the password from your profile password update"
+    );
+  }
+
+  const hashedPassword = await bcryptjs.hash(plainPassword, Number(envVars.BCRYPT_SALT_ROUND));
+
+  const credentialProvider: IAuthProvider = { provider: "credentials", providerId: user.email };
+  const auths: IAuthProvider[] = [...user.auths, credentialProvider];
+
+  user.password = hashedPassword;
+  user.auths = auths;
+
+  await user.save();
+};
+
+const changePassword = async (oldPassword: string, newPassword: string, decodedToken: JwtPayload) => {
+  const user = await User.findById(decodedToken.userId);
+
+  const isOldPasswordMatch = await bcryptjs.compare(oldPassword, user!.password as string);
+  if (!isOldPasswordMatch) throw new AppError(httpStatus.UNAUTHORIZED, "Old Password does not match");
+
+  user!.password = await bcryptjs.hash(newPassword, Number(envVars.BCRYPT_SALT_ROUND));
+  user!.save();
+};
+
+export const AuthServices = {
+  getNewAccessToken,
+  changePassword,
+  setPassword,
+  forgotPassword,
+  resetPassword,
+};
+`,
+        controller: `/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { NextFunction, Request, Response } from "express";
+import httpStatus from "http-status-codes";
+import { JwtPayload } from "jsonwebtoken";
+import passport from "passport";
+import { envVars } from "../../config/env";
+import AppError from "../../errorHelpers/AppError";
+import { catchAsync } from "../../utils/catchAsync";
+import { sendResponse } from "../../utils/sendResponse";
+import { setAuthCookie } from "../../utils/setCookie";
+import { createUserTokens } from "../../utils/userTokens";
+import { AuthServices } from "./auth.service";
+
+const credentialsLogin = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  passport.authenticate("local", async (err: any, user: any, info: any) => {
+    if (err) return next(new AppError(401, err));
+    if (!user) return next(new AppError(401, info.message));
+
+    const userTokens = await createUserTokens(user);
+    const { password: pass, ...rest } = user.toObject();
+
+    setAuthCookie(res, userTokens);
+
+    sendResponse(res, {
+      success: true,
+      statusCode: httpStatus.OK,
+      message: "User Logged In Successfully",
+      data: { accessToken: userTokens.accessToken, refreshToken: userTokens.refreshToken, user: rest },
+    });
+  })(req, res, next);
+});
+
+const getNewAccessToken = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const refreshToken = req.cookies.refreshToken;
+  if (!refreshToken) throw new AppError(httpStatus.BAD_REQUEST, "No refresh token recieved from cookies");
+
+  const tokenInfo = await AuthServices.getNewAccessToken(refreshToken as string);
+  setAuthCookie(res, tokenInfo);
+
+  sendResponse(res, {
+    success: true,
+    statusCode: httpStatus.OK,
+    message: "New Access Token Retrived Successfully",
+    data: tokenInfo,
+  });
+});
+
+const logout = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  res.clearCookie("accessToken", { httpOnly: true, secure: false, sameSite: "lax" });
+  res.clearCookie("refreshToken", { httpOnly: true, secure: false, sameSite: "lax" });
+
+  sendResponse(res, { success: true, statusCode: httpStatus.OK, message: "User Logged Out Successfully", data: null });
+});
+
+const changePassword = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const newPassword = req.body.newPassword;
+  const oldPassword = req.body.oldPassword;
+  const decodedToken = req.user;
+
+  await AuthServices.changePassword(oldPassword, newPassword, decodedToken as JwtPayload);
+
+  sendResponse(res, { success: true, statusCode: httpStatus.OK, message: "Password Changed Successfully", data: null });
+});
+
+const resetPassword = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const decodedToken = req.user;
+
+  await AuthServices.resetPassword(req.body, decodedToken as JwtPayload);
+
+  sendResponse(res, { success: true, statusCode: httpStatus.OK, message: "Password Changed Successfully", data: null });
+});
+
+const setPassword = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const decodedToken = req.user as JwtPayload;
+  const { password } = req.body;
+
+  await AuthServices.setPassword(decodedToken.userId, password);
+
+  sendResponse(res, { success: true, statusCode: httpStatus.OK, message: "Password Changed Successfully", data: null });
+});
+
+const forgotPassword = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  const { email } = req.body;
+
+  await AuthServices.forgotPassword(email);
+
+  sendResponse(res, { success: true, statusCode: httpStatus.OK, message: "Email Sent Successfully", data: null });
+});
+
+const googleCallbackController = catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+  let redirectTo = req.query.state ? (req.query.state as string) : "";
+
+  if (redirectTo.startsWith("/")) redirectTo = redirectTo.slice(1);
+
+  const user = req.user;
+  if (!user) throw new AppError(httpStatus.NOT_FOUND, "User Not Found");
+
+  const tokenInfo = createUserTokens(user);
+
+  setAuthCookie(res, tokenInfo);
+
+  res.redirect(\`\${envVars.FRONTEND_URL}/\${redirectTo}\`);
+});
+
+export const AuthControllers = {
+  credentialsLogin,
+  getNewAccessToken,
+  logout,
+  resetPassword,
+  setPassword,
+  forgotPassword,
+  changePassword,
+  googleCallbackController,
+};
+`,
+        route: `import { NextFunction, Request, Response, Router } from "express";
+import passport from "passport";
+import { envVars } from "../../config/env";
+import { checkAuth } from "../../middlewares/checkAuth";
+import { Role } from "../user/user.interface";
+import { AuthControllers } from "./auth.controller";
+
+const router = Router();
+
+router.post("/login", AuthControllers.credentialsLogin);
+router.post("/refresh-token", AuthControllers.getNewAccessToken);
+router.post("/logout", AuthControllers.logout);
+
+router.post("/change-password", checkAuth(...Object.values(Role)), AuthControllers.changePassword);
+router.post("/set-password", checkAuth(...Object.values(Role)), AuthControllers.setPassword);
+
+router.post("/forgot-password", AuthControllers.forgotPassword);
+router.post("/reset-password", checkAuth(...Object.values(Role)), AuthControllers.resetPassword);
+
+router.get("/google", async (req: Request, res: Response, next: NextFunction) => {
+  const redirect = req.query.redirect || "/";
+  passport.authenticate("google", { scope: ["profile", "email"], state: redirect as string })(req, res, next);
+});
+
+router.get(
+  "/google/callback",
+  passport.authenticate("google", {
+    failureRedirect: \`\${envVars.FRONTEND_URL}/login?error=There is some issues with your account. Please contact with out support team!\`,
+  }),
+  AuthControllers.googleCallbackController
+);
+
+export const AuthRoutes = router;
+`,
+    },
+};

package/dist/project-templates.d.ts

@@ -0,0 +1 @@
+export declare const PROJECT_FILES: Record<string, string>;