Merge pull request #2 from AveselsJS/base-dependency-injection

Base dependency injection

package.json

@@ -21,7 +21,9 @@
   "homepage": "https://github.com/AveselsJS/dependency-ingection-practice#readme",
   "dependencies": {
     "express": "^4.17.2",
+    "inversify": "^6.0.1",
     "nodemon": "^2.0.15",
+    "reflect-metadata": "^0.1.13",
     "tslog": "^3.3.2"
   },
   "devDependencies": {

src/app.ts

@@ -1,10 +1,12 @@
 import express, {Express} from 'express';
 import { Server} from 'http';
+import { injectable } from 'inversify';
 import { ExeptionFilter } from './errors/exeption.filter';
 import { ILogger } from './logger/logger.interface';
 import { LoggerService } from './logger/logger.service';
 import { UserController } from './users/users.controller';
 
+@injectable()
 export class App {
     app: Express;
     server: Server;

src/common/base.controller.ts

@@ -1,12 +1,14 @@
 import { Response, Router } from "express";
-import { LoggerService } from "../logger/logger.service";
+import { injectable } from "inversify";
+import { ILogger } from "../logger/logger.interface";
 import { IControllerRoute } from "./route.interface";
 export {Router} from 'express';
 
+@injectable()
 export abstract class BaseController {
     private readonly _router: Router;
 
-    constructor(private logger: LoggerService) {
+    constructor(private logger: ILogger) {
         this._router = Router(); 
     }
 

src/errors/exeption.filter.ts

@@ -1,13 +1,13 @@
 import { NextFunction, Request, Response } from "express";
-import { LoggerService } from "../logger/logger.service";
+import { inject, injectable } from "inversify";
+import { ILogger } from "../logger/logger.interface";
+import { TYPES } from "../types";
 import { IExeptionFilter } from "./exeption.filter.interface";
 import { HTTPError } from "./http-error.class";
 
+@injectable()
 export class ExeptionFilter implements IExeptionFilter{
-    logger: LoggerService;
-    constructor(logger: LoggerService) {
-        this.logger = logger;
-    }
+    constructor(@inject(TYPES.ILoggerService) private logger: ILogger) { }
 
     catch (err: Error | HTTPError, req: Request, res: Response, next: NextFunction) {
         if (err instanceof HTTPError) {

src/logger/logger.service.ts

@@ -1,6 +1,8 @@
+import { injectable } from 'inversify';
 import {Logger} from 'tslog'
 import { ILogger } from './logger.interface';
 
+@injectable()
 export class LoggerService implements ILogger {
     logger: Logger;
 

src/main.ts

@@ -1,12 +1,20 @@
+import { Container } from "inversify";
+
 import { App } from "./app";
 import { ExeptionFilter } from "./errors/exeption.filter";
+import { IExeptionFilter } from "./errors/exeption.filter.interface";
+import { ILogger } from "./logger/logger.interface";
 import { LoggerService } from "./logger/logger.service";
 import { UserController } from "./users/users.controller";
+import { TYPES } from "./types";
+
+const appContainer = new Container();
+appContainer.bind<ILogger>(TYPES.ILoggerService).to(LoggerService);
+appContainer.bind<IExeptionFilter>(TYPES.ExeptionFilter).to(ExeptionFilter);
+appContainer.bind<UserController>(TYPES.UserController).to(UserController);
+appContainer.bind<App>(TYPES.Application).to(App);
 
-async function bootstrap() {
-    const logger = new LoggerService();
-    const app = new App(logger, new UserController(logger), new ExeptionFilter(logger));
-    await app.init();
-}
+const app = appContainer.get<App>(TYPES.Application);
+app.init();
 
-bootstrap()
+export {app, appContainer};

src/types.ts

@@ -0,0 +1,6 @@
+export const TYPES = {
+    Application: Symbol.for('Application'),
+    ILoggerService: Symbol.for('ILoggerService'),
+    UserController: Symbol.for('UserController'),
+    ExeptionFilter: Symbol.for('ExeptionFilter')
+}

src/users/users.controller.ts

@@ -1,11 +1,15 @@
 import { NextFunction, Request, Response } from "express";
+import { inject, injectable } from "inversify";
 import { BaseController } from "../common/base.controller";
 import { HTTPError } from "../errors/http-error.class";
-import { LoggerService } from "../logger/logger.service";
+import { ILogger } from "../logger/logger.interface";
+import { TYPES } from "../types";
 
+
+@injectable()
 export class UserController extends BaseController{
-    constructor(logger: LoggerService) {
-        super(logger);
+    constructor(@inject(TYPES.ILoggerService) private loggerService: ILogger) {
+        super(loggerService);
         this.bindRoutes([
             {path: '/login', method: 'post', func: this.login},
             {path: '/register', method: 'post', func: this.register}