Update base

.env → .env.example

-# Environment variables declared in this file are automatically made available to Prisma.
-# See the documentation for more detail: https://pris.ly/d/prisma-schema#using-environment-variables
-
-# Prisma supports the native connection string format for PostgreSQL, MySQL and SQLite.
-# See the documentation for all the connection string options: https://pris.ly/d/connection-strings
-
-DATABASE_URL="mysql://qldh:qldh@2021!wGqvF9DV4W@localhost:3308/qldh"
\ No newline at end of file
+# Environment variables declared in this file are automatically made available to Prisma.
+# See the documentation for more detail: https://pris.ly/d/prisma-schema#using-environment-variables
+
+# Prisma supports the native connection string format for PostgreSQL, MySQL and SQLite.
+# See the documentation for all the connection string options: https://pris.ly/d/connection-strings
+
+DATABASE_URL="mysql://user:password@host:port/dbname"
\ No newline at end of file

.gitignore

 node_modules/
 dist/
+dist
 *.log
+.env

src/app.ts

-import { AppConfig } from './configurations/app-config';
-import express from 'express';
-import meetingRoom from './routes/meeting-rooms';
-import device from './routes/device';
-
-const app = express();
-
-app.use('/devices', device);
-
-app.use('/meeting-rooms', meetingRoom);
-
-app.listen(AppConfig.PORT, () => console.log(`Server is running on port ${AppConfig.PORT}`));

src/configurations/log4js.config.ts

+import { Request } from 'express';
 import log4js from 'log4js';
 const isProduction = process.env.NODE_ENV === 'production';
 console.log(isProduction);
@@ -18,4 +19,22 @@ log4js.configure({
         },
     },
 });
+
+export const logError = (
+    req: Request,
+    logMsg: string,
+    errorMsg: string,
+    errorStack?: string,
+    isFatal: boolean = false,
+) => {
+    logger[isFatal ? 'fatal' : 'error'](`[${req.requestId}][${logMsg}]: `, errorStack);
+    logger.info(`[${req.requestId}][${logMsg}]: `, errorMsg);
+    logger.info(`[${req.requestId}][${logMsg}][BODY REQ]: `, {
+        body: req.body,
+        params: req.params,
+        query: req.query,
+        headers: req.headers,
+    });
+};
+
 export const logger = log4js.getLogger('log');

src/database/qldh-mysql.ts

-import { AppConfig } from './../configurations/app-config';
-import { createPool } from 'mysql';
-
-export const DB_POOL = createPool({
-    connectionLimit: AppConfig.DB_CONNECTION_AMOUNT,
-    host: AppConfig.DB_HOST,
-    user: AppConfig.DB_USER,
-    password: AppConfig.DB_PASSWORD,
-    database: AppConfig.DB_DATABASE,
-    port: AppConfig.DB_PORT,
-});
-
-export enum DB_Tables {
-    device = 'device',
-    meetingRoom = 'room',
-}

src/enums/common.ts

-export enum queryErrorCode {
-    P2000 = '',
-    P2001 = '',
-    P2002 = '',
-    P2003 = '',
-    P2004 = '',
-    P2005 = '',
-    P2006 = '',
-    P2007 = '',
-    P2008 = '',
-    P2009 = '',
-    P2010 = '',
-    P2011 = '',
-    P2012 = '',
-    P2013 = '',
-    P2014 = '',
-    P2015 = '',
-    P2016 = '',
-    P2017 = '',
-    P2018 = '',
-    P2019 = '',
-    P2020 = '',
-    P2021 = '',
-    P2022 = '',
-    P2023 = '',
-    P2024 = '',
-    P2025 = '',
-}
+export const queryErrorCode: Record<string, string> = {
+    P2000: '',
+    P2001: '',
+    P2002: '',
+    P2003: '',
+    P2004: '',
+    P2005: '',
+    P2006: '',
+    P2007: '',
+    P2008: '',
+    P2009: '',
+    P2010: '',
+    P2011: '',
+    P2012: '',
+    P2013: '',
+    P2014: '',
+    P2015: '',
+    P2016: '',
+    P2017: '',
+    P2018: '',
+    P2019: '',
+    P2020: '',
+    P2021: '',
+    P2022: '',
+    P2023: '',
+    P2024: '',
+    P2025: '',
+    P3000: '',
+    P3001: '',
+    P3002: '',
+    P3003: '',
+    P3004: '',
+    P3005: '',
+    P3006: '',
+    P3007: '',
+    P3008: '',
+    P3009: '',
+    P3010: '',
+    P3011: '',
+    P3012: '',
+    P3013: '',
+    P3014: '',
+    P3015: '',
+    P1000: '',
+    P1001: '',
+    P1002: '',
+    P1003: '',
+    P1004: '',
+    P1005: '',
+    P1006: '',
+    P1007: '',
+    P1008: '',
+    P1009: '',
+    P1010: '',
+    P1011: '',
+    P1012: '',
+    P1013: '',
+    P1014: '',
+    P1015: '',
+    P4000: '',
+    P4001: '',
+    P4002: '',
+};

src/response/response-messages/index.ts → src/enums/response-messages/index.ts

 export enum ResponseMessages {
     UNAUTHORIZED = 'Vui lòng đăng nhập',
     FORBIDDEN = 'Không được phép truy cập',
+    DB_FATAL_ERROR = 'Database fatal error. Contact system administrator asap.',
+    QUERY_ENGINE_START_ERROR = 'Cannot initialize query engine.',
+    QUERY_UNKNOWN_ERROR = 'Unknown query error',
+    QUERY_VALIDATION_ERROR = 'Query validation error',
 }

src/functions/demo-functions/demo-api.ts

-import { DB_POOL } from './../../database/qldh-mysql';
-export const getDemoData = () => {
-    return new Promise<Record<string, unknown>>((resolve, reject) => {
-        DB_POOL.query('SELECT 1 + 1 AS solution', (error, results, fields) => {
-            if (error) {
-                reject({ error });
-            } else {
-                resolve({ results });
-            }
-        });
-    });
-};

src/functions/devices/index.ts

-import { DB_POOL } from '../../database/qldh-mysql';
-import { Device } from '../../models/Device';
-
-export const getListDevice = (pageIndex: number = 1, pageSize: number = 10, keyword: string) => {
-    console.log(pageIndex, pageSize);
-    return new Promise<Array<Device>>((resolve, reject) => {
-        let query = 'select * from device';
-        if (keyword) {
-            query += ` where name like ${DB_POOL.escape(`%${keyword}%`)}`;
-        }
-        query += ` limit ${DB_POOL.escape((pageIndex - 1) * pageSize)}, ${DB_POOL.escape(pageSize)}`;
-        console.log(query);
-        DB_POOL.query(query, (error, results: Array<Device>) => {
-            if (error) {
-                reject(error);
-            } else {
-                resolve(results);
-            }
-        });
-    });
-};

src/functions/jwt-authentication/index.ts

@@ -3,7 +3,7 @@ import { AppConfig } from './../../configurations/app-config';
 import { sign, verify } from 'jsonwebtoken';
 import { NextFunction, Request, Response } from 'express';
 import { errorBody } from '../../response/error-body';
-import { ResponseMessages } from '../../response/response-messages';
+import { ResponseMessages } from '../../enums/response-messages';
 import { account_cms } from '@prisma/client';
 
 export const generateAccessToken = (user: account_cms) => {

src/functions/meeting-rooms/index.ts

-import { DB_POOL, DB_Tables } from '../../database/qldh-mysql';
-import { FilterMeetingRoomOptions, MeetingRoom } from '../../models/MeetingRoom';
-
-export const getMeetingRooms = (pageIndex: number, pageSize: number, Options?: FilterMeetingRoomOptions) => {
-    let query = `select * from ${DB_Tables.meetingRoom}`;
-    query += ` limit ${DB_POOL.escape((pageIndex - 1) * pageSize)}, ${DB_POOL.escape(pageSize)}`;
-
-    console.log(query);
-
-    return new Promise<Array<MeetingRoom>>((resolve, reject) => {
-        DB_POOL.query(query, (error, results: Array<MeetingRoom>, fields) => {
-            if (error) {
-                reject(error);
-            } else {
-                resolve(results);
-            }
-        });
-    });
-};

src/functions/process-request/index.ts

+import { Prisma } from '@prisma/client';
+import { Request, Response, Router } from 'express';
+import { validationResult } from 'express-validator';
+import { ReasonPhrases } from 'http-status-codes';
+import { logError } from '../../configurations/log4js.config';
+import {
+    databaseFatalResponse,
+    internalServerErrorResponse,
+    queryErrorResponse,
+    queryStartErrorResponse,
+    queryUnknownErrorResponse,
+    queryValidationErrorResponse,
+    validationErrorResponse,
+} from '../../response/error-body';
+
+export const processRequest = async (
+    req: Request,
+    res: Response,
+    processorLogic: () => Promise<void | Response<any, Record<string, any>>>,
+) => {
+    try {
+        const validationErrors = validationResult(req);
+        if (validationErrors.isEmpty()) {
+            const processed = await processorLogic();
+            return processed;
+        } else {
+            return validationErrorResponse(req, res, validationErrors);
+        }
+    } catch (error) {
+        return processRequestError(req, res, error);
+    }
+};
+
+export const processRequestError = (req: Request, res: Response, error: any) => {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        return queryErrorResponse(req, res, error);
+    } else if (error instanceof Prisma.PrismaClientRustPanicError) {
+        return databaseFatalResponse(req, res, error);
+    } else if (error instanceof Prisma.PrismaClientInitializationError) {
+        return queryStartErrorResponse(req, res, error);
+    } else if (error instanceof Prisma.PrismaClientUnknownRequestError) {
+        return queryUnknownErrorResponse(req, res, error);
+    } else if (error instanceof Prisma.PrismaClientValidationError) {
+        return queryValidationErrorResponse(req, res, error);
+    } else {
+        logError(req, ReasonPhrases.INTERNAL_SERVER_ERROR, ReasonPhrases.INTERNAL_SERVER_ERROR, error.stack, true);
+        return internalServerErrorResponse(req, res, ReasonPhrases.INTERNAL_SERVER_ERROR);
+    }
+};

src/models/Device.ts

-export type Device = {
-    id: number;
-    code?: string;
-    name: string;
-    model?: string;
-    image?: string;
-    status?: number;
-    create_time?: Date;
-    create_by?: string;
-    update_time?: Date;
-    update_by?: string;
-};

src/models/MeetingRoom.ts

-import { Device } from './Device';
-
-export type FilterMeetingRoomOptions = {
-    status?: number;
-    name?: string;
-    capacity?: number;
-    devices?: Array<Device>;
-};
-
-export type MeetingRoom = {
-    id: number;
-    code?: string;
-    name: string;
-    description?: string;
-    capacity: number;
-    floor: number;
-    building: number;
-    status?: number;
-};

src/response/error-body/index.ts

@@ -2,8 +2,9 @@ import { Prisma } from '@prisma/client';
 import { Request, Response } from 'express';
 import { Result, ValidationError } from 'express-validator';
 import { ReasonPhrases, StatusCodes } from 'http-status-codes';
-import { logger } from '../../configurations/log4js.config';
-import { ValidatorMessage } from '../../validators/validator-config';
+import { logError, logger } from '../../configurations/log4js.config';
+import { queryErrorCode } from '../../enums/common';
+import { ResponseMessages } from '../../enums/response-messages';
 
 export const errorBody = (data: unknown, code: number, requestId: string, message?: string) => {
     return {
@@ -16,17 +17,48 @@ export const errorBody = (data: unknown, code: number, requestId: string, messag
     };
 };
 
+export const internalServerErrorResponse = (req: Request, res: Response, data: unknown) => {
+    return res
+        .status(StatusCodes.INTERNAL_SERVER_ERROR)
+        .send(errorBody(data, StatusCodes.INTERNAL_SERVER_ERROR, req.requestId, ReasonPhrases.INTERNAL_SERVER_ERROR));
+};
+
 export const queryErrorResponse = (req: Request, res: Response, error: Prisma.PrismaClientKnownRequestError) => {
-    logger.error(`[${req.requestId}][QUERY ERROR ${error.code}]: `, error.stack);
-    logger.info(`[${req.requestId}][QUERY ERROR ${error.code}]: `, error.message);
-    res.status(StatusCodes.INTERNAL_SERVER_ERROR).send(
-        errorBody(error.message, StatusCodes.INTERNAL_SERVER_ERROR, req.requestId, ReasonPhrases.INTERNAL_SERVER_ERROR),
-    );
+    logError(req, `QUERY ERROR ${error.code}`, error.message, error.stack);
+    return internalServerErrorResponse(req, res, queryErrorCode[error.code]);
 };
 
 export const validationErrorResponse = (req: Request, res: Response, errors: Result<ValidationError>) => {
     const errorArray = errors.array();
-    res.status(StatusCodes.UNPROCESSABLE_ENTITY).send(
-        errorBody(errorArray, StatusCodes.UNPROCESSABLE_ENTITY, errorArray[0].msg),
-    );
+    return res
+        .status(StatusCodes.UNPROCESSABLE_ENTITY)
+        .send(errorBody(errorArray, StatusCodes.UNPROCESSABLE_ENTITY, errorArray[0].msg));
+};
+
+export const databaseFatalResponse = (req: Request, res: Response, error: Prisma.PrismaClientRustPanicError) => {
+    logError(req, 'DATABASE FATAL ERROR', error.message, error.stack, true);
+    return internalServerErrorResponse(req, res, ResponseMessages.DB_FATAL_ERROR);
+};
+
+export const queryStartErrorResponse = (req: Request, res: Response, error: Prisma.PrismaClientInitializationError) => {
+    logError(req, 'QUERY ENGINE START ERROR', error.message, error.stack);
+    return internalServerErrorResponse(req, res, ResponseMessages.QUERY_ENGINE_START_ERROR);
+};
+
+export const queryUnknownErrorResponse = (
+    req: Request,
+    res: Response,
+    error: Prisma.PrismaClientUnknownRequestError,
+) => {
+    logError(req, 'QUERY UNKNOWN ERROR', error.message, error.stack);
+    return internalServerErrorResponse(req, res, ResponseMessages.QUERY_UNKNOWN_ERROR);
+};
+
+export const queryValidationErrorResponse = (
+    req: Request,
+    res: Response,
+    error: Prisma.PrismaClientValidationError,
+) => {
+    logError(req, 'QUERY VALIDATION ERROR', error.message, error.stack);
+    return internalServerErrorResponse(req, res, ResponseMessages.QUERY_VALIDATION_ERROR);
 };

src/routes/demo-api.ts

-import { Router } from 'express';
-import { StatusCodes, ReasonPhrases } from 'http-status-codes';
-import { getDemoData } from '../functions/demo-functions/demo-api';
-
-const router = Router();
-
-router.get('/', async (req, res) => {
-    try {
-        const data = await getDemoData();
-        res.status(StatusCodes.OK).send(data);
-    } catch (error) {
-        res.status(StatusCodes.INTERNAL_SERVER_ERROR).send({ error });
-    }
-});
-
-export default router;

src/routes/device/index.ts

-import { Request, Response, Router } from 'express';
-import { validationResult } from 'express-validator';
-import { StatusCodes, ReasonPhrases } from 'http-status-codes';
-import { getListDevice } from '../../functions/devices';
-import { deviceListValidator } from '../../validators/devices';
-
-const route = Router();
-
-route.get('/', deviceListValidator, async (req: Request, res: Response) => {
-    try {
-        const errors = validationResult(req);
-        if (errors.isEmpty()) {
-            const devices = await getListDevice(
-                Number(req.query.pageIndex),
-                Number(req.query.pageSize),
-                req.query.keyword as string,
-            );
-            res.status(StatusCodes.OK).send(devices);
-        } else {
-            res.status(StatusCodes.UNPROCESSABLE_ENTITY).send({
-                errors: errors.array(),
-                message: ReasonPhrases.UNPROCESSABLE_ENTITY,
-            });
-        }
-    } catch (error) {
-        res.status(StatusCodes.INTERNAL_SERVER_ERROR).send(error);
-    }
-});
-
-export default route;

src/routes/login/index.ts

-import { account_cms, Prisma } from '@prisma/client';
+import { account_cms } from '@prisma/client';
 import { MD5 } from 'crypto-js';
 import { Request, Response, Router } from 'express';
-import { validationResult } from 'express-validator';
 import { StatusCodes } from 'http-status-codes';
 import { prisma } from '../..';
 import { logger } from '../../configurations/log4js.config';
 import { generateAccessToken } from '../../functions/jwt-authentication';
-import { errorBody, queryErrorResponse, validationErrorResponse } from '../../response/error-body';
+import { processRequest } from '../../functions/process-request';
+import { errorBody } from '../../response/error-body';
 import { successResponse } from '../../response/success-body';
 import { loginValidator } from '../../validators/login';
 import { ValidatorMessage } from '../../validators/validator-config';
@@ -14,51 +14,45 @@ import { ValidatorMessage } from '../../validators/validator-config';
 const loginRouter = Router();
 
 loginRouter.post('/', loginValidator, async (req: Request, res: Response) => {
-    try {
-        const validationErrors = validationResult(req);
-        if (validationErrors.isEmpty()) {
-            const reqBody = req.body as account_cms;
-            const user = await prisma.account_cms.findFirst({
-                where: {
-                    user_name: {
-                        equals: reqBody.user_name,
-                    },
-                    password: {
-                        equals: MD5(reqBody.password || '').toString(),
-                    },
+    const processorLogic = async () => {
+        const reqBody = req.body as account_cms;
+
+        const user = await prisma.account_cms.findFirst({
+            where: {
+                user_name: {
+                    equals: reqBody.user_name,
+                },
+                password: {
+                    equals: MD5(reqBody.password || '').toString(),
                 },
-            });
+            },
+        });
 
-            if (user) {
-                const jwtToken = generateAccessToken(user);
-                const data = {
-                    id: user.id,
-                    user_name: user.user_name,
-                    email: user.email,
-                    accessToken: jwtToken,
-                };
-                return successResponse(req, res, data);
-            } else {
-                logger.warn(`[${req.requestId}]: `, req.body);
-                return res
-                    .status(StatusCodes.UNPROCESSABLE_ENTITY)
-                    .send(
-                        errorBody(
-                            ValidatorMessage.WRONG_USERNAME_OR_PASSWORD,
-                            StatusCodes.UNPROCESSABLE_ENTITY,
-                            req.requestId,
-                            ValidatorMessage.WRONG_USERNAME_OR_PASSWORD,
-                        ),
-                    );
-            }
+        if (user) {
+            const jwtToken = generateAccessToken(user);
+            const data = {
+                id: user.id,
+                user_name: user.user_name,
+                email: user.email,
+                accessToken: jwtToken,
+            };
+            return successResponse(req, res, data);
         } else {
-            return validationErrorResponse(req, res, validationErrors);
+            logger.warn(`[${req.requestId}][LOGIN FAILED]: `, req.body);
+            return res
+                .status(StatusCodes.UNPROCESSABLE_ENTITY)
+                .send(
+                    errorBody(
+                        ValidatorMessage.WRONG_USERNAME_OR_PASSWORD,
+                        StatusCodes.UNPROCESSABLE_ENTITY,
+                        req.requestId,
+                        ValidatorMessage.WRONG_USERNAME_OR_PASSWORD,
+                    ),
+                );
         }
-    } catch (error) {
-        if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            return queryErrorResponse(req, res, error);
-        }
-    }
+    };
+
+    return processRequest(req, res, processorLogic);
 });
 
 export { loginRouter };

src/routes/meeting-rooms/index.ts

-import { Router } from 'express';
-import { ReasonPhrases, StatusCodes } from 'http-status-codes';
-import { getMeetingRooms } from '../../functions/meeting-rooms';
-
-const router = Router();
-
-router.get('/', async (req, res) => {
-    try {
-        const results = await getMeetingRooms(1, 10);
-
-        res.status(StatusCodes.OK).send(results);
-    } catch (error) {
-        res.status(StatusCodes.INTERNAL_SERVER_ERROR).send({
-            error,
-            message: ReasonPhrases.INTERNAL_SERVER_ERROR,
-        });
-    }
-});
-
-export default router;

src/validators/devices/index.ts

-import { check } from 'express-validator';
-
-export const deviceListValidator = [
-    check('pageIndex', 'Please provide pageIndex').isNumeric(),
-    check('pageSize', 'Please provide pageSize').isNumeric(),
-    check('keyword', 'Please provide keyword').optional().isString(),
-];