core modules are separated

muneebhashone · muneebhashone · commit b4836bc98e43 · 2024-08-20T18:17:48.000+05:00
diff --git a/src/middlewares/can-access.middleware.ts b/src/middlewares/can-access.middleware.ts
@@ -1,7 +1,7 @@
 import { NextFunction, Request, Response } from 'express';
 import { StatusCodes } from 'http-status-codes';
 import { RoleType } from '../enums';
-import { getUserById } from '../user/user.services';
+import { getUserById } from '../modules/user/user.services';
 import { errorResponse } from '../utils/api.utils';
 import { JwtPayload } from '../utils/auth.utils';
 
@@ -29,7 +29,7 @@ export const canAccess =
           StatusCodes.UNAUTHORIZED,
         );
       }
-      const currentUser = await getUserById({ id: requestUser.sub });
+      const currentUser = await getUserById(requestUser.sub);
 
       if (!currentUser) {
         return errorResponse(res, 'Login again', StatusCodes.UNAUTHORIZED);
@@ -43,14 +43,6 @@ export const canAccess =
         );
       }
 
-      if (!currentUser.isActive) {
-        return errorResponse(
-          res,
-          'Your account has been disabled',
-          StatusCodes.UNAUTHORIZED,
-        );
-      }
-
       let can = false;
 
       const accessorsToScanFor = access;
diff --git a/src/modules/auth/auth.constants.ts b/src/modules/auth/auth.constants.ts
@@ -1,5 +1,5 @@
 import { CookieOptions } from 'express';
-import config from '../config/config.service';
+import config from '../../config/config.service';
 
 const clientSideUrl = new URL(config.CLIENT_SIDE_URL);
 
diff --git a/src/modules/auth/auth.controller.ts b/src/modules/auth/auth.controller.ts
@@ -1,8 +1,8 @@
 import { Request, Response } from 'express';
-import config from '../config/config.service';
-import { GoogleCallbackQuery } from '../types';
-import { successResponse } from '../utils/api.utils';
-import { JwtPayload } from '../utils/auth.utils';
+import config from '../../config/config.service';
+import { GoogleCallbackQuery } from '../../types';
+import { successResponse } from '../../utils/api.utils';
+import { JwtPayload } from '../../utils/auth.utils';
 import { AUTH_COOKIE_KEY, COOKIE_CONFIG } from './auth.constants';
 import {
   ChangePasswordSchemaType,
diff --git a/src/modules/auth/auth.router.ts b/src/modules/auth/auth.router.ts
@@ -1,5 +1,5 @@
-import { canAccess } from '../middlewares/can-access.middleware';
-import MagicRouter from '../openapi/magic-router';
+import { canAccess } from '../../middlewares/can-access.middleware';
+import MagicRouter from '../../openapi/magic-router';
 import {
   handleChangePassword,
   handleForgetPassword,
diff --git a/src/modules/auth/auth.schema.ts b/src/modules/auth/auth.schema.ts
@@ -1,6 +1,6 @@
 import z from 'zod';
 import validator from 'validator';
-import { passwordValidationSchema } from '../common/common.schema';
+import { passwordValidationSchema } from '../../common/common.schema';
 import { baseCreateUser } from '../user/user.schema';
 
 export const resetPasswordSchema = z.object({
diff --git a/src/modules/auth/auth.service.ts b/src/modules/auth/auth.service.ts
@@ -1,17 +1,21 @@
-import { ROLE_ENUM, RoleType, SOCIAL_ACCOUNT_ENUM } from '../enums';
-import { GoogleCallbackQuery } from '../types';
-import { UserType } from '../user/user.dto';
-import User from '../user/user.model';
-import { createUser } from '../user/user.services';
+import { ROLE_ENUM, RoleType, SOCIAL_ACCOUNT_ENUM } from '../../enums';
+import { GoogleCallbackQuery } from '../../types';
 import {
   compareHash,
   fetchGoogleTokens,
   getUserInfo,
   hashPassword,
   JwtPayload,
   signToken,
-} from '../utils/auth.utils';
-import { generateRandomNumbers } from '../utils/common.utils';
+} from '../../utils/auth.utils';
+import { generateRandomNumbers } from '../../utils/common.utils';
+import { UserType } from '../user/user.dto';
+import {
+  createUser,
+  getUserByEmail,
+  getUserById,
+  updateUser,
+} from '../user/user.services';
 import {
   ChangePasswordSchemaType,
   ForgetPasswordSchemaType,
@@ -21,11 +25,9 @@ import {
 } from './auth.schema';
 
 export const resetPassword = async (payload: ResetPasswordSchemaType) => {
-  const user = User.findOne({
-    _id: payload.userId,
-    passwordResetCode: payload.code,
-  });
-  if (!user) {
+  const user = await getUserById(payload.userId);
+
+  if (!user || user.passwordResetCode !== payload.code) {
     throw new Error('token is not valid or expired, please try again');
   }
 
@@ -35,51 +37,33 @@ export const resetPassword = async (payload: ResetPasswordSchemaType) => {
 
   const hashedPassword = await hashPassword(payload.password);
 
-  await User.updateOne(
-    {
-      _id: payload.userId,
-    },
-    {
-      $set: {
-        password: hashedPassword,
-        passwordResetCode: null,
-      },
-    },
-  );
+  await updateUser(payload.userId, {
+    password: hashedPassword,
+    passwordResetCode: null,
+  });
 };
 
 export const forgetPassword = async (
   payload: ForgetPasswordSchemaType,
 ): Promise<UserType> => {
-  const user = await User.findOne({
-    phoneNo: payload.email,
-  });
+  const user = await getUserByEmail(payload.email);
 
   if (!user) {
     throw new Error("user doesn't exists");
   }
 
   const code = generateRandomNumbers(4);
 
-  await User.updateOne(
-    {
-      _id: user._id,
-    },
-    {
-      $set: { passwordResetCode: code },
-    },
-  );
+  await updateUser(user._id, { passwordResetCode: code });
 
-  return user.toObject();
+  return user;
 };
 
 export const changePassword = async (
   userId: string,
   payload: ChangePasswordSchemaType,
 ): Promise<void> => {
-  const user = await User.findOne({
-    _id: userId,
-  }).select('+password');
+  const user = await getUserById(userId, '+password');
 
   if (!user || !user.password) {
     throw new Error('User is not found');
@@ -96,15 +80,13 @@ export const changePassword = async (
 
   const hashedPassword = await hashPassword(payload.newPassword);
 
-  await User.updateOne({ _id: userId }, { $set: { password: hashedPassword } });
+  await updateUser(userId, { password: hashedPassword });
 };
 
 export const registerUserByEmail = async (
   payload: RegisterUserByEmailSchemaType,
 ): Promise<UserType> => {
-  const userExistByEmail = await User.findOne({
-    email: payload.email,
-  });
+  const userExistByEmail = await getUserByEmail(payload.email);
 
   if (userExistByEmail) {
     throw new Error('Account already exist with same email address');
@@ -120,7 +102,7 @@ export const registerUserByEmail = async (
 export const loginUserByEmail = async (
   payload: LoginUserByEmailSchemaType,
 ): Promise<string> => {
-  const user = await User.findOne({ email: payload.email }).select('+password');
+  const user = await getUserByEmail(payload.email, '+password');
 
   if (!user || !(await compareHash(String(user.password), payload.password))) {
     throw new Error('Invalid email or password');
@@ -143,6 +125,7 @@ export const googleLogin = async (
   payload: GoogleCallbackQuery,
 ): Promise<UserType> => {
   const { code, error } = payload;
+
   if (error) {
     throw new Error(error);
   }
@@ -157,9 +140,11 @@ export const googleLogin = async (
   const userInfoResponse = await getUserInfo(access_token);
 
   const { id, email, name, picture } = userInfoResponse;
-  const existingUser = await User.findOne({ email });
-  if (!existingUser) {
-    return await createUser({
+
+  const user = await getUserByEmail(email);
+
+  if (!user) {
+    const newUser = await createUser({
       email,
       username: name,
       avatar: picture,
@@ -175,18 +160,21 @@ export const googleLogin = async (
         },
       ],
     });
-  } else {
-    existingUser.socialAccount = [
+
+    return newUser;
+  }
+
+  const updatedUser = await updateUser(user._id, {
+    socialAccount: [
       {
         refreshToken: refresh_token,
         tokenExpiry: new Date(Date.now() + expires_in * 1000),
         accountType: SOCIAL_ACCOUNT_ENUM.GOOGLE,
         accessToken: access_token,
         accountID: id,
       },
-    ];
-    await existingUser.save();
-  }
+    ],
+  });
 
-  return existingUser.toObject();
+  return updatedUser;
 };
diff --git a/src/modules/user/user.controller.ts b/src/modules/user/user.controller.ts
@@ -1,8 +1,8 @@
 import { Request, Response } from 'express';
 import { StatusCodes } from 'http-status-codes';
-import { MongoIdSchemaType } from '../common/common.schema';
-import { successResponse } from '../utils/api.utils';
-import { generateRandomPassword } from '../utils/auth.utils';
+import { MongoIdSchemaType } from '../../common/common.schema';
+import { successResponse } from '../../utils/api.utils';
+import { generateRandomPassword } from '../../utils/auth.utils';
 import { CreateUserSchemaType, GetUsersSchemaType } from './user.schema';
 import { createUser, deleteUser, getUsers } from './user.services';
 
diff --git a/src/modules/user/user.dto.ts b/src/modules/user/user.dto.ts
@@ -1,27 +1,27 @@
 import z from 'zod';
-import { definePaginatedResponse } from '../common/common.utils';
+import { definePaginatedResponse } from '../../common/common.utils';
 import {
   ROLE_ENUM,
   RoleType,
   SOCIAL_ACCOUNT_ENUM,
   SocialAccountType,
-} from '../enums';
+} from '../../enums';
 
-const SocialAccountTypeZ = z.enum(
+export const SocialAccountTypeZ = z.enum(
   Object.keys(SOCIAL_ACCOUNT_ENUM) as [SocialAccountType],
 );
-const RoleTypeZ = z.enum(Object.keys(ROLE_ENUM) as [RoleType]);
 
-const socialAccountInfoSchema = z.object({
+export const RoleTypeZ = z.enum(Object.keys(ROLE_ENUM) as [RoleType]);
+
+export const socialAccountInfoSchema = z.object({
   accountType: SocialAccountTypeZ,
   accessToken: z.string(),
   tokenExpiry: z.date(),
   refreshToken: z.string().optional(),
   accountID: z.string(),
 });
 
-const userOutSchema = z.object({
-  _id: z.string().optional(),
+export const userOutSchema = z.object({
   email: z.string().email(),
   avatar: z.string().url().optional(),
   name: z.string().optional(),
@@ -33,14 +33,15 @@ const userOutSchema = z.object({
   createdAt: z.date().optional(),
 });
 
-const userSchema = userOutSchema.extend({
+export const userSchema = userOutSchema.extend({
   otp: z.string().nullable().optional(),
   password: z.string(),
-  passwordResetCode: z.string().optional(),
+  passwordResetCode: z.string().optional().nullable(),
 });
 
 export const usersPaginatedSchema = definePaginatedResponse(userOutSchema);
 
-export type UserType = z.infer<typeof userSchema>;
+export type UserModelType = z.infer<typeof userSchema>;
+export type UserType = z.infer<typeof userSchema> & { id: string; _id: string };
 export type SocialAccountInfoType = z.infer<typeof socialAccountInfoSchema>;
 export type UserPaginatedType = z.infer<typeof usersPaginatedSchema>;
diff --git a/src/modules/user/user.model.ts b/src/modules/user/user.model.ts
@@ -1,6 +1,6 @@
 import mongoose, { Document, Schema } from 'mongoose';
-import { ROLE_ENUM, SOCIAL_ACCOUNT_ENUM } from '../enums'; // Import rolesEnums
-import { SocialAccountInfoType, UserType } from './user.dto';
+import { ROLE_ENUM, SOCIAL_ACCOUNT_ENUM } from '../../enums'; // Import rolesEnums
+import { SocialAccountInfoType, UserModelType, UserType } from './user.dto';
 
 const SocialAccountSchema = new Schema<SocialAccountInfoType>({
   accountType: {
@@ -36,6 +36,6 @@ const UserSchema: Schema<UserType> = new Schema(
 export interface ISocialAccountDocument
   extends SocialAccountInfoType,
     Document {}
-export interface IUserDocument extends UserType, Document<string> {}
+export interface IUserDocument extends Document<string>, UserModelType {}
 const User = mongoose.model<UserType>('User', UserSchema);
 export default User;
diff --git a/src/modules/user/user.router.ts b/src/modules/user/user.router.ts
@@ -1,5 +1,5 @@
-import { canAccess } from '../middlewares/can-access.middleware';
-import MagicRouter from '../openapi/magic-router';
+import { canAccess } from '../../middlewares/can-access.middleware';
+import MagicRouter from '../../openapi/magic-router';
 import {
   handleCreateSuperAdmin,
   handleCreateUser,
diff --git a/src/modules/user/user.schema.ts b/src/modules/user/user.schema.ts
@@ -1,7 +1,7 @@
 import * as z from 'zod';
-import { passwordValidationSchema } from '../common/common.schema';
-import { ROLE_ENUM, RoleType } from '../enums';
-import { isValidUsername } from '../utils/isUsername';
+import { passwordValidationSchema } from '../../common/common.schema';
+import { ROLE_ENUM, RoleType } from '../../enums';
+import { isValidUsername } from '../../utils/isUsername';
 
 export const baseCreateUser = z.object({
   email: z
diff --git a/src/modules/user/user.services.ts b/src/modules/user/user.services.ts
diff --git a/src/routes/routes.ts b/src/routes/routes.ts
