fix: adjusting some import and methods call

src/Main.ts

@@ -10,16 +10,16 @@ export enum ExitStatus {
 export default class Main {
   public static async start(): Promise<void> {
     try {
-      this.initServices();
+      await this.initServices();
     } catch (error) {
       Logger.error({ msg: `App exited with error: ${error}` });
       process.exit(ExitStatus.Failure);
     }
   }
 
-  private static initServices() {
+  private static async initServices() {
     const app = new App(Number(Env.app.port));
-    app.setup();
+    await app.setup();
     app.start();
     this.setupUncaughtExceptions();
     this.setupUnhandledRejection();

src/__dependencies__/logger/pino/index.test.ts

@@ -15,7 +15,7 @@ describe('Pino Tests', () => {
     it('should call pino when constructor is called by the first time', () => {
       (PinoLogger as any).pinoLogger = undefined;
       PinoLogger.getInstance();
-      expect(pino).toBeCalledWith({ enabled: true });
+      expect(pino).toBeCalledWith({ enabled: false });
       expect(pino).toBeCalledTimes(1);
     });
   });

src/__dependencies__/webFramework/ExpressWebFramework.ts

@@ -1,31 +1,41 @@
+import {
+  IMiddleware,
+  IWebFramework,
+} from '../../util/webFramework/framework/WebFramework';
 import express, { Application, Request, Response, Router } from 'express';
 
-import { IController } from '../../interfaces/IController';
+import { BaseController } from '../../abstracts/BaseController';
 import { IHttpRequest } from '../../interfaces/IHttpRequest';
-import { IWebFramework } from '../../util/webFramework/framework/WebFramework';
+import { Server } from 'http';
 
 export default class ExpressWebFramework
   implements IWebFramework<(req: Request, res: Response) => Promise<void>>
 {
   private application: Application;
+  private server?: Server;
 
   constructor() {
     this.application = express();
     this.application.use(express.json());
   }
 
   public startServer(port: number, callback: () => void): void {
-    this.application.listen(port, callback);
+    this.server = this.application.listen(port, callback);
   }
 
-  public addMiddleware(
-    middleware: (req: Request, res: Response) => Promise<void>
-  ): void {
-    this.application.use(middleware);
+  public addMiddleware(middleware: IMiddleware): void {
+    const expressMiddleware = async (
+      req: Request,
+      res: Response
+    ): Promise<void> => {
+      const result = await middleware.executeMiddleware(req);
+      await res.status(result.statusCode).json(result.body);
+    };
+    this.application.use(expressMiddleware);
   }
 
-  public closeServer(): void {
-    throw new Error('Method not implemented.');
+  public async closeServer(): Promise<void> {
+    await this.server?.close();
   }
 
   public get(
@@ -47,12 +57,12 @@ export default class ExpressWebFramework
   }
 
   public execController(
-    controller: IController
+    controller: BaseController
   ): (req: Request, res: Response) => Promise<void> {
     return async (req: Request, res: Response) => {
       const httpRequest = this.getHttpRequest(req);
 
-      const httpResponse = await controller.executeRoute(httpRequest);
+      const httpResponse = await controller.execute(httpRequest);
 
       res.status(httpResponse.statusCode).json(httpResponse.body);
     };

src/config/Env.ts

@@ -22,7 +22,7 @@ class Envs {
     return {
       port: Number(process.env.APP_PORT) || 3333,
       logger: {
-        enabled: Boolean(process.env.LOGGER_ENABLED) || true,
+        enabled: Boolean(process.env.LOGGER_ENABLED) || false,
       },
       database: {
         address: process.env.DATABASE_ADDRESS || 'localhost',

src/config/RoutesEnum.ts

@@ -1,5 +1,5 @@
 export enum RoutesEnum {
   SIGN_IN = '/signin',
   SIGN_UP = '/signup',
-  USERS = '/users',
+  USERS = '/users/:id',
 }

src/interfaces/IHttpRequest.ts

@@ -1,5 +1,11 @@
 export interface IHttpRequest {
-  headers?: unknown;
-  params?: unknown;
+  headers?: {
+    authorization?: string;
+    [key: string]: unknown;
+  };
+  params?: {
+    id?: string;
+    [key: string]: unknown;
+  };
   body: unknown;
 }

src/repositories/IRepository.ts

@@ -1,7 +1,7 @@
 export interface IRepository<T> {
   create(model: T): Promise<T>;
   delete?(model: T): Promise<T>;
-  update(property: Partial<T>): Promise<T>;
-  findOne(property: Partial<T>): Promise<T>;
+  update(property: Partial<T>, model: Partial<T>): Promise<T>;
+  findOne(property: Partial<T>): Promise<T | undefined>;
   findAll?(property: Partial<T>): Promise<T[]>;
 }

src/repositories/repositoryModel/IRepositoryModel.ts

@@ -2,4 +2,6 @@ export interface IRepositoryModel<T> {
   save(model: T): Promise<T>;
   findOne(properties: Partial<T>): Promise<T | undefined>;
   updateOne(properties: Partial<T>, model: Partial<T>): Promise<T | undefined>;
+  findOneByIdAndToken(userId: string, token: string): Promise<T | undefined>;
+  deleteAll(): Promise<void>;
 }

src/repositories/users/UserRepository.ts

@@ -1,37 +1,52 @@
+import { DatabaseError } from '../../util/errors/DatabaseError';
 import { IRepository } from '../IRepository';
 import { IRepositoryModel } from '../repositoryModel/IRepositoryModel';
 import { IUser } from '../../models/user/IUser';
-
+import httpStatus from 'http-status-codes';
 export class UserRepository implements IRepository<IUser> {
   constructor(private readonly UserRepositoryModel: IRepositoryModel<IUser>) {}
 
-  public async create(model: IUser): Promise<IUser> {
-    const user = await this.UserRepositoryModel.save(model);
-    return user;
-  }
-
-  public async update(user: Partial<IUser>): Promise<IUser> {
-    const result = await this.UserRepositoryModel.updateOne(
-      { email: user.email },
-      { ...user }
-    );
+  public async create(user: IUser): Promise<IUser> {
+    const result = await this.UserRepositoryModel.save(user);
 
     if (!result) {
-      throw new Error('');
+      throw new DatabaseError(
+        `Could not save user ${user.email} in database`,
+        httpStatus.BAD_REQUEST
+      );
     }
 
     return result;
   }
 
-  public async findOne(user: Partial<IUser>): Promise<IUser> {
-    const result = await this.UserRepositoryModel.findOne({
-      email: user.email,
-    });
+  public async update(
+    property: Partial<IUser>,
+    user: Partial<IUser>
+  ): Promise<IUser> {
+    const result = await this.UserRepositoryModel.updateOne(property, user);
 
     if (!result) {
-      throw new Error('');
+      throw new DatabaseError(
+        `User ${user.email} not found in database`,
+        httpStatus.BAD_REQUEST
+      );
     }
 
     return result;
   }
+
+  public async findOne(user: Partial<IUser>): Promise<IUser | undefined> {
+    return await this.UserRepositoryModel.findOne(user);
+  }
+
+  public async deleteAll(): Promise<void> {
+    await this.UserRepositoryModel.deleteAll();
+  }
+
+  public async findOneByIdAndToken(
+    userId: string,
+    token: string
+  ): Promise<IUser | undefined> {
+    return this.UserRepositoryModel.findOneByIdAndToken(userId, token);
+  }
 }

src/util/logger/ILogger.ts

@@ -1,5 +1,6 @@
 export interface ILoggerParams {
   msg: string;
+  [key: string]: unknown;
 }
 export interface ILogger {
   info(message: ILoggerParams): void;

src/util/webFramework/framework/WebFramework.ts

@@ -1,7 +1,11 @@
-import { IController } from '../../../interfaces/IController';
-
+import { BaseController } from '../../../abstracts/BaseController';
+import { IHttpRequest } from '../../../interfaces/IHttpRequest';
+import { IHttpResponse } from '../../../interfaces/IHttpResponse';
+export interface IMiddleware {
+  executeMiddleware(httpRequest: IHttpRequest): Promise<IHttpResponse>;
+}
 export interface IWebFramework<T> {
-  addMiddleware(middleware: T): void;
+  addMiddleware(middleware: IMiddleware): void;
 
   startServer(port: number, callback: () => void): void;
 
@@ -11,5 +15,5 @@ export interface IWebFramework<T> {
 
   closeServer(): void;
 
-  execController(controller: IController): T;
+  execController(controller: BaseController): T;
 }