typescript-express-starter 10.2.1 → 11.0.0

package/lib/node-postgres/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/node-postgres/src/interfaces/routes.interface.ts

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

package/lib/node-postgres/src/interfaces/users.interface.ts

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

package/lib/node-postgres/src/middlewares/auth.middleware.ts

@@ -1,46 +0,0 @@
-import { NextFunction, Response } from 'express';
-import { verify } from 'jsonwebtoken';
-import { SECRET_KEY } from '@config';
-import pg 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 } = (await verify(Authorization, SECRET_KEY)) as DataStoredInToken;
-      const { rows, rowCount } = await pg.query(`
-        SELECT
-          "email",
-          "password"
-        FROM
-          users
-        WHERE
-          "id" = $1
-      `, id);
-
-      if (rowCount) {
-        req.user = rows[0];
-        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/node-postgres/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/node-postgres/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/node-postgres/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/node-postgres/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/node-postgres/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/node-postgres/src/services/auth.service.ts

@@ -1,103 +0,0 @@
-import { hash, compare } from 'bcrypt';
-import { sign } from 'jsonwebtoken';
-import { Service } from 'typedi';
-import { SECRET_KEY } from '@config';
-import pg from '@database';
-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: User): Promise<User> {
-    const { email, password } = userData;
-
-    const { rows: findUser } = await pg.query(
-      `
-    SELECT EXISTS(
-      SELECT
-        "email"
-      FROM
-        users
-      WHERE
-        "email" = $1
-    )`,
-      [email],
-    );
-    if (findUser[0].exists) throw new HttpException(409, `This email ${userData.email} already exists`);
-
-    const hashedPassword = await hash(password, 10);
-    const { rows: signUpUserData } = await pg.query(
-      `
-      INSERT INTO
-        users(
-          "email",
-          "password"
-        )
-      VALUES ($1, $2)
-      RETURNING "email", "password"
-      `,
-      [email, hashedPassword],
-    );
-
-    return signUpUserData[0];
-  }
-
-  public async login(userData: User): Promise<{ cookie: string; findUser: User }> {
-    const { email, password } = userData;
-
-    const { rows, rowCount } = await pg.query(
-      `
-      SELECT
-        "email",
-        "password"
-      FROM
-        users
-      WHERE
-        "email" = $1
-    `,
-      [email],
-    );
-    if (!rowCount) throw new HttpException(409, `This email ${email} was not found`);
-
-    const isPasswordMatching: boolean = await compare(password, rows[0].password);
-    if (!isPasswordMatching) throw new HttpException(409, "You're password not matching");
-
-    const tokenData = createToken(rows[0]);
-    const cookie = createCookie(tokenData);
-    return { cookie, findUser: rows[0] };
-  }
-
-  public async logout(userData: User): Promise<User> {
-    const { email, password } = userData;
-
-    const { rows, rowCount } = await pg.query(
-      `
-    SELECT
-        "email",
-        "password"
-      FROM
-        users
-      WHERE
-        "email" = $1
-      AND
-        "password" = $2
-    `,
-      [email, password],
-    );
-    if (!rowCount) throw new HttpException(409, "User doesn't exist");
-
-    return rows[0];
-  }
-}

package/lib/node-postgres/src/services/users.service.ts

@@ -1,133 +0,0 @@
-import { hash } from 'bcrypt';
-import { Service } from 'typedi';
-import pg from '@database';
-import { HttpException } from '@exceptions/httpException';
-import { User } from '@interfaces/users.interface';
-
-@Service()
-export class UserService {
-  public async findAllUser(): Promise<User[]> {
-    const { rows } = await pg.query(`
-    SELECT
-      *
-    FROM
-      users
-    `);
-    return rows;
-  }
-
-  public async findUserById(userId: number): Promise<User> {
-    const { rows, rowCount } = await pg.query(
-      `
-    SELECT
-      *
-    FROM
-      users
-    WHERE
-      id = $1
-    `,
-      [userId],
-    );
-    if (!rowCount) throw new HttpException(409, "User doesn't exist");
-
-    return rows[0];
-  }
-
-  public async createUser(userData: User): Promise<User> {
-    const { email, password } = userData;
-
-    const { rows } = await pg.query(
-      `
-    SELECT EXISTS(
-      SELECT
-        "email"
-      FROM
-        users
-      WHERE
-        "email" = $1
-    )`,
-      [email],
-    );
-    if (rows[0].exists) throw new HttpException(409, `This email ${email} already exists`);
-
-    const hashedPassword = await hash(password, 10);
-    const { rows: createUserData } = await pg.query(
-      `
-      INSERT INTO
-        users(
-          "email",
-          "password"
-        )
-      VALUES ($1, $2)
-      RETURNING "email", "password"
-      `,
-      [email, hashedPassword],
-    );
-
-    return createUserData[0];
-  }
-
-  public async updateUser(userId: number, userData: User): Promise<User[]> {
-    const { rows: findUser } = await pg.query(
-      `
-      SELECT EXISTS(
-        SELECT
-          "id"
-        FROM
-          users
-        WHERE
-          "id" = $1
-      )`,
-      [userId],
-    );
-    if (findUser[0].exists) throw new HttpException(409, "User doesn't exist");
-
-    const { email, password } = userData;
-    const hashedPassword = await hash(password, 10);
-    const { rows: updateUserData } = await pg.query(
-      `
-      UPDATE
-        users
-      SET
-        "email" = $2,
-        "password" = $3
-      WHERE
-        "id" = $1
-      RETURNING "email", "password"
-    `,
-      [userId, email, hashedPassword],
-    );
-
-    return updateUserData;
-  }
-
-  public async deleteUser(userId: number): Promise<User[]> {
-    const { rows: findUser } = await pg.query(
-      `
-      SELECT EXISTS(
-        SELECT
-          "id"
-        FROM
-          users
-        WHERE
-          "id" = $1
-      )`,
-      [userId],
-    );
-    if (findUser[0].exists) throw new HttpException(409, "User doesn't exist");
-
-    const { rows: deleteUserData } = await pg.query(
-      `
-      DELETE
-      FROM
-        users
-      WHERE
-        id = $1
-      RETURNING "email", "password"
-      `,
-      [userId],
-    );
-
-    return deleteUserData;
-  }
-}

package/lib/node-postgres/src/test/auth.test.ts

@@ -1,57 +0,0 @@
-import request from 'supertest';
-import { App } from '@/app';
-import pg from '@database';
-import { CreateUserDto } from '@dtos/users.dto';
-import { AuthRoute } from '@routes/auth.route';
-
-afterAll(async () => {
-  await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
-  pg.end();
-});
-
-describe('Testing Auth', () => {
-  describe('[POST] /signup', () => {
-    it('response should have the Create userData', async () => {
-      const userData: CreateUserDto = {
-        email: 'example@email.com',
-        password: 'password',
-      };
-      const authRoute = new AuthRoute();
-      const app = new App([authRoute]);
-
-      return await request(app.getServer())
-      .post('/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: 'example1@email.com',
-        password: 'password',
-      };
-
-      const authRoute = new AuthRoute();
-      const app = new App([authRoute]);
-
-      return await request(app.getServer())
-        .post('/login')
-        .send(userData)
-        .expect('Set-Cookie', /^Authorization=.+/);
-    });
-  });
-
-  // error: StatusCode : 404, Message : Authentication token missing
-  // describe('[POST] /logout', () => {
-  //   it('logout Set-Cookie Authorization=; Max-age=0', () => {
-  //     const authRoute = new AuthRoute();
-  //     const app = new App([authRoute]);
-
-  //     return request(app.getServer())
-  //       .post('/logout')
-  //       .expect('Set-Cookie', /^Authorization=\;/);
-  //   });
-  // });
-});

package/lib/node-postgres/src/test/users.test.ts

@@ -1,72 +0,0 @@
-import request from 'supertest';
-import { App } from '@/app';
-import pg from '@database';
-import { CreateUserDto } from '@dtos/users.dto';
-import { UserRoute } from '@routes/users.route';
-
-afterAll(async () => {
-  await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
-  pg.end();
-});
-
-describe('Testing Users', () => {
-  describe('[GET] /users', () => {
-    it('response statusCode 200 / findAll', async () => {
-      const usersRoute = new UserRoute();
-      const app = new App([usersRoute]);
-
-      return await request(app.getServer()).get(`${usersRoute.path}`).expect(200);
-    });
-  });
-
-  describe('[GET] /users/:id', () => {
-    it('response statusCode 200 / findOne', async () => {
-      const usersRoute = new UserRoute();
-      const app = new App([usersRoute]);
-
-      return await request(app.getServer())
-        .get(`${usersRoute.path}`)
-        .query({
-          userId: 1,
-        })
-        .expect(200);
-    });
-  });
-
-  describe('[POST] /users', () => {
-    it('response statusCode 201 / created', async () => {
-      const userData: CreateUserDto = {
-        email: 'example@email.com',
-        password: 'password',
-      };
-      const usersRoute = new UserRoute();
-      const app = new App([usersRoute]);
-
-      return await request(app.getServer()).post(`${usersRoute.path}`).send(userData).expect(201);
-    });
-  });
-
-  describe('[PUT] /users/:id', () => {
-    it('response statusCode 200 / updated', async () => {
-      const userId = 1;
-      const userData: CreateUserDto = {
-        email: 'example@email.com',
-        password: 'password',
-      };
-      const usersRoute = new UserRoute();
-      const app = new App([usersRoute]);
-
-      return await request(app.getServer()).put(`${usersRoute.path}/${userId}`).send(userData).expect(200);
-    });
-  });
-
-  describe('[DELETE] /users/:id', () => {
-    it('response statusCode 200 / deleted', async () => {
-      const userId = 1;
-      const usersRoute = new UserRoute();
-      const app = new App([usersRoute]);
-
-      return await request(app.getServer()).delete(`${usersRoute.path}/${userId}`).expect(200);
-    });
-  });
-});

package/lib/node-postgres/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/node-postgres/src/utils/validateEnv.ts

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