feat: add authentication system

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "typescript.preferences.importModuleSpecifier": "non-relative",
+  "typescript.preferences.quoteStyle": "single",
+}

package.json

@@ -3,7 +3,8 @@
   "private": true,
   "workspaces": ["packages/*"],
   "scripts": {
-    "dev": "lerna run dev --stream"
+    "dev": "lerna run dev --stream",
+    "test": "lerna run test --stream"
   },
   "devDependencies": {
     "lerna": "3.22.1"

packages/backend/.env.example

@@ -0,0 +1,10 @@
+MYSQL_HOST=
+MYSQL_PORT=
+MYSQL_USER=
+MYSQL_PASSWORD=
+MYSQL_DATABASE=
+
+REDIS_HOST=
+REDIS_PORT=
+REDIS_USER=
+REDIS_PASSWORD=

packages/backend/declarations/express.d.ts

@@ -0,0 +1,8 @@
+declare namespace Express {
+  export interface Request {
+    session?: {
+      sessionId: string,
+      staffId: number,
+    }
+  }
+}

packages/backend/package.json

@@ -9,21 +9,26 @@
     "build": "yarn run build:prod",
     "dev": "npm-run-all --silent --parallel build:dev start:dev",
     "lint": "eslint . --ext .ts",
-    "start:dev": "nodemon dist/app.js -q -w dist -e js",
-    "start:prod": "node dist/app.js",
+    "start:dev": "nodemon -r dotenv/config dist/app.js -q -w dist -e js",
+    "start:prod": "node -r dotenv/config dist/app.js",
     "start": "yarn run start:prod",
     "test": "jest --silent"
   },
   "dependencies": {
+    "bcrypt": "^5.0.1",
     "express": "^4.17.3",
+    "mysql2": "^2.3.3",
+    "redis": "^4.0.6",
     "reflect-metadata": "^0.1.13"
   },
   "devDependencies": {
+    "@types/bcrypt": "^5.0.0",
     "@types/express": "^4.17.13",
     "@types/jest": "^27.4.1",
     "@types/supertest": "^2.0.12",
     "@typescript-eslint/eslint-plugin": "^5.12.1",
     "@typescript-eslint/parser": "^5.12.1",
+    "dotenv": "^16.0.0",
     "eslint": "^8.9.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-airbnb-typescript": "^16.1.0",

packages/backend/src/App.ts

@@ -4,7 +4,7 @@ try {
   console.log('Starting up the application...');
   const server = new Server(4000);
   server.run();
-} catch (error: Error | unknown) {
+} catch (error: unknown) {
   if (error instanceof Error) {
     console.log(`${error.name}: ${error.message}`);
     console.log('Closing the application...');

packages/backend/src/Server.ts

@@ -3,28 +3,73 @@ import http from 'http';
 import express, { Application } from 'express';
 import { IndexController } from '@/controllers/IndexController';
 import { ControllerRegistry } from '@/controllers/ControllerRegistry';
+import { DatabaseConnector } from '@/utils/database/DatabaseConnector';
+import { DatabaseException } from '@/exceptions/DatabaseException';
+import { CookieProvider } from '@/utils/cookie/CookieProvider';
+import { AuthController } from '@/controllers/AuthController';
+import { AuthService } from '@/services/AuthService';
+import { AddressRepository } from '@/repositories/address/AddressRepository';
+import { BillRepository } from '@/repositories/bill/BillRepository';
+import { BranchRepository } from '@/repositories/branch/BranchRepository';
+import { MachineRepository } from '@/repositories/machine/MachineRepository';
+import { MachinePartRepository } from '@/repositories/machinePart/MachinePartRepository';
+import { MaintenanceLogRepository } from '@/repositories/maintenancelog/MaintenanceLogRepository';
+import { MaintenancePartRepository } from '@/repositories/maintenancepart/MaintenancePartRepository';
+import { OrderRepository } from '@/repositories/order/OrderRepository';
+import { StaffRepository } from '@/repositories/staff/StaffRepository';
+import { ZoneRepository } from '@/repositories/zone/ZoneRepository';
+import { DefaultAddressRepository } from '@/repositories/address/DefaultAddressRepository';
+import { DefaultBillRepository } from '@/repositories/bill/DefaultBillRepository';
+import { DefaultBranchRepository } from '@/repositories/branch/DefaultBranchRepository';
+import { DefaultMachineRepository } from '@/repositories/machine/DefaultMachineRepository';
+import { DefaultMachinePartRepository } from '@/repositories/machinePart/DefaultMachinePartRepository';
+import { DefaultMaintenanceLogRepository } from '@/repositories/maintenancelog/DefaultMaintenanceLogRepository';
+import { DefaultMaintenancePartRepository } from '@/repositories/maintenancepart/DefaultMaintenancePartRepository';
+import { DefaultOrderRepository } from '@/repositories/order/DefaultOrderRepository';
+import { DefaultStaffRepository } from '@/repositories/staff/DefaultStaffRepository';
+import { DefaultZoneRepository } from '@/repositories/zone/DefaultZoneRepository';
+import { SessionRepository } from '@/repositories/session/SessionRepository';
+import { DefaultSessionRepository } from '@/repositories/session/DefaultSessionRepository';
+import { StaffController } from '@/controllers/StaffController';
 
 export class Server {
 
   private readonly app: Application;
   private readonly port: number;
-  private readonly controllerRegistry: ControllerRegistry;
+
+  private databaseConnector: DatabaseConnector;
+  private controllerRegistry: ControllerRegistry;
+  private cookieProvider: CookieProvider;
+
+  private addressRepository: AddressRepository;
+  private billRepository: BillRepository;
+  private branchRepository: BranchRepository;
+  private machineRepository: MachineRepository;
+  private machinePartRepository: MachinePartRepository;
+  private maintenanceLogRepository: MaintenanceLogRepository;
+  private maintenancePartRepository: MaintenancePartRepository;
+  private orderRepository: OrderRepository;
+  private sessionRepository: SessionRepository;
+  private staffRepository: StaffRepository;
+  private zoneRepository: ZoneRepository;
+
+  private authService: AuthService;
 
   public constructor(port: number) {
     this.app = express();
     this.port = port;
-    this.controllerRegistry = new ControllerRegistry(this.app);
+    this.databaseConnector = new DatabaseConnector();
   }
 
-  public run(): http.Server {
-    this.controllerRegistry.loadControllers([
-      new IndexController(),
-    ]);
-
+  public async run(): Promise<http.Server> {
+    this.app.use(express.urlencoded({ extended: true }));
+    this.app.use(express.json());
     this.app.disable('x-powered-by');
 
-    const controllerCount = this.controllerRegistry.size();
-    console.log(`Registered ${controllerCount} controller${controllerCount > 1 ? 's' : ''}`);
+    await this.connectDatabase();
+    await this.registerRepository();
+    await this.registerServices();
+    await this.loadControllers();
 
     return this.app.listen(this.port, this.onStartup.bind(this));
   }
@@ -33,4 +78,56 @@ export class Server {
     console.log(`Listening on http://localhost:${this.port}/`);
   }
 
+  private async registerRepository(): Promise<void> {
+    const defaultDb = await this.databaseConnector.getDefaultDatabase();
+    const cachingDb = await this.databaseConnector.getCachingDatabase();
+
+    this.addressRepository = new DefaultAddressRepository(defaultDb, cachingDb);
+    this.billRepository = new DefaultBillRepository(defaultDb, cachingDb);
+    this.branchRepository = new DefaultBranchRepository(defaultDb, cachingDb);
+    this.machineRepository = new DefaultMachineRepository(defaultDb, cachingDb);
+    this.machinePartRepository = new DefaultMachinePartRepository(defaultDb, cachingDb);
+    this.maintenanceLogRepository = new DefaultMaintenanceLogRepository(defaultDb, cachingDb);
+    this.maintenancePartRepository = new DefaultMaintenancePartRepository(defaultDb, cachingDb);
+    this.orderRepository = new DefaultOrderRepository(defaultDb, cachingDb);
+    this.sessionRepository = new DefaultSessionRepository(defaultDb, cachingDb);
+    this.staffRepository = new DefaultStaffRepository(defaultDb, cachingDb);
+    this.zoneRepository = new DefaultZoneRepository(defaultDb, cachingDb);
+  }
+
+  private async registerServices(): Promise<void> {
+    this.authService = new AuthService(this.staffRepository, this.sessionRepository);
+  }
+
+  private async loadControllers(): Promise<void> {
+    this.cookieProvider = new CookieProvider('this-is-the-secret-just-keep-it');
+
+    this.controllerRegistry = new ControllerRegistry(
+      this.app,
+      this.cookieProvider,
+      this.sessionRepository,
+      this.staffRepository,
+    );
+
+    this.controllerRegistry.loadControllers([
+      new IndexController(),
+      new AuthController(this.cookieProvider, this.authService),
+      new StaffController(this.staffRepository),
+    ]);
+
+    const controllerCount = this.controllerRegistry.size();
+    console.log(`Registered ${controllerCount} controller${controllerCount > 1 ? 's' : ''}`);
+  }
+
+  private async connectDatabase(): Promise<void> {
+    try {
+      await this.databaseConnector.connect();
+    } catch (error: unknown) {
+      if (error instanceof DatabaseException) {
+        console.log(error.message);
+      }
+      process.exit(1);
+    }
+  }
+
 }

packages/backend/src/controllers/AuthController.ts

@@ -0,0 +1,49 @@
+import { Controller } from '@/controllers/Controller';
+import { Methods } from '@/controllers/Route';
+import { ControllerMapping } from '@/decorators/ControllerDecorator';
+import { RouteMapping } from '@/decorators/RouteDecorator';
+import { CookieProvider } from '@/utils/cookie/CookieProvider';
+import { Request, Response } from 'express';
+import { RequestBody } from '@/decorators/RequestDecorator';
+import { AuthService } from '@/services/AuthService';
+
+@ControllerMapping('/auth')
+export class AuthController extends Controller {
+
+  private readonly cookieProvider: CookieProvider;
+  private readonly authService: AuthService;
+
+  public constructor(cookieProvider: CookieProvider, authService: AuthService) {
+    super();
+    this.cookieProvider = cookieProvider;
+    this.authService = authService;
+  }
+
+  @RouteMapping('/login', Methods.POST)
+  @RequestBody('username', 'password')
+  private async loginRoute(req: Request, res: Response): Promise<void> {
+    const { username, password } = req.body;
+
+    const cookie = await this.authService.login(username, password);
+
+    if (cookie) {
+      this.cookieProvider.setSignedCookie(res, cookie);
+
+      res.status(200).json({
+        message: 'Logged in successfully',
+      });
+    }
+  }
+
+  @RouteMapping('/logout', Methods.GET)
+  private async logoutRoute(req: Request, res: Response): Promise<void> {
+    const sessionId = this.cookieProvider.getSignedCookie(req, 'sid');
+
+    await this.authService.logout(sessionId);
+
+    res.status(200).json({
+      message: 'Logged out successfully',
+    });
+  }
+
+}

packages/backend/src/controllers/Controller.ts

@@ -1,15 +1,11 @@
-import { RouteHandler } from '@/controllers/Route';
-import { RouteMetadata } from '@/decorators/RouteDecorator';
-import { ErrorHandler } from '@/exceptions/ErrorHandler';
-import { Router } from 'express';
+import { Route } from '@/controllers/Route';
 
 export class Controller {
 
   /**
    * Injected with {@link ControllerDecorator} on class declaration
    */
   private readonly path: string;
-  private readonly router: Router = Router();
   private readonly hasAvailable: boolean;
 
   /**
@@ -28,19 +24,21 @@ export class Controller {
   }
 
   /**
-   * Returns the modular express router of the controller instance
-   * @returns The express {@link Router} instance
+   * Returns the router structure with handler and metadata of the controller
+   * for converting to the modular express router
+   * @returns The router structure (array of {@link Route})
    */
-  public getRouter(): Router {
+  public getRouter(): Route[] {
     const routes = Reflect.getMetadataKeys(this);
 
-    routes.forEach((route) => {
-      const routeHandler: RouteHandler = ErrorHandler.wrap(this[route]);
-      const routeProperty: RouteMetadata = Reflect.getMetadata(route, this);
-      this.router[routeProperty.method.toLowerCase()](routeProperty.path, routeHandler);
+    const router: Route[] = routes.map((route) => {
+      return {
+        handler: this[route].bind(this),
+        metadata: Reflect.getMetadata(route, this),
+      };
     });
 
-    return this.router;
+    return router;
   }
 
 }