typescript-express-starter 8.1.7 → 9.1.1

package/lib/mikro-orm/ecosystem.config.js

@@ -0,0 +1,57 @@
+/**
+ * @description pm2 configuration file.
+ * @example
+ *  production mode :: pm2 start ecosystem.config.js --only prod
+ *  development mode :: pm2 start ecosystem.config.js --only dev
+ */
+ module.exports = {
+  apps: [
+    {
+      name: 'prod', // pm2 start App name
+      script: 'dist/server.js',
+      exec_mode: 'cluster', // 'cluster' or 'fork'
+      instance_var: 'INSTANCE_ID', // instance variable
+      instances: 2, // pm2 instance count
+      autorestart: true, // auto restart if process crash
+      watch: false, // files change automatic restart
+      ignore_watch: ['node_modules', 'logs'], // ignore files change
+      max_memory_restart: '1G', // restart if process use more than 1G memory
+      merge_logs: true, // if true, stdout and stderr will be merged and sent to pm2 log
+      output: './logs/access.log', // pm2 log file
+      error: './logs/error.log', // pm2 error log file
+      env: { // environment variable
+        PORT: 3000,
+        NODE_ENV: 'production',
+      },
+    },
+    {
+      name: 'dev', // pm2 start App name
+      script: 'ts-node', // ts-node
+      args: '-r tsconfig-paths/register --transpile-only src/server.ts', // ts-node args
+      exec_mode: 'cluster', // 'cluster' or 'fork'
+      instance_var: 'INSTANCE_ID', // instance variable
+      instances: 2, // pm2 instance count
+      autorestart: true, // auto restart if process crash
+      watch: false, // files change automatic restart
+      ignore_watch: ['node_modules', 'logs'], // ignore files change
+      max_memory_restart: '1G', // restart if process use more than 1G memory
+      merge_logs: true, // if true, stdout and stderr will be merged and sent to pm2 log
+      output: './logs/access.log', // pm2 log file
+      error: './logs/error.log', // pm2 error log file
+      env: { // environment variable
+        PORT: 3000,
+        NODE_ENV: 'development',
+      },
+    },
+  ],
+  deploy: {
+    production: {
+      user: 'user',
+      host: '0.0.0.0',
+      ref: 'origin/master',
+      repo: 'git@github.com:repo.git',
+      path: 'dist/server.js',
+      'post-deploy': 'npm install && npm run build && pm2 reload ecosystem.config.js --only prod',
+    },
+  },
+};

package/lib/mikro-orm/jest.config.js

@@ -0,0 +1,12 @@
+const { pathsToModuleNameMapper } = require('ts-jest');
+const { compilerOptions } = require('./tsconfig.json');
+
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, { prefix: '<rootDir>/src' }),
+};

package/lib/mikro-orm/nginx.conf

@@ -0,0 +1,40 @@
+user  nginx;
+worker_processes  1;
+
+error_log  /var/log/nginx/error.log warn;
+pid        /var/run/nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+
+    upstream api-server {
+        server server:3000;
+        keepalive 100;
+    }
+
+    server {
+        listen 80;
+        server_name localhost;
+
+        location / {
+		proxy_http_version 1.1;
+            	proxy_pass         http://api-server;
+        }
+
+    }
+
+    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                      '$status $body_bytes_sent "$http_referer" '
+                      '"$http_user_agent" "$http_x_forwarded_for"';
+
+    access_log  /var/log/nginx/access.log  main;
+
+    sendfile        on;
+    keepalive_timeout  65;
+    include /etc/nginx/conf.d/*.conf;
+}

package/lib/mikro-orm/nodemon.json

@@ -0,0 +1,12 @@
+{
+    "watch": [
+        "src",
+        ".env"
+    ],
+    "ext": "js,ts,json",
+    "ignore": [
+        "src/logs/*",
+        "src/**/*.{spec,test}.ts"
+    ],
+    "exec": "ts-node -r tsconfig-paths/register --transpile-only src/server.ts"
+}

package/lib/mikro-orm/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "typescript-express-starter",
+  "version": "0.0.0",
+  "description": "TypeScript + MikroORM + MongoDB + Express API Server",
+  "author": "",
+  "license": "ISC",
+  "scripts": {
+    "start": "npm run build && cross-env NODE_ENV=production node dist/server.js",
+    "dev": "cross-env NODE_ENV=development nodemon",
+    "build": "swc src -d dist --source-maps --copy-files",
+    "build:tsc": "tsc && tsc-alias",
+    "test": "jest --forceExit --detectOpenHandles",
+    "lint": "eslint --ext .ts src/",
+    "lint:fix": "npm run lint -- --fix",
+    "deploy:prod": "npm run build && pm2 start ecosystem.config.js --only prod",
+    "deploy:dev": "pm2 start ecosystem.config.js --only dev"
+  },
+  "dependencies": {
+    "@mikro-orm/core": "^5.1.2",
+    "@mikro-orm/mongodb": "^5.1.2",
+    "bcrypt": "^5.0.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.13.1",
+    "compression": "^1.7.4",
+    "cookie-parser": "^1.4.5",
+    "cors": "^2.8.5",
+    "dotenv": "^10.0.0",
+    "envalid": "^7.1.0",
+    "express": "^4.17.1",
+    "helmet": "^4.6.0",
+    "hpp": "^0.2.3",
+    "jsonwebtoken": "^8.5.1",
+    "morgan": "^1.10.0",
+    "swagger-jsdoc": "^6.0.0",
+    "swagger-ui-express": "^4.1.6",
+    "winston": "^3.3.3",
+    "winston-daily-rotate-file": "^4.5.5"
+  },
+  "devDependencies": {
+    "@mikro-orm/mongo-highlighter": "^1.0.0",
+    "@swc/cli": "^0.1.51",
+    "@swc/core": "^1.2.108",
+    "@types/bcrypt": "^5.0.0",
+    "@types/compression": "^1.7.1",
+    "@types/cookie-parser": "^1.4.2",
+    "@types/cors": "^2.8.11",
+    "@types/express": "^4.17.13",
+    "@types/hpp": "^0.2.1",
+    "@types/jest": "27.4.x",
+    "@types/jsonwebtoken": "^8.5.4",
+    "@types/morgan": "^1.9.3",
+    "@types/node": "^16.0.1",
+    "@types/supertest": "^2.0.11",
+    "@types/swagger-jsdoc": "^6.0.1",
+    "@types/swagger-ui-express": "^4.1.3",
+    "@typescript-eslint/eslint-plugin": "^4.28.2",
+    "@typescript-eslint/parser": "^4.28.2",
+    "cross-env": "^7.0.3",
+    "eslint": "^7.30.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^3.4.0",
+    "husky": "^7.0.1",
+    "jest": "27.4.x",
+    "lint-staged": "^11.0.0",
+    "node-config": "^0.0.2",
+    "node-gyp": "^8.1.0",
+    "nodemon": "^2.0.9",
+    "pm2": "^5.1.0",
+    "prettier": "^2.3.2",
+    "supertest": "^6.2.2",
+    "ts-jest": "^27.1.4",
+    "ts-node": "^10.4.0",
+    "tsc-alias": "^1.4.1",
+    "tsconfig-paths": "^3.10.1",
+    "typescript": "^4.5.2"
+  }
+}

package/lib/mikro-orm/src/app.ts

@@ -0,0 +1,98 @@
+import express from 'express';
+import cookieParser from 'cookie-parser';
+import compression from 'compression';
+import cors from 'cors';
+import helmet from 'helmet';
+import hpp from 'hpp';
+import morgan from 'morgan';
+import swaggerJSDoc from 'swagger-jsdoc';
+import swaggerUi from 'swagger-ui-express';
+import { logger, stream } from '@utils/logger';
+import { MikroORM, RequestContext } from '@mikro-orm/core';
+import { NODE_ENV, PORT, LOG_FORMAT, ORIGIN, CREDENTIALS } from '@config';
+import { DI, dbOptions } from '@databases';
+import { UserEntity } from '@entities/users.entity';
+import { Routes } from '@interfaces/routes.interface';
+import errorMiddleware from '@middlewares/error.middleware';
+
+class App {
+  public app: express.Application;
+  public env: string;
+  public port: string | number;
+  public host: string;
+
+  constructor(routes: Routes[]) {
+    this.app = express();
+    this.env = NODE_ENV || 'development';
+    this.port = PORT || 3000;
+
+    this.initializeMiddlewares();
+    this.connectToDatabase();
+    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() {
+    try {
+      DI.orm = await MikroORM.init(dbOptions);
+      DI.em = DI.orm.em.fork();
+      DI.userRepository = DI.orm.em.fork().getRepository(UserEntity);
+    } catch (error) {
+      logger.error(error);
+    }
+    this.app.use((_1, _2, next) => RequestContext.create(DI.orm.em, next));
+  }
+
+  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/mikro-orm/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/mikro-orm/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/mikro-orm/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/mikro-orm/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 = await this.userService.deleteUser(userId);
+
+      res.status(200).json({ data: deleteUserData, message: 'deleted' });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+export default UsersController;

package/lib/mikro-orm/src/databases/index.ts

@@ -0,0 +1,19 @@
+import { EntityManager, EntityRepository, MikroORM, Options } from '@mikro-orm/core';
+import { MongoHighlighter } from '@mikro-orm/mongo-highlighter';
+import { NODE_ENV, DB_HOST, DB_PORT, DB_DATABASE } from '@config';
+import { BaseEntity } from '@entities/base.entity';
+import { UserEntity } from '@entities/users.entity';
+
+export const dbOptions: Options = {
+  type: 'mongo',
+  clientUrl: `mongodb://${DB_HOST}:${DB_PORT}/${DB_DATABASE}`,
+  entities: [BaseEntity, UserEntity],
+  highlighter: new MongoHighlighter(),
+  debug: NODE_ENV === 'development' ? true : false,
+};
+
+export const DI = {} as {
+  orm: MikroORM;
+  em: EntityManager;
+  userRepository: EntityRepository<UserEntity>;
+};

package/lib/mikro-orm/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/mikro-orm/src/entities/base.entity.ts

@@ -0,0 +1,16 @@
+import { PrimaryKey, Property, SerializedPrimaryKey } from '@mikro-orm/core';
+import { ObjectId } from '@mikro-orm/mongodb';
+
+export abstract class BaseEntity {
+  @PrimaryKey()
+  _id!: ObjectId;
+
+  @SerializedPrimaryKey({ type: 'text' })
+  id!: string;
+
+  @Property({ type: 'date' })
+  createdAt = new Date();
+
+  @Property({ type: 'date', onUpdate: () => new Date() })
+  updatedAt = new Date();
+}

package/lib/mikro-orm/src/entities/users.entity.ts

@@ -0,0 +1,17 @@
+import { Entity, Property } from '@mikro-orm/core';
+import { BaseEntity } from '@entities/base.entity';
+
+@Entity()
+export class UserEntity extends BaseEntity {
+  constructor(email: string, password: string) {
+    super();
+    this.email = email;
+    this.password = password;
+  }
+
+  @Property({ type: 'text' })
+  email!: string;
+
+  @Property({ type: 'text' })
+  password!: string;
+}

package/lib/mikro-orm/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/mikro-orm/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/mikro-orm/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/6257233cbfa5c2b8e249dbe7
+
+###
+# Create User
+POST {{ baseURL }}/users
+Content-Type: application/json
+
+{
+    "email": "example@email.com",
+    "password": "password"
+}
+
+###
+# Modify User By Id
+PUT {{ baseURL }}/users/6257233cbfa5c2b8e249dbe7
+Content-Type: application/json
+
+{
+    "email": "example@email.com",
+    "password": "password"
+}
+
+###
+# Delete User By Id
+DELETE {{ baseURL }}/users/6257233cbfa5c2b8e249dbe7

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

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

package/lib/mikro-orm/src/interfaces/users.interface.ts

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

package/lib/mikro-orm/src/middlewares/auth.middleware.ts

@@ -0,0 +1,32 @@
+import { NextFunction, Response } from 'express';
+import { verify } from 'jsonwebtoken';
+import { SECRET_KEY } from '@config';
+import { DI } from '@databases';
+import { HttpException } from '@exceptions/HttpException';
+import { DataStoredInToken, RequestWithUser } from '@interfaces/auth.interface';
+
+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 = verify(Authorization, secretKey) as DataStoredInToken;
+      const userId = verificationResponse._id;
+      const findUser = await DI.userRepository.findOne(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/mikro-orm/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;