typescript-express-starter 10.2.1 → 11.0.0

package/lib/sequelize/src/http/users.http

@@ -1,34 +0,0 @@
-# baseURL
-@baseURL = http://localhost:3000
-
-###
-# Find All Users
-GET {{ baseURL }}/users
-
-###
-# Find User By Id
-GET {{ baseURL }}/users/1
-
-###
-# Create User
-POST {{ baseURL }}/users
-Content-Type: application/json
-
-{
-    "email": "example@email.com",
-	"password": "password"
-}
-
-###
-# Modify User By Id
-PUT {{ baseURL }}/users/1
-Content-Type: application/json
-
-{
-    "email": "example@email.com",
-	"password": "password"
-}
-
-###
-# Delete User By Id
-DELETE {{ baseURL }}/users/1

package/lib/sequelize/src/interfaces/auth.interface.ts

@@ -1,15 +0,0 @@
-import { Request } from 'express';
-import { User } from '@interfaces/users.interface';
-
-export interface DataStoredInToken {
-  id: number;
-}
-
-export interface TokenData {
-  token: string;
-  expiresIn: number;
-}
-
-export interface RequestWithUser extends Request {
-  user: User;
-}

package/lib/sequelize/src/interfaces/routes.interface.ts

@@ -1,6 +0,0 @@
-import { Router } from 'express';
-
-export interface Routes {
-  path?: string;
-  router: Router;
-}

package/lib/sequelize/src/interfaces/users.interface.ts

@@ -1,5 +0,0 @@
-export interface User {
-  id?: number;
-  email: string;
-  password: string;
-}

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

@@ -1,38 +0,0 @@
-import { NextFunction, Response } from 'express';
-import { verify } from 'jsonwebtoken';
-import { SECRET_KEY } from '@config';
-import { DB } from '@database';
-import { HttpException } from '@exceptions/httpException';
-import { DataStoredInToken, RequestWithUser } from '@interfaces/auth.interface';
-
-const getAuthorization = (req) => {
-  const coockie = req.cookies['Authorization'];
-  if (coockie) return coockie;
-
-  const header = req.header('Authorization');
-  if (header) return header.split('Bearer ')[1];
-
-  return null;
-}
-
-export const AuthMiddleware = async (req: RequestWithUser, res: Response, next: NextFunction) => {
-  try {
-    const Authorization = getAuthorization(req);
-
-    if (Authorization) {
-      const { id } = verify(Authorization, SECRET_KEY) as DataStoredInToken;
-      const findUser = await DB.Users.findByPk(id);
-
-      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'));
-  }
-};

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

@@ -1,15 +0,0 @@
-import { NextFunction, Request, Response } from 'express';
-import { HttpException } from '@/exceptions/httpException';
-import { logger } from '@utils/logger';
-
-export 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);
-  }
-};

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

@@ -1,27 +0,0 @@
-import { plainToInstance } from 'class-transformer';
-import { validateOrReject, ValidationError } from 'class-validator';
-import { NextFunction, Request, Response } from 'express';
-import { HttpException } from '@exceptions/httpException';
-
-/**
- * @name ValidationMiddleware
- * @description Allows use of decorator and non-decorator based validation
- * @param type dto
- * @param skipMissingProperties When skipping missing properties
- * @param whitelist Even if your object is an instance of a validation class it can contain additional properties that are not defined
- * @param forbidNonWhitelisted If you would rather to have an error thrown when any non-whitelisted properties are present
- */
-export const ValidationMiddleware = (type: any, skipMissingProperties = false, whitelist = false, forbidNonWhitelisted = false) => {
-  return (req: Request, res: Response, next: NextFunction) => {
-    const dto = plainToInstance(type, req.body);
-    validateOrReject(dto, { skipMissingProperties, whitelist, forbidNonWhitelisted })
-      .then(() => {
-        req.body = dto;
-        next();
-      })
-      .catch((errors: ValidationError[]) => {
-        const message = errors.map((error: ValidationError) => Object.values(error.constraints)).join(', ');
-        next(new HttpException(400, message));
-      });
-  };
-};

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

@@ -1,39 +0,0 @@
-import { Sequelize, DataTypes, Model, Optional } from 'sequelize';
-import { User } from '@interfaces/users.interface';
-
-export type UserCreationAttributes = Optional<User, 'id' | 'email' | 'password'>;
-
-export class UserModel extends Model<User, UserCreationAttributes> implements User {
-  public id: number;
-  public email: string;
-  public password: string;
-
-  public readonly createdAt!: Date;
-  public readonly updatedAt!: Date;
-}
-
-export default function (sequelize: Sequelize): typeof UserModel {
-  UserModel.init(
-    {
-      id: {
-        autoIncrement: true,
-        primaryKey: true,
-        type: DataTypes.INTEGER,
-      },
-      email: {
-        allowNull: false,
-        type: DataTypes.STRING(45),
-      },
-      password: {
-        allowNull: false,
-        type: DataTypes.STRING(255),
-      },
-    },
-    {
-      tableName: 'users',
-      sequelize,
-    },
-  );
-
-  return UserModel;
-}

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

@@ -1,21 +0,0 @@
-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';
-
-export class AuthRoute implements Routes {
-  public router = Router();
-  public auth = new AuthController();
-
-  constructor() {
-    this.initializeRoutes();
-  }
-
-  private initializeRoutes() {
-    this.router.post('/signup', ValidationMiddleware(CreateUserDto), this.auth.signUp);
-    this.router.post('/login', ValidationMiddleware(CreateUserDto), this.auth.logIn);
-    this.router.post('/logout', AuthMiddleware, this.auth.logOut);
-  }
-}

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

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

package/lib/sequelize/src/server.ts

@@ -1,10 +0,0 @@
-import { App } from '@/app';
-import { AuthRoute } from '@routes/auth.route';
-import { UserRoute } from '@routes/users.route';
-import { ValidateEnv } from '@utils/validateEnv';
-
-ValidateEnv();
-
-const app = new App([new AuthRoute(), new UserRoute()]);
-
-app.listen();

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

@@ -1,52 +0,0 @@
-import { compare, hash } from 'bcrypt';
-import { sign } from 'jsonwebtoken';
-import { Service } from 'typedi';
-import { SECRET_KEY } from '@config';
-import { DB } from '@database';
-import { CreateUserDto } from '@dtos/users.dto';
-import { HttpException } from '@/exceptions/httpException';
-import { DataStoredInToken, TokenData } from '@interfaces/auth.interface';
-import { User } from '@interfaces/users.interface';
-
-const createToken = (user: User): TokenData => {
-  const dataStoredInToken: DataStoredInToken = { id: user.id };
-  const expiresIn: number = 60 * 60;
-
-  return { expiresIn, token: sign(dataStoredInToken, SECRET_KEY, { expiresIn }) };
-}
-
-const createCookie = (tokenData: TokenData): string => {
-  return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
-}
-@Service()
-export class AuthService {
-  public async signup(userData: CreateUserDto): Promise<User> {
-    const findUser: User = await DB.Users.findOne({ where: { email: userData.email } });
-    if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
-
-    const hashedPassword = await hash(userData.password, 10);
-    const createUserData: User = await DB.Users.create({ ...userData, password: hashedPassword });
-
-    return createUserData;
-  }
-
-  public async login(userData: CreateUserDto): Promise<{ cookie: string; findUser: User }> {
-    const findUser: User = await DB.Users.findOne({ where: { email: userData.email } });
-    if (!findUser) throw new HttpException(409, `This email ${userData.email} was not found`);
-
-    const isPasswordMatching: boolean = await compare(userData.password, findUser.password);
-    if (!isPasswordMatching) throw new HttpException(409, "Password not matching");
-
-    const tokenData = createToken(findUser);
-    const cookie = createCookie(tokenData);
-
-    return { cookie, findUser };
-  }
-
-  public async logout(userData: User): Promise<User> {
-    const findUser: User = await DB.Users.findOne({ where: { email: userData.email, password: userData.password } });
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    return findUser;
-  }
-}

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

@@ -1,50 +0,0 @@
-import { hash } from 'bcrypt';
-import { Service } from 'typedi';
-import { DB } from '@database';
-import { CreateUserDto } from '@dtos/users.dto';
-import { HttpException } from '@/exceptions/httpException';
-import { User } from '@interfaces/users.interface';
-
-@Service()
-export class UserService {
-  public async findAllUser(): Promise<User[]> {
-    const allUser: User[] = await DB.Users.findAll();
-    return allUser;
-  }
-
-  public async findUserById(userId: number): Promise<User> {
-    const findUser: User = await DB.Users.findByPk(userId);
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    return findUser;
-  }
-
-  public async createUser(userData: CreateUserDto): Promise<User> {
-    const findUser: User = await DB.Users.findOne({ where: { email: userData.email } });
-    if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
-
-    const hashedPassword = await hash(userData.password, 10);
-    const createUserData: User = await DB.Users.create({ ...userData, password: hashedPassword });
-    return createUserData;
-  }
-
-  public async updateUser(userId: number, userData: CreateUserDto): Promise<User> {
-    const findUser: User = await DB.Users.findByPk(userId);
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    const hashedPassword = await hash(userData.password, 10);
-    await DB.Users.update({ ...userData, password: hashedPassword }, { where: { id: userId } });
-
-    const updateUser: User = await DB.Users.findByPk(userId);
-    return updateUser;
-  }
-
-  public async deleteUser(userId: number): Promise<User> {
-    const findUser: User = await DB.Users.findByPk(userId);
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    await DB.Users.destroy({ where: { id: userId } });
-
-    return findUser;
-  }
-}

package/lib/sequelize/src/test/auth.test.ts

@@ -1,71 +0,0 @@
-import bcrypt from 'bcrypt';
-import { Sequelize } from 'sequelize';
-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: 1,
-        email: userData.email,
-        password: await bcrypt.hash(userData.password, 10),
-      });
-
-      (Sequelize as any).authenticate = jest.fn();
-      const app = new App([authRoute]);
-      return request(app.getServer()).post(`${authRoute.path}signup`).send(userData).expect(201);
-    });
-  });
-
-  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: 1,
-        email: userData.email,
-        password: await bcrypt.hash(userData.password, 10),
-      });
-
-      (Sequelize as any).authenticate = 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 authRoute = new AuthRoute();
-
-  //     const app = new App([authRoute]);
-  //     return request(app.getServer())
-  //       .post(`${authRoute.path}logout`)
-  //       .expect('Set-Cookie', /^Authorization=\;/);
-  //   });
-  // });
-});

package/lib/sequelize/src/test/users.test.ts

@@ -1,131 +0,0 @@
-import bcrypt from 'bcrypt';
-import { Sequelize } from 'sequelize';
-import request from 'supertest';
-import { App } from '@/app';
-import { CreateUserDto } from '@dtos/users.dto';
-import { UserRoute } from '@routes/users.route';
-
-afterAll(async () => {
-  await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
-});
-
-describe('Testing Users', () => {
-  describe('[GET] /users', () => {
-    it('response findAll users', async () => {
-      const usersRoute = new UserRoute();
-      const users = usersRoute.usersController.userService.users;
-
-      users.findAll = jest.fn().mockReturnValue([
-        {
-          id: 1,
-          email: 'a@email.com',
-          password: await bcrypt.hash('q1w2e3r4!', 10),
-        },
-        {
-          id: 2,
-          email: 'b@email.com',
-          password: await bcrypt.hash('a1s2d3f4!', 10),
-        },
-        {
-          id: 3,
-          email: 'c@email.com',
-          password: await bcrypt.hash('z1x2c3v4!', 10),
-        },
-      ]);
-
-      (Sequelize as any).authenticate = 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 = 1;
-
-      const usersRoute = new UserRoute();
-      const users = usersRoute.usersController.userService.users;
-
-      users.findByPk = jest.fn().mockReturnValue({
-        id: 1,
-        email: 'a@email.com',
-        password: await bcrypt.hash('q1w2e3r4!', 10),
-      });
-
-      (Sequelize as any).authenticate = 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 UserRoute();
-      const users = usersRoute.usersController.userService.users;
-
-      users.findOne = jest.fn().mockReturnValue(null);
-      users.create = jest.fn().mockReturnValue({
-        id: 1,
-        email: userData.email,
-        password: await bcrypt.hash(userData.password, 10),
-      });
-
-      (Sequelize as any).authenticate = 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 = 1;
-      const userData: CreateUserDto = {
-        email: 'test@email.com',
-        password: '1q2w3e4r!',
-      };
-
-      const usersRoute = new UserRoute();
-      const users = usersRoute.usersController.userService.users;
-
-      users.findByPk = jest.fn().mockReturnValue({
-        id: userId,
-        email: userData.email,
-        password: await bcrypt.hash(userData.password, 10),
-      });
-      users.update = jest.fn().mockReturnValue([1]);
-      users.findByPk = jest.fn().mockReturnValue({
-        id: userId,
-        email: userData.email,
-        password: await bcrypt.hash(userData.password, 10),
-      });
-
-      (Sequelize as any).authenticate = jest.fn();
-      const app = new App([usersRoute]);
-      return request(app.getServer()).put(`${usersRoute.path}/${userId}`).send(userData).expect(200);
-    });
-  });
-
-  describe('[DELETE] /users/:id', () => {
-    it('response Delete user', async () => {
-      const userId = 1;
-
-      const usersRoute = new UserRoute();
-      const users = usersRoute.usersController.userService.users;
-
-      users.findByPk = jest.fn().mockReturnValue({
-        id: userId,
-        email: 'a@email.com',
-        password: await bcrypt.hash('q1w2e3r4!', 10),
-      });
-
-      (Sequelize as any).authenticate = jest.fn();
-      const app = new App([usersRoute]);
-      return request(app.getServer()).delete(`${usersRoute.path}/${userId}`).expect(200);
-    });
-  });
-});

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

@@ -1,65 +0,0 @@
-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/sequelize/src/utils/validateEnv.ts

@@ -1,8 +0,0 @@
-import { cleanEnv, port, str } from 'envalid';
-
-export function ValidateEnv() {
-  cleanEnv(process.env, {
-    NODE_ENV: str(),
-    PORT: port(),
-  });
-}