chore: list + format fix and restructure

.eslintrc

@@ -0,0 +1,20 @@
+{
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": 2020
+    },
+    "plugins": [
+        "@typescript-eslint/eslint-plugin"
+    ],
+    "extends": [
+        "plugin:@typescript-eslint/recommended",
+        "prettier/@typescript-eslint",
+        "plugin:prettier/recommended"
+    ],
+    "rules": {
+        "@typescript-eslint/interface-name-prefix": "off",
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/no-explicit-any": "off"
+    }
+}

package.json

@@ -7,9 +7,10 @@
     "start": "node ./build/src/app.js",
     "dev": "nodemon ./build/src/app.js",
     "build": "tsc -p .",
-    "production": "NODE_ENV=production node ./build/src/app.js",
-    "test": "LOG_LEVEL=debug jest --forceExit --silent ./build/test",
-    "coverage": "LOG_LEVEL=debug jest --coverage --forceExit ./build/test/api",
+    "build:watch": "tsc --watch",
+    "production": "cross-env NODE_ENV=production node ./build/src/app.js",
+    "test": "cross-env LOG_LEVEL=debug jest --forceExit --silent ./build/test",
+    "coverage": "cross-env LOG_LEVEL=debug jest --coverage --forceExit ./build/test/api",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix"
   },
   "author": "Shihab Mridha",
@@ -40,12 +41,14 @@
     "@types/validator": "12.0.1",
     "@typescript-eslint/eslint-plugin": "^5.59.9",
     "@typescript-eslint/parser": "^5.59.9",
+    "cross-env": "^7.0.3",
     "eslint": "^8.42.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
     "faker": "4.1.0",
     "jest": "^29.5.0",
     "jest-junit-reporter": "^1.1.0",
+    "nodemon": "^2.0.22",
     "prettier": "^2.8.8",
     "source-map-support": "0.5.21",
     "supertest": "^6.3.3",

src/app.ts

@@ -5,10 +5,11 @@ import * as express from 'express';
 import * as compress from 'compression';
 import app from './server';
 import * as cors from 'cors';
-import routes from './routes';
 import errorHandler from './common/errors/error.handler';
-import logger from './logger';
-import initDB from './database';
+import logger from './common/logger';
+import initDB from './common/database';
+import container from './inversify';
+import ApplicationRouter from './router';
 
 /**
  * This is a bootstrap function
@@ -23,8 +24,8 @@ async function bootstrap() {
     });
   }
 
-  app.disable('x-powered-by'); // Hide information
-  app.use(compress()); // Compress
+  app.disable('x-powered-by');
+  app.use(compress());
 
   // Enable middleware/whatever only in Production
   if (process.env.NODE_ENV === 'production') {
@@ -38,7 +39,7 @@ async function bootstrap() {
   app.use(cors());
 
   /**
-   * Configure mongoose
+   * Configure database
    **/
   if (!initDB.isDbConnected()) {
     await initDB.connect();
@@ -58,7 +59,9 @@ async function bootstrap() {
   /**
    * Configure routes
    */
-  routes(app);
+  // Let inversify resolve the dependency
+  const router = container.get<ApplicationRouter>(ApplicationRouter);
+  router.register(app);
 
   /**
    * Configure error handler

src/constants.ts → src/common/constants.ts

@@ -1,4 +1,4 @@
-enum StaticStringKeys {
+enum Constants {
   INVALID_REQUEST = 'Invalid request',
   INVALID_CREDENTIAL = 'Invalid credential',
   INVALID_ACCESS_TOKEN = 'Invalid access token',
@@ -14,4 +14,4 @@ enum StaticStringKeys {
   REPOSITORY_ERROR_INVALID_ID = 'Invalid id',
 }
 
-export default StaticStringKeys;
+export default Constants;

src/database.ts → src/common/database.ts

@@ -1,12 +1,12 @@
-import { MongoClient, Db, Collection } from 'mongodb';
+import { MongoClient, Db, Collection, ServerApiVersion } from 'mongodb';
 import logger from './logger';
+import { ApplicationError } from './errors/app.errors';
 
 /**
  * All the methods and properties mentioned in the following class is
  * specific to MongoDB. You should make necessary changes to support
- * the database you want to use.
+ * the database/orm you want to use.
  */
-
 class Database {
   private password: string;
 
@@ -21,10 +21,26 @@ class Database {
   private databaseInstance: Db;
 
   constructor() {
-    this.password = process.env.DB_PWD || '';
-    this.user = process.env.DB_USER || '';
-    this.host = process.env.DB_HOST || 'localhost:27017';
-    this.dbName = process.env.DB_NAME || 'my-db';
+    this.password = process.env.DB_PWD;
+    this.user = process.env.DB_USER;
+    this.host = process.env.DB_HOST;
+    this.dbName = process.env.DB_NAME;
+
+    if (!this.password) {
+      throw new Error('Database password not found');
+    }
+
+    if (!this.user) {
+      throw new Error('Database user not found');
+    }
+
+    if (!this.host) {
+      throw new Error('Database host not found');
+    }
+
+    if (!this.dbName) {
+      throw new Error('Database name not found');
+    }
   }
 
   public async connect(): Promise<void> {
@@ -41,11 +57,14 @@ class Database {
     logger.debug(`Database connection string: ${connectionString}`);
 
     const client = new MongoClient(connectionString, {
-      poolSize: 50,
+      maxPoolSize: 50,
       connectTimeoutMS: TWO_MINUTES_IN_MS,
       socketTimeoutMS: ONE_DAY_IN_MS,
-      useNewUrlParser: true,
-      useUnifiedTopology: true,
+      serverApi: {
+        version: ServerApiVersion.v1,
+        strict: true,
+        deprecationErrors: true,
+      }
     });
 
     this.dbClient = await client.connect();
@@ -55,7 +74,7 @@ class Database {
   }
 
   public async disconnect() {
-    if (this.dbClient.isConnected()) {
+    if (this.dbClient) {
       logger.info(`Disconnected from ${this.host}/${this.dbName}`);
       await this.dbClient.close();
     }
@@ -80,16 +99,7 @@ class Database {
    * Customize as needed for your database.
    */
   private getConnectionString() {
-    const env = process.env.NODE_ENV;
-    if (env === 'test' && !process.env.DB_NAME) {
-      this.dbName += '_test';
-    }
-
-    if (env !== 'localhost' && this.user && this.password) {
-      return `mongodb+srv://${this.user}:${this.password}@${this.host}/${this.dbName}`;
-    }
-
-    return `mongodb+srv://${this.host}/${this.dbName}`;
+    return `mongodb://${this.user}:${this.password}@${this.host}/${this.dbName}`;
   }
 
   public getDbHost() {
@@ -109,7 +119,7 @@ class Database {
   }
 
   public isDbConnected() {
-    return this.dbClient && this.dbClient.isConnected();
+    return Boolean(this.dbClient);
   }
 }
 

src/common/errors/app.errors.ts

@@ -1,4 +1,4 @@
-import StaticStringKeys from '../../constants';
+import Constants from '../constants';
 
 export class ApplicationError extends Error {
   public code = null;
@@ -48,23 +48,23 @@ export class InternalError extends ApplicationError {
 
 export class InvalidCredentialError extends BadRequestError {
   constructor(...args: any) {
-    super(StaticStringKeys.INVALID_CREDENTIAL, args);
+    super(Constants.INVALID_CREDENTIAL, args);
   }
 }
 
 export class InvalidTokenError extends BadRequestError {
   constructor(type: string, ...args: any) {
     if (type === 'ACCESS') {
-      super(StaticStringKeys.INVALID_ACCESS_TOKEN, args);
+      super(Constants.INVALID_ACCESS_TOKEN, args);
     } else {
-      super(StaticStringKeys.INVALID_REFRESH_TOKEN, args);
+      super(Constants.INVALID_REFRESH_TOKEN, args);
     }
   }
 }
 
 export class InvalidIdError extends BadRequestError {
   constructor(...args: any) {
-    super(StaticStringKeys.REPOSITORY_ERROR_INVALID_ID, args);
+    super(Constants.REPOSITORY_ERROR_INVALID_ID, args);
   }
 }
 

src/common/errors/error.handler.ts

@@ -6,13 +6,9 @@ import {
 } from 'express';
 import { NotFoundError, ApplicationError } from './app.errors';
 import { MongoError } from 'mongodb';
-import log from '../../logger';
+import log from '../logger';
 
 export default function (app: Application) {
-  /**
-   * Handle errors
-   */
-
   // If you are lost
   app.use(() => {
     throw new NotFoundError('You are lost');

src/repository.ts → src/common/repository.ts

@@ -1,7 +1,7 @@
 import { injectable, unmanaged } from 'inversify';
 import { Collection, Filter, ObjectId } from 'mongodb';
 import db from './database';
-import { getValidObjectId } from './common/utils/utils';
+import { getValidObjectId } from './utils/utils';
 
 /**
  * Fields you want to select. For mongodb it is a key-value pair.

src/common/utils/asyncWrapper.ts

@@ -5,16 +5,14 @@ import {
 } from 'express';
 
 // Wraps async functions, catching all errors and sending them forward to express error handler
-export default function asyncWrap(controller: CallableFunction) {
-  return async (
-    req: ExpressRequest,
-    res: ExpressResponse,
-    next: NextFunction,
-  ) => {
+const asyncWrap = (controller: CallableFunction) =>  {
+  return async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
     try {
       await controller(req, res, next);
-    } catch (e) {
-      next(e);
+    } catch (error) {
+      next(error);
     }
   };
 }
+
+export default asyncWrap;

src/common/utils/utils.ts

@@ -1,12 +1,6 @@
 import { ObjectId } from 'mongodb';
-import * as fs from 'fs';
-import * as utils from 'util';
 import { InvalidIdError } from '../errors/app.errors';
 
-// Promisify some utility functions
-export const exists = utils.promisify(fs.exists);
-export const mkdir = utils.promisify(fs.mkdir);
-
 export function getValidObjectId(id: string | ObjectId) {
   if (!ObjectId.isValid(id)) {
     throw new InvalidIdError();

src/inversify.ts

@@ -1,13 +1,17 @@
 import { Container } from 'inversify';
 import { TYPES } from './types';
-import UserRepository, {
-  IUserRepository,
-} from './repositories/user.repository';
-import UserService, { IUserService } from './services/user.service';
-import UserController from './controllers/user.controller';
+import UserRepository, { IUserRepository } from './user/user.repository';
+import UserService from './user/user.service';
+import UserController from './user/user.controller';
+import IUserService from './user/user.service.interface';
+import ApplicationRouter from './router';
 
 const container = new Container({ defaultScope: 'Singleton' });
-container.bind(UserController).to(UserController);
+// Like other dependencies we do not resolve ApplicationRouter via `TYPES`.
+// We get the instance of the class only in app.ts file during bootstrap.
+container.bind(ApplicationRouter).to(ApplicationRouter);
+
+container.bind<UserController>(TYPES.UserController).to(UserController);
 container.bind<IUserRepository>(TYPES.UserRepository).to(UserRepository);
 container.bind<IUserService>(TYPES.UserService).to(UserService);
 

src/router.ts

@@ -0,0 +1,16 @@
+import { Application } from 'express';
+import { injectable, inject } from 'inversify';
+import asyncWrap from './common/utils/asyncWrapper';
+import UserController from './user/user.controller';
+import { TYPES } from './types';
+
+@injectable()
+export default class ApplicationRouter {
+  @inject(TYPES.UserController) private userController: UserController;
+
+  public register(app: Application) {
+    app.get('/users', asyncWrap(this.userController.find));
+    app.get('/users/:id', asyncWrap(this.userController.get));
+    app.post('/users', asyncWrap(this.userController.create));
+  }
+}