typescript-express-starter 7.0.0 → 8.1.2

package/lib/typegoose/src/middlewares/auth.middleware.ts

@@ -0,0 +1,32 @@
+import { NextFunction, Response } from 'express';
+import { verify } from 'jsonwebtoken';
+import { SECRET_KEY } from '@config';
+import { HttpException } from '@exceptions/HttpException';
+import { DataStoredInToken, RequestWithUser } from '@interfaces/auth.interface';
+import userModel from '@models/users.model';
+
+const authMiddleware = async (req: RequestWithUser, res: Response, next: NextFunction) => {
+  try {
+    const Authorization = req.cookies['Authorization'] || (req.header('Authorization') ? req.header('Authorization').split('Bearer ')[1] : null);
+
+    if (Authorization) {
+      const secretKey: string = SECRET_KEY;
+      const verificationResponse = (await verify(Authorization, secretKey)) as DataStoredInToken;
+      const userId = verificationResponse._id;
+      const findUser = await userModel.findById(userId);
+
+      if (findUser) {
+        req.user = findUser;
+        next();
+      } else {
+        next(new HttpException(401, 'Wrong authentication token'));
+      }
+    } else {
+      next(new HttpException(404, 'Authentication token missing'));
+    }
+  } catch (error) {
+    next(new HttpException(401, 'Wrong authentication token'));
+  }
+};
+
+export default authMiddleware;

package/lib/typegoose/src/middlewares/error.middleware.ts

@@ -0,0 +1,17 @@
+import { NextFunction, Request, Response } from 'express';
+import { HttpException } from '@exceptions/HttpException';
+import { logger } from '@utils/logger';
+
+const errorMiddleware = (error: HttpException, req: Request, res: Response, next: NextFunction) => {
+  try {
+    const status: number = error.status || 500;
+    const message: string = error.message || 'Something went wrong';
+
+    logger.error(`[${req.method}] ${req.path} >> StatusCode:: ${status}, Message:: ${message}`);
+    res.status(status).json({ message });
+  } catch (error) {
+    next(error);
+  }
+};
+
+export default errorMiddleware;

package/lib/typegoose/src/middlewares/validation.middleware.ts

@@ -0,0 +1,25 @@
+import { plainToClass } from 'class-transformer';
+import { validate, ValidationError } from 'class-validator';
+import { RequestHandler } from 'express';
+import { HttpException } from '@exceptions/HttpException';
+
+const validationMiddleware = (
+  type: any,
+  value: string | 'body' | 'query' | 'params' = 'body',
+  skipMissingProperties = false,
+  whitelist = true,
+  forbidNonWhitelisted = true,
+): RequestHandler => {
+  return (req, res, next) => {
+    validate(plainToClass(type, req[value]), { skipMissingProperties, whitelist, forbidNonWhitelisted }).then((errors: ValidationError[]) => {
+      if (errors.length > 0) {
+        const message = errors.map((error: ValidationError) => Object.values(error.constraints)).join(', ');
+        next(new HttpException(400, message));
+      } else {
+        next();
+      }
+    });
+  };
+};
+
+export default validationMiddleware;

package/lib/typegoose/src/models/users.model.ts

@@ -0,0 +1,18 @@
+import { prop, getModelForClass, modelOptions } from '@typegoose/typegoose';
+
+@modelOptions({ schemaOptions: { collection: 'users', timestamps: true } })
+class User {
+  @prop({ type: String, required: true, unique: true })
+  public email: string;
+
+  @prop({ type: String, required: true })
+  public password: string;
+
+  public createdAt?: Date;
+
+  public updatedAt?: Date;
+}
+
+const UserModel = getModelForClass(User);
+
+export default UserModel;

package/lib/typegoose/src/routes/auth.route.ts

@@ -0,0 +1,24 @@
+import { Router } from 'express';
+import AuthController from '@controllers/auth.controller';
+import { CreateUserDto } from '@dtos/users.dto';
+import { Routes } from '@interfaces/routes.interface';
+import authMiddleware from '@middlewares/auth.middleware';
+import validationMiddleware from '@middlewares/validation.middleware';
+
+class AuthRoute implements Routes {
+  public path = '/';
+  public router = Router();
+  public authController = new AuthController();
+
+  constructor() {
+    this.initializeRoutes();
+  }
+
+  private initializeRoutes() {
+    this.router.post(`${this.path}signup`, validationMiddleware(CreateUserDto, 'body'), this.authController.signUp);
+    this.router.post(`${this.path}login`, validationMiddleware(CreateUserDto, 'body'), this.authController.logIn);
+    this.router.post(`${this.path}logout`, authMiddleware, this.authController.logOut);
+  }
+}
+
+export default AuthRoute;

package/lib/typegoose/src/routes/index.route.ts

@@ -0,0 +1,19 @@
+import { Router } from 'express';
+import IndexController from '@controllers/index.controller';
+import { Routes } from '@interfaces/routes.interface';
+
+class IndexRoute implements Routes {
+  public path = '/';
+  public router = Router();
+  public indexController = new IndexController();
+
+  constructor() {
+    this.initializeRoutes();
+  }
+
+  private initializeRoutes() {
+    this.router.get(`${this.path}`, this.indexController.index);
+  }
+}
+
+export default IndexRoute;

package/lib/typegoose/src/routes/users.route.ts

@@ -0,0 +1,25 @@
+import { Router } from 'express';
+import UsersController from '@controllers/users.controller';
+import { CreateUserDto } from '@dtos/users.dto';
+import { Routes } from '@interfaces/routes.interface';
+import validationMiddleware from '@middlewares/validation.middleware';
+
+class UsersRoute implements Routes {
+  public path = '/users';
+  public router = Router();
+  public usersController = new UsersController();
+
+  constructor() {
+    this.initializeRoutes();
+  }
+
+  private initializeRoutes() {
+    this.router.get(`${this.path}`, this.usersController.getUsers);
+    this.router.get(`${this.path}/:id`, this.usersController.getUserById);
+    this.router.post(`${this.path}`, validationMiddleware(CreateUserDto, 'body'), this.usersController.createUser);
+    this.router.put(`${this.path}/:id`, validationMiddleware(CreateUserDto, 'body', true), this.usersController.updateUser);
+    this.router.delete(`${this.path}/:id`, this.usersController.deleteUser);
+  }
+}
+
+export default UsersRoute;

package/lib/typegoose/src/server.ts

@@ -0,0 +1,11 @@
+import App from '@/app';
+import AuthRoute from '@routes/auth.route';
+import IndexRoute from '@routes/index.route';
+import UsersRoute from '@routes/users.route';
+import validateEnv from '@utils/validateEnv';
+
+validateEnv();
+
+const app = new App([new IndexRoute(), new UsersRoute(), new AuthRoute()]);
+
+app.listen();

package/lib/typegoose/src/services/auth.service.ts

@@ -0,0 +1,61 @@
+import { hash, compare } from 'bcrypt';
+import { sign } from 'jsonwebtoken';
+import { SECRET_KEY } from '@config';
+import { CreateUserDto } from '@dtos/users.dto';
+import { HttpException } from '@exceptions/HttpException';
+import { DataStoredInToken, TokenData } from '@interfaces/auth.interface';
+import { User } from '@interfaces/users.interface';
+import userModel from '@models/users.model';
+import { isEmpty } from '@utils/util';
+
+class AuthService {
+  public async signup(userData: CreateUserDto): Promise<User> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await userModel.findOne({ email: userData.email });
+    if (findUser) throw new HttpException(409, `You're email ${userData.email} already exists`);
+
+    const hashedPassword = await hash(userData.password, 10);
+    const createUserData: User = await userModel.create({ ...userData, password: hashedPassword });
+
+    return createUserData;
+  }
+
+  public async login(userData: CreateUserDto): Promise<{ cookie: string; findUser: User }> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await userModel.findOne({ email: userData.email });
+    if (!findUser) throw new HttpException(409, `You're email ${userData.email} not found`);
+
+    const isPasswordMatching: boolean = await compare(userData.password, findUser.password);
+    if (!isPasswordMatching) throw new HttpException(409, "You're password not matching");
+
+    const tokenData = this.createToken(findUser);
+    const cookie = this.createCookie(tokenData);
+
+    return { cookie, findUser };
+  }
+
+  public async logout(userData: User): Promise<User> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await userModel.findOne({ email: userData.email, password: userData.password });
+    if (!findUser) throw new HttpException(409, `You're email ${userData.email} not found`);
+
+    return findUser;
+  }
+
+  public createToken(user: User): TokenData {
+    const dataStoredInToken: DataStoredInToken = { _id: user._id };
+    const secretKey: string = SECRET_KEY;
+    const expiresIn: number = 60 * 60;
+
+    return { expiresIn, token: sign(dataStoredInToken, secretKey, { expiresIn }) };
+  }
+
+  public createCookie(tokenData: TokenData): string {
+    return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
+  }
+}
+
+export default AuthService;

package/lib/typegoose/src/services/users.service.ts

@@ -0,0 +1,64 @@
+import { hash } from 'bcrypt';
+import { CreateUserDto } from '@dtos/users.dto';
+import { HttpException } from '@exceptions/HttpException';
+import { User } from '@interfaces/users.interface';
+import userModel from '@models/users.model';
+import { isEmpty } from '@utils/util';
+
+class UserService {
+  // public users = userModel;
+
+  public async findAllUser(): Promise<User[]> {
+    const users: User[] = await userModel.find();
+    return users;
+  }
+
+  public async findUserById(userId: string): Promise<User> {
+    if (isEmpty(userId)) throw new HttpException(400, "You're not userId");
+
+    const findUser: User = await userModel.findOne({ _id: userId });
+    if (!findUser) throw new HttpException(409, "You're not user");
+
+    return findUser;
+  }
+
+  public async createUser(userData: CreateUserDto): Promise<User> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await userModel.findOne({ email: userData.email });
+    if (findUser) throw new HttpException(409, `You're email ${userData.email} already exists`);
+
+    const hashedPassword = await hash(userData.password, 10);
+    const createUserData: User = await userModel.create({ ...userData, password: hashedPassword });
+
+    return createUserData;
+  }
+
+  public async updateUser(userId: string, userData: CreateUserDto): Promise<User> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    if (userData.email) {
+      const findUser: User = await userModel.findOne({ email: userData.email });
+      if (findUser && findUser._id != userId) throw new HttpException(409, `You're email ${userData.email} already exists`);
+    }
+
+    if (userData.password) {
+      const hashedPassword = await hash(userData.password, 10);
+      userData = { ...userData, password: hashedPassword };
+    }
+
+    const updateUserById: User = await userModel.findByIdAndUpdate(userId, { userData });
+    if (!updateUserById) throw new HttpException(409, "You're not user");
+
+    return updateUserById;
+  }
+
+  public async deleteUser(userId: string): Promise<User> {
+    const deleteUserById: User = await userModel.findByIdAndDelete(userId);
+    if (!deleteUserById) throw new HttpException(409, "You're not user");
+
+    return deleteUserById;
+  }
+}
+
+export default UserService;

package/lib/typegoose/src/tests/auth.test.ts

@@ -0,0 +1,83 @@
+import bcrypt from 'bcrypt';
+import mongoose from 'mongoose';
+import request from 'supertest';
+import App from '@/app';
+import { CreateUserDto } from '@dtos/users.dto';
+import AuthRoute from '@routes/auth.route';
+
+afterAll(async () => {
+  await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
+});
+
+describe('Testing Auth', () => {
+  describe('[POST] /signup', () => {
+    it('response should have the Create userData', async () => {
+      const userData: CreateUserDto = {
+        email: 'test@email.com',
+        password: 'q1w2e3r4!',
+      };
+
+      const authRoute = new AuthRoute();
+      const users = authRoute.authController.authService.users;
+
+      users.findOne = jest.fn().mockReturnValue(null);
+      users.create = jest.fn().mockReturnValue({
+        _id: '60706478aad6c9ad19a31c84',
+        email: userData.email,
+        password: await bcrypt.hash(userData.password, 10),
+      });
+
+      (mongoose as any).connect = jest.fn();
+      const app = new App([authRoute]);
+      return request(app.getServer()).post(`${authRoute.path}signup`).send(userData);
+    });
+  });
+
+  describe('[POST] /login', () => {
+    it('response should have the Set-Cookie header with the Authorization token', async () => {
+      const userData: CreateUserDto = {
+        email: 'test@email.com',
+        password: 'q1w2e3r4!',
+      };
+
+      const authRoute = new AuthRoute();
+      const users = authRoute.authController.authService.users;
+
+      users.findOne = jest.fn().mockReturnValue({
+        _id: '60706478aad6c9ad19a31c84',
+        email: userData.email,
+        password: await bcrypt.hash(userData.password, 10),
+      });
+
+      (mongoose as any).connect = jest.fn();
+      const app = new App([authRoute]);
+      return request(app.getServer())
+        .post(`${authRoute.path}login`)
+        .send(userData)
+        .expect('Set-Cookie', /^Authorization=.+/);
+    });
+  });
+
+  // describe('[POST] /logout', () => {
+  //   it('logout Set-Cookie Authorization=; Max-age=0', async () => {
+  //     const userData: User = {
+  //       _id: '60706478aad6c9ad19a31c84',
+  //       email: 'test@email.com',
+  //       password: await bcrypt.hash('q1w2e3r4!', 10),
+  //     };
+
+  //     const authRoute = new AuthRoute();
+  //     const users = authRoute.authController.authService.users;
+
+  //     users.findOne = jest.fn().mockReturnValue(userData);
+
+  //     (mongoose as any).connect = jest.fn();
+  //     const app = new App([authRoute]);
+  //     return request(app.getServer())
+  //       .post(`${authRoute.path}logout`)
+  //       .send(userData)
+  //       .set('Set-Cookie', 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ')
+  //       .expect('Set-Cookie', /^Authorization=\; Max-age=0/);
+  //   });
+  // });
+});

package/lib/typegoose/src/tests/index.test.ts

@@ -0,0 +1,18 @@
+import request from 'supertest';
+import App from '@/app';
+import IndexRoute from '@routes/index.route';
+
+afterAll(async () => {
+  await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
+});
+
+describe('Testing Index', () => {
+  describe('[GET] /', () => {
+    it('response statusCode 200', () => {
+      const indexRoute = new IndexRoute();
+      const app = new App([indexRoute]);
+
+      return request(app.getServer()).get(`${indexRoute.path}`).expect(200);
+    });
+  });
+});

package/lib/typegoose/src/tests/users.test.ts

@@ -0,0 +1,133 @@
+import bcrypt from 'bcrypt';
+import mongoose from 'mongoose';
+import request from 'supertest';
+import App from '@/app';
+import { CreateUserDto } from '@dtos/users.dto';
+import UsersRoute from '@routes/users.route';
+
+afterAll(async () => {
+  await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
+});
+
+describe('Testing Users', () => {
+  describe('[GET] /users', () => {
+    it('response fineAll Users', async () => {
+      const usersRoute = new UsersRoute();
+      const users = usersRoute.usersController.userService.users;
+
+      users.find = jest.fn().mockReturnValue([
+        {
+          _id: 'qpwoeiruty',
+          email: 'a@email.com',
+          password: await bcrypt.hash('q1w2e3r4!', 10),
+        },
+        {
+          _id: 'alskdjfhg',
+          email: 'b@email.com',
+          password: await bcrypt.hash('a1s2d3f4!', 10),
+        },
+        {
+          _id: 'zmxncbv',
+          email: 'c@email.com',
+          password: await bcrypt.hash('z1x2c3v4!', 10),
+        },
+      ]);
+
+      (mongoose as any).connect = jest.fn();
+      const app = new App([usersRoute]);
+      return request(app.getServer()).get(`${usersRoute.path}`).expect(200);
+    });
+  });
+
+  describe('[GET] /users/:id', () => {
+    it('response findOne User', async () => {
+      const userId = 'qpwoeiruty';
+
+      const usersRoute = new UsersRoute();
+      const users = usersRoute.usersController.userService.users;
+
+      users.findOne = jest.fn().mockReturnValue({
+        _id: 'qpwoeiruty',
+        email: 'a@email.com',
+        password: await bcrypt.hash('q1w2e3r4!', 10),
+      });
+
+      (mongoose as any).connect = jest.fn();
+      const app = new App([usersRoute]);
+      return request(app.getServer()).get(`${usersRoute.path}/${userId}`).expect(200);
+    });
+  });
+
+  describe('[POST] /users', () => {
+    it('response Create User', async () => {
+      const userData: CreateUserDto = {
+        email: 'test@email.com',
+        password: 'q1w2e3r4',
+      };
+
+      const usersRoute = new UsersRoute();
+      const users = usersRoute.usersController.userService.users;
+
+      users.findOne = jest.fn().mockReturnValue(null);
+      users.create = jest.fn().mockReturnValue({
+        _id: '60706478aad6c9ad19a31c84',
+        email: userData.email,
+        password: await bcrypt.hash(userData.password, 10),
+      });
+
+      (mongoose as any).connect = jest.fn();
+      const app = new App([usersRoute]);
+      return request(app.getServer()).post(`${usersRoute.path}`).send(userData).expect(201);
+    });
+  });
+
+  describe('[PUT] /users/:id', () => {
+    it('response Update User', async () => {
+      const userId = '60706478aad6c9ad19a31c84';
+      const userData: CreateUserDto = {
+        email: 'test@email.com',
+        password: 'q1w2e3r4',
+      };
+
+      const usersRoute = new UsersRoute();
+      const users = usersRoute.usersController.userService.users;
+
+      if (userData.email) {
+        users.findOne = jest.fn().mockReturnValue({
+          _id: userId,
+          email: userData.email,
+          password: await bcrypt.hash(userData.password, 10),
+        });
+      }
+
+      users.findByIdAndUpdate = jest.fn().mockReturnValue({
+        _id: userId,
+        email: userData.email,
+        password: await bcrypt.hash(userData.password, 10),
+      });
+
+      (mongoose as any).connect = jest.fn();
+      const app = new App([usersRoute]);
+      return request(app.getServer()).put(`${usersRoute.path}/${userId}`).send(userData);
+    });
+  });
+
+  describe('[DELETE] /users/:id', () => {
+    it('response Delete User', async () => {
+      const userId = '60706478aad6c9ad19a31c84';
+
+      const usersRoute = new UsersRoute();
+      const users = usersRoute.usersController.userService.users;
+
+      users.findByIdAndDelete = jest.fn().mockReturnValue({
+        _id: '60706478aad6c9ad19a31c84',
+        email: 'test@email.com',
+        password: await bcrypt.hash('q1w2e3r4!', 10),
+      });
+
+      (mongoose as any).connect = jest.fn();
+      const app = new App([usersRoute]);
+      return request(app.getServer()).delete(`${usersRoute.path}/${userId}`).expect(200);
+    });
+  });
+});

package/lib/typegoose/src/utils/logger.ts

@@ -0,0 +1,65 @@
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import winston from 'winston';
+import winstonDaily from 'winston-daily-rotate-file';
+import { LOG_DIR } from '@config';
+
+// logs dir
+const logDir: string = join(__dirname, LOG_DIR);
+
+if (!existsSync(logDir)) {
+  mkdirSync(logDir);
+}
+
+// Define log format
+const logFormat = winston.format.printf(({ timestamp, level, message }) => `${timestamp} ${level}: ${message}`);
+
+/*
+ * Log Level
+ * error: 0, warn: 1, info: 2, http: 3, verbose: 4, debug: 5, silly: 6
+ */
+const logger = winston.createLogger({
+  format: winston.format.combine(
+    winston.format.timestamp({
+      format: 'YYYY-MM-DD HH:mm:ss',
+    }),
+    logFormat,
+  ),
+  transports: [
+    // debug log setting
+    new winstonDaily({
+      level: 'debug',
+      datePattern: 'YYYY-MM-DD',
+      dirname: logDir + '/debug', // log file /logs/debug/*.log in save
+      filename: `%DATE%.log`,
+      maxFiles: 30, // 30 Days saved
+      json: false,
+      zippedArchive: true,
+    }),
+    // error log setting
+    new winstonDaily({
+      level: 'error',
+      datePattern: 'YYYY-MM-DD',
+      dirname: logDir + '/error', // log file /logs/error/*.log in save
+      filename: `%DATE%.log`,
+      maxFiles: 30, // 30 Days saved
+      handleExceptions: true,
+      json: false,
+      zippedArchive: true,
+    }),
+  ],
+});
+
+logger.add(
+  new winston.transports.Console({
+    format: winston.format.combine(winston.format.splat(), winston.format.colorize()),
+  }),
+);
+
+const stream = {
+  write: (message: string) => {
+    logger.info(message.substring(0, message.lastIndexOf('\n')));
+  },
+};
+
+export { logger, stream };

package/lib/typegoose/src/utils/util.ts

@@ -0,0 +1,19 @@
+/**
+ * @method isEmpty
+ * @param {String | Number | Object} value
+ * @returns {Boolean} true & false
+ * @description this value is Empty Check
+ */
+export const isEmpty = (value: string | number | object): boolean => {
+  if (value === null) {
+    return true;
+  } else if (typeof value !== 'number' && value === '') {
+    return true;
+  } else if (typeof value === 'undefined' || value === undefined) {
+    return true;
+  } else if (value !== null && typeof value === 'object' && !Object.keys(value).length) {
+    return true;
+  } else {
+    return false;
+  }
+};

package/lib/typegoose/src/utils/validateEnv.ts

@@ -0,0 +1,10 @@
+import { cleanEnv, port, str } from 'envalid';
+
+const validateEnv = () => {
+  cleanEnv(process.env, {
+    NODE_ENV: str(),
+    PORT: port(),
+  });
+};
+
+export default validateEnv;