typescript-express-starter 7.0.0 → 8.0.0

package/lib/typegoose/src/app.ts

@@ -0,0 +1,93 @@
+import compression from 'compression';
+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 { connect, set } from 'mongoose';
+import swaggerJSDoc from 'swagger-jsdoc';
+import swaggerUi from 'swagger-ui-express';
+import { NODE_ENV, PORT, LOG_FORMAT, ORIGIN, CREDENTIALS } from '@config';
+import { dbConnection } from '@databases';
+import { Routes } from '@interfaces/routes.interface';
+import errorMiddleware from '@middlewares/error.middleware';
+import { logger, stream } from '@utils/logger';
+
+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 connectToDatabase() {
+    if (this.env !== 'production') {
+      set('debug', true);
+    }
+
+    connect(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);
+  }
+}
+
+export default App;

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

@@ -0,0 +1,5 @@
+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, DB_HOST, DB_PORT, DB_DATABASE, SECRET_KEY, LOG_FORMAT, LOG_DIR, ORIGIN } = process.env;

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

@@ -0,0 +1,46 @@
+import { NextFunction, Request, Response } from 'express';
+import { CreateUserDto } from '@dtos/users.dto';
+import { RequestWithUser } from '@interfaces/auth.interface';
+import { User } from '@interfaces/users.interface';
+import AuthService from '@services/auth.service';
+
+class AuthController {
+  public authService = new AuthService();
+
+  public signUp = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const userData: CreateUserDto = req.body;
+      const signUpUserData: User = await this.authService.signup(userData);
+
+      res.status(201).json({ data: signUpUserData, message: 'signup' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public logIn = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const userData: CreateUserDto = req.body;
+      const { cookie, findUser } = await this.authService.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) => {
+    try {
+      const userData: User = req.user;
+      const logOutUserData: User = await this.authService.logout(userData);
+
+      res.setHeader('Set-Cookie', ['Authorization=; Max-age=0']);
+      res.status(200).json({ data: logOutUserData, message: 'logout' });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+export default AuthController;

package/lib/typegoose/src/controllers/index.controller.ts

@@ -0,0 +1,13 @@
+import { NextFunction, Request, Response } from 'express';
+
+class IndexController {
+  public index = (req: Request, res: Response, next: NextFunction) => {
+    try {
+      res.sendStatus(200);
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+export default IndexController;

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

@@ -0,0 +1,65 @@
+import { NextFunction, Request, Response } from 'express';
+import { CreateUserDto } from '@dtos/users.dto';
+import { User } from '@interfaces/users.interface';
+import userService from '@services/users.service';
+
+class UsersController {
+  public userService = new userService();
+
+  public getUsers = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const findAllUsersData: User[] = await this.userService.findAllUser();
+
+      res.status(200).json({ data: findAllUsersData, message: 'findAll' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public getUserById = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const userId: string = req.params.id;
+      const findOneUserData: User = await this.userService.findUserById(userId);
+
+      res.status(200).json({ data: findOneUserData, message: 'findOne' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public createUser = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const userData: CreateUserDto = req.body;
+      const createUserData: User = await this.userService.createUser(userData);
+
+      res.status(201).json({ data: createUserData, message: 'created' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public updateUser = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const userId: string = req.params.id;
+      const userData: CreateUserDto = req.body;
+      const updateUserData: User = await this.userService.updateUser(userId, userData);
+
+      res.status(200).json({ data: updateUserData, message: 'updated' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public deleteUser = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const userId: string = req.params.id;
+      const deleteUserData: User = await this.userService.deleteUser(userId);
+
+      res.status(200).json({ data: deleteUserData, message: 'deleted' });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+export default UsersController;

package/lib/typegoose/src/databases/index.ts

@@ -0,0 +1,3 @@
+import { DB_HOST, DB_PORT, DB_DATABASE } from '@config';
+
+export const dbConnection = `mongodb://${DB_HOST}:${DB_PORT}/${DB_DATABASE}`;

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

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

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

@@ -0,0 +1,10 @@
+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/typegoose/src/http/auth.http

@@ -0,0 +1,32 @@
+# 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
+
+{
+    "email": "example@email.com",
+    "password": "password"
+}

package/lib/typegoose/src/http/users.http

@@ -0,0 +1,34 @@
+# 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/typegoose/src/interfaces/auth.interface.ts

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

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

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

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

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

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;