fix: controller + validator naming

src/modules/auth/auth.controller.ts

@@ -1,63 +1,52 @@
 import httpStatus from 'http-status';
 import { Request, Response } from 'express';
 import catchAsync from '../utils/catchAsync';
-import { registerUser } from '../user/user.service';
-import {
-  generateAuthTokens,
-  generateResetPasswordToken,
-  generateVerifyEmailToken,
-} from '../token/token.service';
-import { loginUserWithEmailAndPassword, logout, refreshAuth, resetPassword, verifyEmail } from './auth.service';
-import { sendResetPasswordEmail, sendVerificationEmail } from '../email/email.service';
-import config from '../../config/config';
-import { AccessAndRefreshTokens } from '../token/token.interfaces';
-
-export const sendTokens = (res: Response, tokens: AccessAndRefreshTokens) => {
-  res.cookie('accessToken', tokens.access, config.jwt.cookieOptions);
-  res.cookie('refreshToken', tokens.refresh, config.jwt.cookieOptions);
-};
-
-export const registerController = catchAsync(async (req: Request, res: Response) => {
-  const user = await registerUser(req.body);
-  const tokens = await generateAuthTokens(user);
+import * as tokenService from '@/modules/token/token.service';
+import * as userService from '@/modules/user/user.service';
+import * as authService from '@/modules/auth/auth.service';
+import * as emailService from '@/modules/email/email.service';
+
+export const register = catchAsync(async (req: Request, res: Response) => {
+  const user = await userService.registerUser(req.body);
+  const tokens = await tokenService.generateAuthTokens(user);
   res.status(httpStatus.CREATED).send({ user, tokens });
 });
 
-export const loginController = catchAsync(async (req: Request, res: Response) => {
+export const login = catchAsync(async (req: Request, res: Response) => {
   const { email, password } = req.body;
-  const user = await loginUserWithEmailAndPassword(email, password);
-  const tokens = await generateAuthTokens(user);
+  const user = await authService.loginUserWithEmailAndPassword(email, password);
+  const tokens = await tokenService.generateAuthTokens(user);
   res.send({ user, tokens });
 });
 
-export const logoutController = catchAsync(async (req: Request, res: Response) => {
-  await logout(req.body.refreshToken);
+export const logout = catchAsync(async (req: Request, res: Response) => {
+  await authService.logout(req.body.refreshToken);
   res.status(httpStatus.NO_CONTENT).send();
 });
 
-export const refreshTokensController = catchAsync(async (req: Request, res: Response) => {
-  const tokens = await refreshAuth(req.body.refreshToken);
+export const refreshTokens = catchAsync(async (req: Request, res: Response) => {
+  const tokens = await authService.refreshAuth(req.body.refreshToken);
   res.send({ ...tokens });
 });
 
-export const forgotPasswordController = catchAsync(async (req: Request, res: Response) => {
-  const resetPasswordToken = await generateResetPasswordToken(req.body.email);
-  await sendResetPasswordEmail(req.body.email, resetPasswordToken);
+export const forgotPassword = catchAsync(async (req: Request, res: Response) => {
+  const resetPasswordToken = await tokenService.generateResetPasswordToken(req.body.email);
+  await emailService.sendResetPasswordEmail(req.body.email, resetPasswordToken);
   res.status(httpStatus.NO_CONTENT).send();
 });
 
-export const resetPasswordController = catchAsync(async (req: Request, res: Response) => {
-  await resetPassword(req.query['token'], req.body.password);
+export const resetPassword = catchAsync(async (req: Request, res: Response) => {
+  await authService.resetPassword(req.query['token'], req.body.password);
   res.status(httpStatus.NO_CONTENT).send();
 });
 
-export const sendVerificationEmailController = catchAsync(async (req: Request, res: Response) => {
-  const verifyEmailToken = await generateVerifyEmailToken(req.user);
-  await sendVerificationEmail(req.user.email, verifyEmailToken, req.user.name);
+export const sendVerificationEmail = catchAsync(async (req: Request, res: Response) => {
+  const verifyEmailToken = await tokenService.generateVerifyEmailToken(req.user);
+  await emailService.sendVerificationEmail(req.user.email, verifyEmailToken, req.user.name);
   res.status(httpStatus.NO_CONTENT).send();
 });
 
-export const verifyEmailController = catchAsync(async (req: Request, res: Response) => {
-  await verifyEmail(req.query['token']);
+export const verifyEmail = catchAsync(async (req: Request, res: Response) => {
+  await authService.verifyEmail(req.query['token']);
   res.status(httpStatus.NO_CONTENT).send();
 });

src/modules/auth/auth.validation.ts

@@ -8,36 +8,36 @@ const registerBody: Record<keyof NewRegisteredUser, any> = {
   name: Joi.string().required(),
 };
 
-export const registerValidator = {
+export const register = {
   body: Joi.object().keys(registerBody),
 };
 
-export const loginValidator = {
+export const login = {
   body: Joi.object().keys({
     email: Joi.string().required(),
     password: Joi.string().required(),
   }),
 };
 
-export const logoutValidator = {
+export const logout = {
   body: Joi.object().keys({
     refreshToken: Joi.string().required(),
   }),
 };
 
-export const refreshTokensValidator = {
+export const refreshTokens = {
   body: Joi.object().keys({
     refreshToken: Joi.string().required(),
   }),
 };
 
-export const forgotPasswordValidator = {
+export const forgotPassword = {
   body: Joi.object().keys({
     email: Joi.string().email().required(),
   }),
 };
 
-export const resetPasswordValidator = {
+export const resetPassword = {
   query: Joi.object().keys({
     token: Joi.string().required(),
   }),
@@ -46,7 +46,7 @@ export const resetPasswordValidator = {
   }),
 };
 
-export const verifyEmailValidator = {
+export const verifyEmail = {
   query: Joi.object().keys({
     token: Joi.string().required(),
   }),

src/modules/token/token.service.ts

@@ -8,7 +8,7 @@ import ApiError from '../errors/ApiError';
 import tokenTypes from './token.types';
 import { AccessAndRefreshTokens, ITokenDoc } from './token.interfaces';
 import { IUserDoc } from '../user/user.interfaces';
-import { getUserByEmail } from '../user/user.service';
+import * as userService from '@/modules/user/user.service';
 
 /**
  * Generate token
@@ -113,7 +113,7 @@ export const generateAuthTokens = async (user: IUserDoc): Promise<AccessAndRefre
  * @returns {Promise<string>}
  */
 export const generateResetPasswordToken = async (email: string): Promise<string> => {
-  const user = await getUserByEmail(email);
+  const user = await userService.getUserByEmail(email);
   if (!user) {
     throw new ApiError(httpStatus.NOT_FOUND, 'No users found with this email');
   }

src/modules/user/user.controller.ts

@@ -4,41 +4,41 @@ import mongoose from 'mongoose';
 import catchAsync from '../utils/catchAsync';
 import ApiError from '../errors/ApiError';
 import pick from '../utils/pick';
-import { createUser, queryUsers, getUserById, updateUserById, deleteUserById } from './user.service';
 import { IOptions } from '../paginate/paginate.plugin';
+import * as userService from '@/modules/user/user.service';
 
-export const createUserController = catchAsync(async (req: Request, res: Response) => {
-  const user = await createUser(req.body);
+export const createUser = catchAsync(async (req: Request, res: Response) => {
+  const user = await userService.createUser(req.body);
   res.status(httpStatus.CREATED).send(user);
 });
 
-export const getUsersController = catchAsync(async (req: Request, res: Response) => {
+export const getUsers = catchAsync(async (req: Request, res: Response) => {
   const filter = pick(req.query, ['name', 'role']);
   const options: IOptions = pick(req.query, ['sortBy', 'limit', 'page']);
-  const result = await queryUsers(filter, options);
+  const result = await userService.queryUsers(filter, options);
   res.send(result);
 });
 
-export const getUserController = catchAsync(async (req: Request, res: Response) => {
+export const getUser = catchAsync(async (req: Request, res: Response) => {
   if (typeof req.params['userId'] === 'string') {
-    const user = await getUserById(new mongoose.Types.ObjectId(req.params['userId']));
+    const user = await userService.getUserById(new mongoose.Types.ObjectId(req.params['userId']));
     if (!user) {
       throw new ApiError(httpStatus.NOT_FOUND, 'User not found');
     }
     res.send(user);
   }
 });
 
-export const updateUserController = catchAsync(async (req: Request, res: Response) => {
+export const updateUser = catchAsync(async (req: Request, res: Response) => {
   if (typeof req.params['userId'] === 'string') {
-    const user = await updateUserById(new mongoose.Types.ObjectId(req.params['userId']), req.body);
+    const user = await userService.updateUserById(new mongoose.Types.ObjectId(req.params['userId']), req.body);
     res.send(user);
   }
 });
 
-export const deleteUserController = catchAsync(async (req: Request, res: Response) => {
+export const deleteUser = catchAsync(async (req: Request, res: Response) => {
   if (typeof req.params['userId'] === 'string') {
-    await deleteUserById(new mongoose.Types.ObjectId(req.params['userId']));
+    await userService.deleteUserById(new mongoose.Types.ObjectId(req.params['userId']));
     res.status(httpStatus.NO_CONTENT).send();
   }
 });

src/modules/user/user.validation.ts

@@ -9,11 +9,11 @@ const createUserBody: Record<keyof NewCreatedUser, any> = {
   role: Joi.string().required().valid('user', 'admin'),
 };
 
-export const createUserValidator = {
+export const createUser = {
   body: Joi.object().keys(createUserBody),
 };
 
-export const getUsersValidator = {
+export const getUsers = {
   query: Joi.object().keys({
     name: Joi.string(),
     role: Joi.string(),
@@ -23,13 +23,13 @@ export const getUsersValidator = {
   }),
 };
 
-export const getUserValidator = {
+export const getUser = {
   params: Joi.object().keys({
     userId: Joi.string().custom(objectId),
   }),
 };
 
-export const updateUserValidator = {
+export const updateUser = {
   params: Joi.object().keys({
     userId: Joi.required().custom(objectId),
   }),
@@ -42,7 +42,7 @@ export const updateUserValidator = {
     .min(1),
 };
 
-export const deleteUserValidator = {
+export const deleteUser = {
   params: Joi.object().keys({
     userId: Joi.string().custom(objectId),
   }),

src/routes/v1/auth.route.ts

@@ -1,36 +1,19 @@
 import express, { Router } from 'express';
 import validate from '@/modules/validate/validate.middleware';
 import auth from '@/modules/auth/auth.middleware';
-import {
-  forgotPasswordValidator,
-  loginValidator,
-  logoutValidator,
-  refreshTokensValidator,
-  registerValidator,
-  resetPasswordValidator,
-  verifyEmailValidator,
-} from '../../modules/auth/auth.validation';
-import {
-  forgotPasswordController,
-  loginController,
-  logoutController,
-  refreshTokensController,
-  registerController,
-  resetPasswordController,
-  sendVerificationEmailController,
-  verifyEmailController,
-} from '../../modules/auth/auth.controller';
+import * as authValidation from '@/modules/auth/auth.validation';
+import * as authController from '@/modules/auth/auth.controller';
 
 const router: Router = express.Router();
 
-router.post('/register', validate(registerValidator), registerController);
-router.post('/login', validate(loginValidator), loginController);
-router.post('/logout', validate(logoutValidator), logoutController);
-router.post('/refresh-tokens', validate(refreshTokensValidator), refreshTokensController);
-router.post('/forgot-password', validate(forgotPasswordValidator), forgotPasswordController);
-router.post('/reset-password', validate(resetPasswordValidator), resetPasswordController);
-router.post('/send-verification-email', auth(), sendVerificationEmailController);
-router.post('/verify-email', validate(verifyEmailValidator), verifyEmailController);
+router.post('/register', validate(authValidation.register), authController.register);
+router.post('/login', validate(authValidation.login), authController.login);
+router.post('/logout', validate(authValidation.logout), authController.logout);
+router.post('/refresh-tokens', validate(authValidation.refreshTokens), authController.refreshTokens);
+router.post('/forgot-password', validate(authValidation.forgotPassword), authController.forgotPassword);
+router.post('/reset-password', validate(authValidation.resetPassword), authController.resetPassword);
+router.post('/send-verification-email', auth(), authController.sendVerificationEmail);
+router.post('/verify-email', validate(authValidation.verifyEmail), authController.verifyEmail);
 
 export default router;
 

src/routes/v1/swagger.route.ts

@@ -1,7 +1,7 @@
 import express from 'express';
 import swaggerJsdoc from 'swagger-jsdoc';
 import swaggerUi from 'swagger-ui-express';
-import swaggerDefinition from '../../modules/swagger/swagger.definition';
+import swaggerDefinition from '@/modules/swagger/swagger.definition';
 
 const router = express.Router();
 

src/routes/v1/user.route.ts

@@ -1,33 +1,21 @@
 import express, { Router } from 'express';
-import validate from '../../modules/validate/validate.middleware';
-import auth from '../../modules/auth/auth.middleware';
-import {
-  createUserValidator,
-  deleteUserValidator,
-  getUsersValidator,
-  getUserValidator,
-  updateUserValidator,
-} from '../../modules/user/user.validation';
-import {
-  createUserController,
-  deleteUserController,
-  getUserController,
-  getUsersController,
-  updateUserController,
-} from '../../modules/user/user.controller';
+import validate from '@/modules/validate/validate.middleware';
+import auth from '@/modules/auth/auth.middleware';
+import * as userValidation from '@/modules/user/user.validation';
+import * as userController from '@/modules/user/user.controller';
 
 const router: Router = express.Router();
 
 router
   .route('/')
-  .post(auth('manageUsers'), validate(createUserValidator), createUserController)
-  .get(auth('getUsers'), validate(getUsersValidator), getUsersController);
+  .post(auth('manageUsers'), validate(userValidation.createUser), userController.createUser)
+  .get(auth('getUsers'), validate(userValidation.getUsers), userController.getUsers);
 
 router
   .route('/:userId')
-  .get(auth('getUsers'), validate(getUserValidator), getUserController)
-  .patch(auth('manageUsers'), validate(updateUserValidator), updateUserController)
-  .delete(auth('manageUsers'), validate(deleteUserValidator), deleteUserController);
+  .get(auth('getUsers'), validate(userValidation.getUser), userController.getUser)
+  .patch(auth('manageUsers'), validate(userValidation.updateUser), userController.updateUser)
+  .delete(auth('manageUsers'), validate(userValidation.deleteUser), userController.deleteUser);
 
 export default router;