typescript-express-starter 10.2.1 → 11.0.0

package/lib/typeorm/src/app.ts

@@ -1,87 +0,0 @@
-import 'reflect-metadata';
-import cookieParser from 'cookie-parser';
-import cors from 'cors';
-import express from 'express';
-import helmet from 'helmet';
-import hpp from 'hpp';
-import morgan from 'morgan';
-import compression from 'compression';
-import swaggerUi from 'swagger-ui-express';
-import swaggerJSDoc from 'swagger-jsdoc';
-import { NODE_ENV, PORT, LOG_FORMAT, ORIGIN, CREDENTIALS } from '@config';
-import { dbConnection } from '@database';
-import { Routes } from '@interfaces/routes.interface';
-import { ErrorMiddleware } from '@middlewares/error.middleware';
-import { logger, stream } from '@utils/logger';
-
-export class App {
-  public app: express.Application;
-  public env: string;
-  public port: string | number;
-
-  constructor(routes: Routes[]) {
-    this.app = express();
-    this.env = NODE_ENV || 'development';
-    this.port = PORT || 3000;
-
-    this.connectToDatabase();
-    this.initializeMiddlewares();
-    this.initializeRoutes(routes);
-    this.initializeSwagger();
-    this.initializeErrorHandling();
-  }
-
-  public listen() {
-    this.app.listen(this.port, () => {
-      logger.info(`=================================`);
-      logger.info(`======= ENV: ${this.env} =======`);
-      logger.info(`🚀 App listening on the port ${this.port}`);
-      logger.info(`=================================`);
-    });
-  }
-
-  public getServer() {
-    return this.app;
-  }
-
-  private async connectToDatabase() {
-    await dbConnection();
-  }
-
-  private initializeMiddlewares() {
-    this.app.use(morgan(LOG_FORMAT, { stream }));
-    this.app.use(cors({ origin: ORIGIN, credentials: CREDENTIALS }));
-    this.app.use(hpp());
-    this.app.use(helmet());
-    this.app.use(compression());
-    this.app.use(express.json());
-    this.app.use(express.urlencoded({ extended: true }));
-    this.app.use(cookieParser());
-  }
-
-  private initializeRoutes(routes: Routes[]) {
-    routes.forEach(route => {
-      this.app.use('/', route.router);
-    });
-  }
-
-  private initializeSwagger() {
-    const options = {
-      swaggerDefinition: {
-        info: {
-          title: 'REST API',
-          version: '1.0.0',
-          description: 'Example docs',
-        },
-      },
-      apis: ['swagger.yaml'],
-    };
-
-    const specs = swaggerJSDoc(options);
-    this.app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(specs));
-  }
-
-  private initializeErrorHandling() {
-    this.app.use(ErrorMiddleware);
-  }
-}

package/lib/typeorm/src/config/index.ts

@@ -1,6 +0,0 @@
-import { config } from 'dotenv';
-config({ path: `.env.${process.env.NODE_ENV || 'development'}.local` });
-
-export const CREDENTIALS = process.env.CREDENTIALS === 'true';
-export const { NODE_ENV, PORT, SECRET_KEY, LOG_FORMAT, LOG_DIR, ORIGIN } = process.env;
-export const { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DATABASE } = process.env;

package/lib/typeorm/src/controllers/auth.controller.ts

@@ -1,44 +0,0 @@
-import { NextFunction, Request, Response } from 'express';
-import { Container } from 'typedi';
-import { RequestWithUser } from '@interfaces/auth.interface';
-import { User } from '@interfaces/users.interface';
-import { AuthService } from '@services/auth.service';
-
-export class AuthController {
-  public auth = Container.get(AuthService);
-
-  public signUp = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const userData: User = req.body;
-      const signUpUserData: User = await this.auth.signup(userData);
-
-      res.status(201).json({ data: signUpUserData, message: 'signup' });
-    } catch (error) {
-      next(error);
-    }
-  };
-
-  public logIn = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const userData: User = req.body;
-      const { cookie, findUser } = await this.auth.login(userData);
-
-      res.setHeader('Set-Cookie', [cookie]);
-      res.status(200).json({ data: findUser, message: 'login' });
-    } catch (error) {
-      next(error);
-    }
-  };
-
-  public logOut = async (req: RequestWithUser, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const userData: User = req.user;
-      const logOutUserData: User = await this.auth.logout(userData);
-
-      res.setHeader('Set-Cookie', ['Authorization=; Max-age=0']);
-      res.status(200).json({ data: logOutUserData, message: 'logout' });
-    } catch (error) {
-      next(error);
-    }
-  };
-}

package/lib/typeorm/src/controllers/users.controller.ts

@@ -1,63 +0,0 @@
-import { NextFunction, Request, Response } from 'express';
-import { Container } from 'typedi';
-import { User } from '@interfaces/users.interface';
-import { UserService } from '@services/users.service';
-
-export class UserController {
-  public user = Container.get(UserService);
-
-  public getUsers = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const findAllUsersData: User[] = await this.user.findAllUser();
-
-      res.status(200).json({ data: findAllUsersData, message: 'findAll' });
-    } catch (error) {
-      next(error);
-    }
-  };
-
-  public getUserById = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const userId = Number(req.params.id);
-      const findOneUserData: User = await this.user.findUserById(userId);
-
-      res.status(200).json({ data: findOneUserData, message: 'findOne' });
-    } catch (error) {
-      next(error);
-    }
-  };
-
-  public createUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const userData: User = req.body;
-      const createUserData: User = await this.user.createUser(userData);
-
-      res.status(201).json({ data: createUserData, message: 'created' });
-    } catch (error) {
-      next(error);
-    }
-  };
-
-  public updateUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const userId = Number(req.params.id);
-      const userData: User = req.body;
-      const updateUserData: User = await this.user.updateUser(userId, userData);
-
-      res.status(200).json({ data: updateUserData, message: 'updated' });
-    } catch (error) {
-      next(error);
-    }
-  };
-
-  public deleteUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const userId = Number(req.params.id);
-      const deleteUserData: User = await this.user.deleteUser(userId);
-
-      res.status(200).json({ data: deleteUserData, message: 'deleted' });
-    } catch (error) {
-      next(error);
-    }
-  };
-}

package/lib/typeorm/src/database/index.ts

@@ -1,26 +0,0 @@
-import { join } from 'path';
-import { createConnection, ConnectionOptions } from 'typeorm';
-import { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DATABASE } from '@config';
-
-export const dbConnection = async () => {
-  const dbConfig: ConnectionOptions = {
-    type: 'postgres',
-    username: POSTGRES_USER,
-    password: POSTGRES_PASSWORD,
-    host: POSTGRES_HOST,
-    port: +POSTGRES_PORT,
-    database: POSTGRES_DATABASE,
-    synchronize: true,
-    logging: false,
-    entities: [join(__dirname, '../**/*.entity{.ts,.js}')],
-    migrations: [join(__dirname, '../**/*.migration{.ts,.js}')],
-    subscribers: [join(__dirname, '../**/*.subscriber{.ts,.js}')],
-    cli: {
-      entitiesDir: 'src/entities',
-      migrationsDir: 'src/migration',
-      subscribersDir: 'src/subscriber',
-    },
-  };
-
-  await createConnection(dbConfig);
-};

package/lib/typeorm/src/dtos/users.dto.ts

@@ -1,20 +0,0 @@
-import { IsEmail, IsString, IsNotEmpty, MinLength, MaxLength } from 'class-validator';
-
-export class CreateUserDto {
-  @IsEmail()
-  public email: string;
-
-  @IsString()
-  @IsNotEmpty()
-  @MinLength(9)
-  @MaxLength(32)
-  public password: string;
-}
-
-export class UpdateUserDto {
-  @IsString()
-  @IsNotEmpty()
-  @MinLength(9)
-  @MaxLength(32)
-  public password: string;
-}

package/lib/typeorm/src/entities/users.entity.ts

@@ -1,26 +0,0 @@
-import { IsNotEmpty } from 'class-validator';
-import { BaseEntity, Entity, PrimaryGeneratedColumn, Column, Unique, CreateDateColumn, UpdateDateColumn } from 'typeorm';
-import { User } from '@interfaces/users.interface';
-
-@Entity()
-export class UserEntity extends BaseEntity implements User {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column()
-  @IsNotEmpty()
-  @Unique(['email'])
-  email: string;
-
-  @Column()
-  @IsNotEmpty()
-  password: string;
-
-  @Column()
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @Column()
-  @UpdateDateColumn()
-  updatedAt: Date;
-}

package/lib/typeorm/src/exceptions/HttpException.ts

@@ -1,10 +0,0 @@
-export class HttpException extends Error {
-  public status: number;
-  public message: string;
-
-  constructor(status: number, message: string) {
-    super(message);
-    this.status = status;
-    this.message = message;
-  }
-}

package/lib/typeorm/src/http/auth.http

@@ -1,27 +0,0 @@
-# baseURL
-@baseURL = http://localhost:3000
-
-###
-# User Signup
-POST {{ baseURL }}/signup
-Content-Type: application/json
-
-{
-    "email": "example@email.com",
-	"password": "password"
-}
-
-###
-# User Login
-POST {{ baseURL }}/login
-Content-Type: application/json
-
-{
-    "email": "example@email.com",
-	"password": "password"
-}
-
-###
-# User Logout
-POST {{ baseURL }}/logout
-Content-Type: application/json

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

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

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

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

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

@@ -1,38 +0,0 @@
-import { NextFunction, Response } from 'express';
-import { verify } from 'jsonwebtoken';
-import { SECRET_KEY } from '@config';
-import { UserEntity } from '@entities/users.entity';
-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 findUser = await UserEntity.findOne(id, { select: ['id', 'email', 'password'] });
-
-      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/typeorm/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/typeorm/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/typeorm/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/typeorm/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/typeorm/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/typeorm/src/services/auth.service.ts

@@ -1,54 +0,0 @@
-import { compare, hash } from 'bcrypt';
-import { sign } from 'jsonwebtoken';
-import { Service } from 'typedi';
-import { EntityRepository, Repository } from 'typeorm';
-import { SECRET_KEY } from '@config';
-import { UserEntity } from '@entities/users.entity';
-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 secretKey: string = SECRET_KEY;
-  const expiresIn: number = 60 * 60;
-
-  return { expiresIn, token: sign(dataStoredInToken, secretKey, { expiresIn }) };
-}
-
-const createCookie = (tokenData: TokenData): string => {
-  return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
-}
-
-@Service()
-@EntityRepository()
-export class AuthService extends Repository<UserEntity> {
-  public async signup(userData: User): Promise<User> {
-    const findUser: User = await UserEntity.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 UserEntity.create({ ...userData, password: hashedPassword }).save();
-    return createUserData;
-  }
-
-  public async login(userData: User): Promise<{ cookie: string; findUser: User }> {
-    const findUser: User = await UserEntity.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 UserEntity.findOne({ where: { email: userData.email, password: userData.password } });
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    return findUser;
-  }
-}

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

@@ -1,51 +0,0 @@
-import { hash } from 'bcrypt';
-import { EntityRepository, Repository } from 'typeorm';
-import { Service } from 'typedi';
-import { UserEntity } from '@entities/users.entity';
-import { HttpException } from '@/exceptions/httpException';
-import { User } from '@interfaces/users.interface';
-
-@Service()
-@EntityRepository()
-export class UserService extends Repository<UserEntity> {
-  public async findAllUser(): Promise<User[]> {
-    const users: User[] = await UserEntity.find();
-    return users;
-  }
-
-  public async findUserById(userId: number): Promise<User> {
-    const findUser: User = await UserEntity.findOne({ where: { id: userId } });
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    return findUser;
-  }
-
-  public async createUser(userData: User): Promise<User> {
-    const findUser: User = await UserEntity.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 UserEntity.create({ ...userData, password: hashedPassword }).save();
-
-    return createUserData;
-  }
-
-  public async updateUser(userId: number, userData: User): Promise<User> {
-    const findUser: User = await UserEntity.findOne({ where: { id: userId } });
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    const hashedPassword = await hash(userData.password, 10);
-    await UserEntity.update(userId, { ...userData, password: hashedPassword });
-
-    const updateUser: User = await UserEntity.findOne({ where: { id: userId } });
-    return updateUser;
-  }
-
-  public async deleteUser(userId: number): Promise<User> {
-    const findUser: User = await UserEntity.findOne({ where: { id: userId } });
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
-
-    await UserEntity.delete({ id: userId });
-    return findUser;
-  }
-}