@just-tracking/shared 1.0.2 → 1.0.3

package/.eslintrc.json

@@ -0,0 +1,20 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true,
+        "node": true
+    },
+    "extends": ["eslint:recommended", "prettier"],
+    "overrides": [],
+    "parserOptions": {
+        "ecmaVersion": 2020,
+        "sourceType": "module"
+    },
+    "plugins": ["prettier", "import"],
+    "rules": {
+        "prettier/prettier": "error",
+        "camelcase": "error",
+        "no-multiple-empty-lines": ["error", { "max": 4, "maxEOF": 1 }],
+        "object-shorthand": ["error"]
+    }
+}

package/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-tracking/shared",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "index.js",
   "author": "Sargis Yeritsyan <sargis021996@gmail.com>",
   "license": "MIT",
@@ -21,5 +21,14 @@
     "winston": "^3.11.0",
     "winston-daily-rotate-file": "^5.0.0"
   },
-  "devDependencies": {}
+  "devDependencies": {
+    "@babel/eslint-parser": "7.19.1",
+    "babel-eslint": "10.1.0",
+    "eslint": "8.27.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "nodemon": "3.1.9",
+    "prettier": "2.7.1"
+  }
 }

package/src/errors/errors.js

@@ -1,135 +1,212 @@
 const logger = require('../logger/logger');
 const Slack = require('@slack/bolt');
 
-const SLACK_ENABLED =process?.env?.SLACK_ENABLED === 'true'
-const SLACK_SIGNING_SECRET = process?.env?.SLACK_SIGNING_SECRET
-const SLACK_BOT_TOKEN = process?.env?.SLACK_BOT_TOKEN
-const SLACK_CHANNEL = process?.env?.SLACK_CHANNEL
-
-let app
-
-if(SLACK_SIGNING_SECRET && SLACK_BOT_TOKEN && SLACK_ENABLED) {
-    app = new Slack.App({
-        signingSecret: process.env.SLACK_SIGNING_SECRET,
-        token: process.env.SLACK_BOT_TOKEN,
-    });
+const SLACK_ENABLED = process?.env?.SLACK_ENABLED === 'true';
+const SLACK_SIGNING_SECRET = process?.env?.SLACK_SIGNING_SECRET;
+const SLACK_BOT_TOKEN = process?.env?.SLACK_BOT_TOKEN;
+const SLACK_CHANNEL = process?.env?.SLACK_CHANNEL;
+const NODE_ENV = process?.env?.NODE_ENV || 'development';
+
+let app;
+
+if (SLACK_SIGNING_SECRET && SLACK_BOT_TOKEN && SLACK_ENABLED) {
+  app = new Slack.App({
+    signingSecret: SLACK_SIGNING_SECRET,
+    token: SLACK_BOT_TOKEN,
+  });
 }
 
 const ERRORS = {
-    AUTHENTICATION: {
-        label: 'AUTHENTICATION',
-        status: 401
-    },
-    UNAUTHORIZED: {
-        label: 'UNAUTHORIZED',
-        status: 403
-    },
-    VALIDATION: {
-        label: 'VALIDATION',
-        status: 400
-    }
-}
+  AUTHENTICATION: {
+    label: 'AUTHENTICATION',
+    status: 401,
+  },
+  UNAUTHORIZED: {
+    label: 'UNAUTHORIZED',
+    status: 403,
+  },
+  VALIDATION: {
+    label: 'VALIDATION',
+    status: 400,
+  },
+};
 
 class CustomError extends Error {
-    data;
-    type;
-    status;
-
-    constructor(message, data = {}, type = 'GENERAL', status) {
-        super(message);
-        this.data = data;
-        this.status = status;
-        this.type = type;
-    }
+  constructor(message, data = {}, type = 'GENERAL', status) {
+    super(message);
+    this.name = this.constructor.name;
+    this.data = data;
+    this.status = status;
+    this.type = type;
+    Error.captureStackTrace(this, this.constructor);
+  }
 }
 
 class AuthenticationError extends CustomError {
-    constructor(message, status, data = {}) {
-        super(message, data, ERRORS['AUTHENTICATION'].label, ERRORS['AUTHENTICATION'].status);
-    }
+  constructor(message, data = {}) {
+    super(
+      message,
+      data,
+      ERRORS['AUTHENTICATION'].label,
+      ERRORS['AUTHENTICATION'].status
+    );
+  }
 }
 
 class ValidationError extends CustomError {
-    constructor(message, data = {}) {
-        super(message, data, ERRORS['VALIDATION'].label, ERRORS['VALIDATION'].status);
-    }
+  constructor(message, data = {}) {
+    super(
+      message,
+      data,
+      ERRORS['VALIDATION'].label,
+      ERRORS['VALIDATION'].status
+    );
+  }
 }
 
 class UnauthorizedError extends CustomError {
-    constructor(message, data = {}) {
-        super(message, data, ERRORS['UNAUTHORIZED'].label, ERRORS['UNAUTHORIZED'].status);
+  constructor(message, data = {}) {
+    super(
+      message,
+      data,
+      ERRORS['UNAUTHORIZED'].label,
+      ERRORS['UNAUTHORIZED'].status
+    );
+  }
+}
+
+// Helper to sanitize sensitive data
+function sanitizeData(data) {
+  if (!data || typeof data !== 'object') return data;
+
+  const sensitive = [
+    'password',
+    'token',
+    'apiKey',
+    'secret',
+    'authorization',
+    'cookie',
+  ];
+  const sanitized = Array.isArray(data) ? [...data] : { ...data };
+
+  for (const key in sanitized) {
+    if (sensitive.some((s) => key.toLowerCase().includes(s))) {
+      sanitized[key] = '[REDACTED]';
+    } else if (typeof sanitized[key] === 'object' && sanitized[key] !== null) {
+      sanitized[key] = sanitizeData(sanitized[key]);
     }
+  }
+
+  return sanitized;
+}
+
+// Helper to send Slack notification with retry logic
+async function sendSlackNotification(errorBody) {
+  if (!app || !SLACK_ENABLED) return;
+
+  try {
+    const message = `
+*🚨 Production Error Report*
+*Status:* ${errorBody.status}
+*Method:* ${errorBody.method}
+*URL:* ${errorBody.url}
+*Message:* ${errorBody.message}
+*Stack Trace:*
+\`\`\`
+${errorBody.stack?.substring(0, 2000) || 'No stack trace available'}
+\`\`\`
+    `.trim();
+
+    await app.client.chat.postMessage({
+      token: SLACK_BOT_TOKEN,
+      channel: SLACK_CHANNEL,
+      text: message,
+    });
+  } catch (slackError) {
+    // Log Slack notification failure but don't throw
+    logger.error('Failed to send Slack notification', {
+      error: slackError.message,
+      originalError: errorBody.message,
+    });
+  }
 }
 
 async function errorHandler(err, req, res, next) {
-    console.log('err', err)
-    const status = err.status || 500;
-    const { status: errStatus, ...errData } = typeof err === 'object' ? err : {};
-
-    const errorBody = {
-        status,
-        method: req.method,
-        url: req.url,
-        headers: req.headers,
-        body: req.body,
-        stack: err instanceof Error ? err.stack : undefined,
-    };
-    console.log('errorBody', errorBody)
-
-    if(status !== 401 && status !== 403) {
-        logger.error(err?.message || err?.data?.error, { ...errorBody, err });
-    }
-    console.log('status', status)
-
-    if(app && SLACK_ENABLED && status === 500) {
-        const message = `
-            *Error Report*
-            *Status:* ${errorBody.status}
-            *Method:* ${errorBody.method}
-            *URL:* ${errorBody.url}
-            *Headers:* ${JSON.stringify(errorBody.headers)}
-            *Body:* ${JSON.stringify(errorBody.body)}
-            *Stack Trace:* ${errorBody.stack}
-        `;
-
-        await app.client.chat.postMessage({
-            token: SLACK_BOT_TOKEN,
-            channel: SLACK_CHANNEL,
-            text: message,
-        });
-    }
-    
-    if (err.name === 'ValidationError') {
-        console.log("ValidationError err", err);
-        if (err.details && err.details.length) {
-
-            const errors = {};
-
-            err.details.forEach((item) => {
-                errors[item.context.key] = item.message
-            })
-
-            return res.status(ERRORS['VALIDATION'].status).json({
-                success: false,
-                status: ERRORS['VALIDATION'].status,
-                error: ERRORS['VALIDATION'].label,
-                data: errors
-            })
-        }
-    }
+  const status = err.status || 500;
+  const isProduction = NODE_ENV === 'production';
+
+  // Build error body with sanitized data
+  const errorBody = {
+    status,
+    message: err.message || 'Internal server error',
+    method: req.method,
+    url: req.url,
+    timestamp: new Date().toISOString(),
+    ...(isProduction
+      ? {}
+      : {
+          headers: sanitizeData(req.headers),
+          body: sanitizeData(req.body),
+          stack: err.stack,
+        }),
+  };
+
+  // Log appropriately based on status
+  if (status >= 500) {
+    logger.error(errorBody.message, {
+      ...errorBody,
+      errorType: err.type,
+      errorData: err.data,
+    });
 
-    return res.status(status).json({
-        success: false,
-        status: status,
-        error: err.message,
-        data: err.data,
-        type: err.type
+    // Send Slack notification for 500 errors only
+    if (isProduction && status === 500) {
+      // Don't await - fire and forget to not block response
+      sendSlackNotification({
+        ...errorBody,
+        stack: err.stack,
+      }).catch(() => {}); // Silently fail if Slack notification fails
+    }
+  } else if (status >= 400 && status < 500) {
+    logger.warn(errorBody.message, {
+      ...errorBody,
+      errorType: err.type,
+    });
+  }
+
+  // Handle Joi/validation errors
+  if (err.name === 'ValidationError' && err.details?.length) {
+    const errors = err.details.reduce((acc, item) => {
+      acc[item.context.key] = item.message;
+      return acc;
+    }, {});
+
+    return res.status(ERRORS['VALIDATION'].status).json({
+      success: false,
+      status: ERRORS['VALIDATION'].status,
+      error: ERRORS['VALIDATION'].label,
+      data: errors,
     });
+  }
+
+  // Build response based on environment
+  const response = {
+    success: false,
+    status,
+    error:
+      isProduction && status === 500 ? 'Internal server error' : err.message,
+    ...(err.type && { type: err.type }),
+    ...(err.data && Object.keys(err.data).length > 0 && { data: err.data }),
+    ...(!isProduction && err.stack && { stack: err.stack }),
+  };
+
+  return res.status(status).json(response);
 }
 
 module.exports = {
-    AuthenticationError,
-    UnauthorizedError,
-    ValidationError,
-    errorHandler
-}
+  AuthenticationError,
+  UnauthorizedError,
+  ValidationError,
+  CustomError,
+  errorHandler,
+};

package/src/logger/logger.js

@@ -7,21 +7,26 @@ const DailyRotateFile = require('winston-daily-rotate-file');
 const logDirectory = path.resolve(__dirname, '../../../../logs');
 
 if (!fs.existsSync(logDirectory)) {
-    fs.mkdirSync(logDirectory);
+  fs.mkdirSync(logDirectory);
 }
 
 const logger = winston.createLogger({
-    level: 'debug',
-    format: combine(errors({ stack: true }), timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), json(), prettyPrint()),
-    transports: [
-        new winston.transports.Console(),
-        new DailyRotateFile({
-            level: 'error',
-            filename: path.join(logDirectory, 'app-%DATE%.log'),
-            datePattern: 'YYYY-MM-DD',
-            zippedArchive: true
-        }),
-    ],
+  level: 'debug',
+  format: combine(
+    errors({ stack: true }),
+    timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    json(),
+    prettyPrint()
+  ),
+  transports: [
+    new winston.transports.Console(),
+    new DailyRotateFile({
+      level: 'error',
+      filename: path.join(logDirectory, 'app-%DATE%.log'),
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+    }),
+  ],
 });
 
-module.exports = logger;
+module.exports = logger;

package/src/middlewares/auth.middleware.js

@@ -1,57 +1,71 @@
 const axios = require('axios');
 const { UnauthorizedError, AuthenticationError } = require('../errors/errors');
+const NODE_ENV = process.env.NODE_ENV;
 
 function formatCookies(cookies) {
-    return Object.keys(cookies)
-        .map((key) => `${key}=${cookies[key]}`)
-        .join(';');
+  return Object.keys(cookies)
+    .map((key) => `${key}=${cookies[key]}`)
+    .join(';');
 }
 
 async function auth(req, res, next) {
-    try {
-        const { data } = await axios.get(
-            `${process.env.AUTH_MICROSERVICE_URL}/user`,
-            {
-                headers: {
-                    Authorization: req.headers?.authorization ? req.headers['authorization'] : '',
-                    Cookie: formatCookies(req?.cookies ? req.cookies : {})
-                },
-            }
-        );
-        req.user = data;
-        return next();
-    } catch (error) {
-        console.error(error);
-        return next(new AuthenticationError(error.response?.data?.message || error.response?.data?.error));
-    }
+  try {
+    const { data } = await axios.get(
+      `${process.env.AUTH_MICROSERVICE_URL}/user`,
+      {
+        headers: {
+          Authorization: req.headers?.authorization
+            ? req.headers['authorization']
+            : '',
+          Cookie: formatCookies(req?.cookies ? req.cookies : {}),
+        },
+      }
+    );
+    req.user = data;
+    return next();
+  } catch (error) {
+    console.error(error.message);
+    return next(
+      new AuthenticationError(
+        error.response?.data?.message || error.response?.data?.error
+      )
+    );
+  }
 }
 
 function can(permission) {
-    return async (req, res, next) => {
-        try {
-            const { data } = await axios.get(
-                `${process.env.AUTH_MICROSERVICE_URL}/user/can`,
-                {
-                    params: {
-                        name: permission,
-                    },
-                    headers: {
-                        Authorization: req.headers['authorization'],
-                        Cookie: formatCookies(req.cookies)
-                    },
-                }
-            );
-
-            if (!data) return next(new UnauthorizedError("You are not authorized to access this endpoint"));
-            else return next();
-        } catch (error) {
-            return next(new UnauthorizedError("You are not authorized to access this endpoint"))
+  return async (req, res, next) => {
+    try {
+      const { data } = await axios.get(
+        `${process.env.AUTH_MICROSERVICE_URL}/user/can`,
+        {
+          params: {
+            name: permission,
+          },
+          headers: {
+            Authorization: req.headers['authorization'],
+            Cookie: formatCookies(req.cookies),
+          },
         }
+      );
 
+      if (!data) {
+        return next(
+          new UnauthorizedError(
+            'You are not authorized to access this endpoint'
+          )
+        );
+      }
+      return next();
+    } catch (error) {
+      return next(
+        new UnauthorizedError('You are not authorized to access this endpoint')
+      );
     }
+  };
 }
 
 module.exports = {
-    auth,
-    can
-};
+  auth,
+  can,
+};

package/src/response/response.js

@@ -1,18 +1,18 @@
 module.exports = formatResponse = (req, res, next) => {
-    res.apiResponse = (status, success, message = null, data = null) => {
-        const response = {
-            status,
-            success
-        };
-        if (data) {
-            response.data = data;
-        }
-        if (message && success) {
-            response.message = message;
-        } else if (message) {
-            response.error = message;
-        }
-        res.status(status).json(response);
+  res.apiResponse = (status, success, message = null, data = null) => {
+    const response = {
+      status,
+      success,
     };
-    next();
-};
+    if (data) {
+      response.data = data;
+    }
+    if (message && success) {
+      response.message = message;
+    } else if (message) {
+      response.error = message;
+    }
+    res.status(status).json(response);
+  };
+  next();
+};