Task 5

config/logger.js

@@ -0,0 +1,19 @@
+import winston from "winston";
+
+const { combine, timestamp, printf } = winston.format;
+
+const myFormat = printf(({ level, message, timestamp }) => {
+    return `${timestamp} ${level}: ${JSON.stringify(message)}`;
+});
+
+export const logger = winston.createLogger({
+    level: 'info',
+    format: combine(
+            timestamp(),
+            myFormat,
+        ),
+    transports: [
+        new winston.transports.File({ filename: 'error.log', level: 'error' }),
+        new winston.transports.File({ filename: 'combined.log' }),
+    ],
+});

controllers/group.js

@@ -1,26 +1,72 @@
+import { logger } from "../config/logger";
 import { groupService } from "../services/group";
 
-export const getGroup = async (req, res) => {
-  const groupData = await groupService.getById(req.params.id);
-  res.status(200).json(groupData);
+export const getGroup = async (req, res, next) => {
+	const METHOD = 'getGroup';
+
+	try {
+		const groupData = await groupService.getById(req.params.id);
+		logger.log('info', JSON.stringify({ method: METHOD, id: req.params.id }));
+		res.status(200).json(groupData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: { id: req.params.id } });
+	}
 };
 
-export const getGroups = async (req, res) => {
-  const groupData = await groupService.getList();
-  res.status(200).json(groupData);
+export const getGroups = async (req, res, next) => {
+	const METHOD = 'getGroups';
+
+	try {
+		const groupData = await groupService.getList();
+		logger.log('info', JSON.stringify({ method: METHOD }));
+		res.status(200).json(groupData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD });
+	}
 };
 
-export const createGroup = async (req, res) => {
-  const groupData = await groupService.create(req.body);
-  res.status(200).json(groupData);
+export const createGroup = async (req, res, next) => {
+	const METHOD = 'createGroup';
+
+	try {
+		const groupData = await groupService.create(req.body);
+		logger.log('info', JSON.stringify({ method: METHOD, params: req.body }));
+		res.status(200).json(groupData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: req.body });
+	}
 };
 
-export const editGroup = async (req, res) => {
-  const groupData = await groupService.edit(req.body);
-  res.status(200).json(groupData);
+export const editGroup = async (req, res, next) => {
+	const METHOD = 'editGroup';
+
+	try {
+		const groupData = await groupService.edit(req.body);
+		logger.log('info', JSON.stringify({ method: METHOD, params: req.body }));
+		res.status(200).json(groupData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: req.body });
+	}
 };
 
-export const deleteGroup = async (req, res) => {
-  await groupService.delete(req.params.id);
-  res.status(200).send();
+export const deleteGroup = async (req, res, next) => {
+	const METHOD = 'deleteGroup';
+
+	try {
+		await groupService.delete(req.params.id);
+		logger.log('info', JSON.stringify({ method: METHOD, id: req.params.id }));
+		res.status(200).send();
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: { id: req.params.id } });
+	}
 };

controllers/user.js

@@ -1,26 +1,73 @@
+import { logger } from "../config/logger";
+import DatabaseError from "../helpers/errors/databaseError";
 import { userService } from "../services/user";
 
-export const getUser = async (req, res) => {
-  const userData = await userService.getById(req.params.id);
-  res.status(200).json(userData);
+export const getUser = async (req, res, next) => {
+	const METHOD = 'getUser';
+
+	try {
+		const userData = await userService.getById(req.params.id);
+		logger.log('info', JSON.stringify({ method: METHOD, id: req.params.id }));
+		res.status(200).json(userData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: { id: req.params.id }});
+	}
 };
 
-export const getUsers = async (req, res) => {
-  const usersData = await userService.getList(req.query.loginSubstring, req.query.limit);
-  res.status(200).json(usersData);
+export const getUsers = async (req, res, next) => {
+	const METHOD = 'getUsers';
+
+	try {
+		const usersData = await userService.getList(req.query.loginSubstring, req.query.limit);
+		logger.log('info', JSON.stringify({ method: METHOD, substring: req.query.loginSubstring, limit: req.query.limit }));
+		res.status(200).json(usersData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: { substring: req.query.loginSubstring, limit: req.query.limit } });
+	}
 };
 
-export const createUser = async (req, res) => {
-  const userData = await userService.create(req.body);
-  res.status(200).json(userData);
+export const createUser = async (req, res, next) => {
+	const METHOD = 'createUser';
+
+	try {
+		const userData = await userService.create(req.body);
+		logger.log('info', JSON.stringify({ method: METHOD, params: req.body }));
+		res.status(200).json(userData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: req.body });
+	}
 };
 
-export const editUser = async (req, res) => {
-  const userData = await userService.edit(req.body);
-  res.status(200).json(userData);
+export const editUser = async (req, res, next) => {
+	const METHOD = 'editUser';
+
+	try {
+		const userData = await userService.edit(req.body);
+		logger.log('info', JSON.stringify({ method: METHOD, params: req.body }));
+		res.status(200).json(userData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: req.body });
+	}
 };
 
-export const deleteUser = async (req, res) => {
-  await userService.delete(req.params.id);
-  res.status(200).send();
+export const deleteUser = async (req, res, next) => {
+	const METHOD = 'deleteUser';
+
+	try {
+		await userService.delete(req.params.id);
+		logger.log('info', JSON.stringify({ method: METHOD, id: req.params.id }));
+		res.status(200).send();
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: { id: req.params.id } });
+	}
 };

controllers/userGroup.js

@@ -1,11 +1,31 @@
+import { logger } from "../config/logger";
+import DatabaseError from "../helpers/errors/databaseError";
 import { userGroupService } from "../services/userGroup"
 
-export const getUserGroups = async (req, res) => {
-  const userGroupsData = await userGroupService.getList();
-  res.status(200).json(userGroupsData);
+export const getUserGroups = async (req, res, next) => {
+	const METHOD = 'getUserGroups';
+
+	try {
+		const userGroupsData = await userGroupService.getList();
+		logger.log('info', JSON.stringify({ method: METHOD }));
+		res.status(200).json(userGroupsData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD });
+	}
 };
 
-export const addUserGroup = async (req, res) => {
-  const userGroupData = await userGroupService.create(req.body);
-  res.status(200).json(userGroupData);
+export const addUserGroup = async (req, res, next) => {
+	const METHOD = 'addUserGroup';
+
+	try {
+		const userGroupData = await userGroupService.create(req.body);
+		logger.log('info', JSON.stringify({ method: METHOD, params: req.body }));
+		res.status(200).json(userGroupData);
+	}
+	catch (error) {
+		const err = new DatabaseError(error.message);
+		next({ error: err, method: METHOD, params: req.body });
+	}
 };

helpers/errors/databaseError.js

@@ -0,0 +1,7 @@
+import ExtendError from './errorExtention';
+
+export default class DatabaseError extends ExtendError {
+    constructor(message) {
+        super(500, message || 'Database Error')
+    }
+}

helpers/errors/errorExtention.js

@@ -0,0 +1,17 @@
+export default class ExtendError extends Error {
+    constructor(status, message) {
+      super(message);
+      this.status = status;
+    }
+
+    getResponse() {
+        return {
+            status: 'Failed',
+            message: this.message
+        };
+    }
+
+    getStatus() {
+        return this.status;
+    }
+}

helpers/errors/errorHandler.js

@@ -0,0 +1,16 @@
+import { logger } from "../../config/logger";
+import DatabaseError from "./databaseError";
+import NotFoundError from "./notFoundError";
+
+const customErrors = [DatabaseError, NotFoundError];
+
+export const customErrorHandler = ({ error, method, params }, res) => {
+    if (customErrors.includes(error.constructor)) {
+        logger.log('error', JSON.stringify({ status: error.status, message: error.message, method: method, params: params }));
+
+        return res.status(error.status).json({ status: error.status, message: error.message });
+    }
+
+    logger.log('error', JSON.stringify({ unhandledError: error.message, method: method, params: params }));
+    throw new Error(error);
+};

helpers/errors/notFoundError.js

@@ -0,0 +1,7 @@
+import ExtendError from './errorExtention';
+
+export default class NotFoundError extends ExtendError {
+    constructor(message) {
+        super(404, message || 'Not Found')
+    }
+}

helpers/initLogger.js

@@ -0,0 +1,24 @@
+import { logger } from "../config/logger";
+
+export const initLogger = app => {
+    app.use((req, res, next) => {
+        const dataMessage = [];
+
+        dataMessage.push(JSON.stringify({ url: req.originalUrl }));
+
+        if (!isObjEmpty(req.params)) {
+            dataMessage.push(JSON.stringify({ params: req.params }));
+        }
+
+        if (!isObjEmpty(req.body)) {
+            dataMessage.push(JSON.stringify({ body: req.body }));
+        }
+
+        logger.log('info', dataMessage.toString());
+        next();
+    });
+
+    const isObjEmpty = obj => {
+        return Object.keys(obj).length === 0 && obj.constructor === Object;
+    }
+}

loaders/index.js

@@ -1,14 +1,13 @@
 import { routerLoader } from "./routerLoader";
-import { sequelize } from "../config/db";
+import { logger } from "../config/logger";
 
 export const loaders = (app) => {
-  sequelize
-  .authenticate()
-  .then(() => {
-      console.log('Connection to database!');
-  })
-  .catch(err => {
-      console.log('Can\'t connect to database!');
+  process.on('uncaughtException', err => {
+    logger.log('error', 'UncaughtException happens... System shut down' + JSON.stringify(err));
+    process.exit(1);
+  });
+  process.on('unhandledRejection', err => {
+    logger.log('error', 'UnhandledRejection happens... Please, stay on your place.' + JSON.stringify(err));
   });
 
   routerLoader(app);

loaders/routerLoader.js

@@ -1,8 +1,24 @@
 import { json } from "express";
 import { API_PREFIX } from "../config";
+import { customErrorHandler } from "../helpers/errors/errorHandler";
+import NotFoundError from "../helpers/errors/notFoundError";
+import { initLogger } from "../helpers/initLogger";
 import { apiRouter } from "../routers/index";
 
 export const routerLoader = (app) => {
     app.use(json());
+
+    initLogger(app);
+
     app.use(API_PREFIX, apiRouter());
+
+    app.use((req, res, next) => {
+        const error = new NotFoundError();
+        next({ error });
+    });
+
+    app.use((error, req, res, next) => {
+        customErrorHandler(error, res);
+        next();
+    });
 };

models/user.js

@@ -1,9 +1,11 @@
 import { User } from "../db-layer/userDB";
 import { Op } from "sequelize";
+import DatabaseError from "../helpers/errors/databaseError";
+import NotFoundError from "../helpers/errors/notFoundError";
 
 export const userModel = {
     getById: (userId) => {
-        return User.findByPk(userId).catch((err) => console.error(err));
+        return User.findByPk(userId);
     },
 
     getList: (loginSubstr, limit) => {