@just-tracking/shared 1.0.0

package/.env.example

@@ -0,0 +1 @@
+AUTH_MICROSERVICE_URL=""

package/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Publish package
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+

package/index.js

@@ -0,0 +1,12 @@
+const errors = require("./src/errors/errors");
+const topics = require("./src/kafka/topics");
+const authMiddleware = require("./src/middlewares/auth.middleware");
+const formatResponse = require('./src/response/response');
+const logger = require('./src/logger/logger');
+const rabbitBroker = require('./src/wrappers/rabbitBroker');
+
+module.exports.Errors = errors;
+module.exports.Topics = topics;
+module.exports.AuthMiddleware = authMiddleware;
+module.exports.formatResponse = formatResponse;
+module.exports.rabbitBroker = rabbitBroker;

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@just-tracking/shared",
+  "version": "1.0.0",
+  "main": "index.js",
+  "author": "Sargis Yeritsyan <sargis021996@gmail.com>",
+  "license": "MIT",
+  "description": "Just Tracking shared lib",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.12.1",
+    "npm": ">=8.19.2"
+  },
+  "dependencies": {
+    "@slack/bolt": "^3.17.1",
+    "amqplib": "^0.10.4",
+    "axios": "^1.4.0",
+    "dotenv": "^16.3.1",
+    "lodash": "^4.17.21",
+    "winston": "^3.11.0",
+    "winston-daily-rotate-file": "^5.0.0"
+  },
+  "devDependencies": {}
+}

package/src/errors/errors.js

@@ -0,0 +1,135 @@
+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 ERRORS = {
+    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;
+    }
+}
+
+class AuthenticationError extends CustomError {
+    constructor(message, status, 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);
+    }
+}
+
+class UnauthorizedError extends CustomError {
+    constructor(message, data = {}) {
+        super(message, data, ERRORS['UNAUTHORIZED'].label, ERRORS['UNAUTHORIZED'].status);
+    }
+}
+
+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
+            })
+        }
+    }
+
+    return res.status(status).json({
+        success: false,
+        status: status,
+        error: err.message,
+        data: err.data,
+        type: err.type
+    });
+}
+
+module.exports = {
+    AuthenticationError,
+    UnauthorizedError,
+    ValidationError,
+    errorHandler
+}

package/src/kafka/topics.js

@@ -0,0 +1,21 @@
+const topics = {
+    USER_CREATED: 'user.created',
+    USER_EDITED: 'user.edited',
+    USER_DELETED: 'user.deleted',
+    TRIP_CREATED: 'trip.created',
+    TRIP_EDITED: 'trip.edited',
+    TRIP_DELETED: 'trip.deleted',
+    TRIP_FINISHED: 'trip.finished',
+    DRIVER_ASSIGNED: 'driver.assigned',
+    DRIVER_CREATED: 'driver.created',
+    DRIVER_EDITED: 'driver.edited',
+    DRIVER_DELETED: 'driver.deleted',
+    SEND_EMAIL_MESSAGE: 'send.email.message',
+    SEND_PHONE_MESSAGE: 'send.phone.message',
+    SEND_CHAT_MESSAGE: 'send.chat.message',
+    SEND_NOTIFICATION: 'send.notification'
+};
+
+module.exports = {
+    topics
+}

package/src/logger/logger.js

@@ -0,0 +1,27 @@
+const path = require('path');
+const fs = require('fs');
+const winston = require('winston');
+const { combine, timestamp, json, prettyPrint, errors } = winston.format;
+const DailyRotateFile = require('winston-daily-rotate-file');
+
+const logDirectory = path.resolve(__dirname, '../../../../logs');
+
+if (!fs.existsSync(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
+        }),
+    ],
+});
+
+module.exports = logger;

package/src/middlewares/auth.middleware.js

@@ -0,0 +1,57 @@
+const axios = require('axios');
+const { UnauthorizedError, AuthenticationError } = require('../errors/errors');
+
+function formatCookies(cookies) {
+    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));
+    }
+}
+
+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"))
+        }
+
+    }
+}
+
+module.exports = {
+    auth,
+    can
+};

package/src/response/response.js

@@ -0,0 +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);
+    };
+    next();
+};

package/src/wrappers/rabbitBroker.js

@@ -0,0 +1,150 @@
+const amqp = require('amqplib');
+const _ = require('lodash');
+
+/**
+ * @var {Promise<MessageBroker>}
+ */
+let instance;
+
+/**
+ * Broker for async messaging
+ */
+class MessageBroker {
+    /**
+     * Trigger init connection method
+     */
+    constructor() {
+        this.queues = {};
+    }
+
+    /**
+     * Initialize connection to rabbitMQ
+     */
+    async init() {
+        try {
+            console.log('Connecting to RabbitMQ:', process.env.RABBITMQ_URL);
+            this.connection = await amqp.connect(process.env.RABBITMQ_URL || 'amqp://localhost');
+            this.channel = await this.connection.createChannel();
+            console.log('Connected to RabbitMQ');
+
+            this.connection.on('close', async () => {
+                console.warn('RabbitMQ connection closed, attempting to reconnect...');
+                await this.init();
+            });
+
+            this.connection.on('error', (error) => {
+                console.error('RabbitMQ connection error:', error);
+            });
+
+            return this;
+        } catch (error) {
+            console.error('Error connecting to RabbitMQ:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Send message to queue
+     * @param {String} queue Queue name
+     * @param {Object} msg Message as any
+     */
+    async send(queue, msg) {
+        if (!this.connection) {
+            await this.init();
+        }
+        await this.channel.assertQueue(queue, { durable: true });
+        this.channel.sendToQueue(queue, Buffer.from(JSON.stringify(msg)), { persistent: true });
+    }
+
+    async sendExchange(exchange, queue, msg) {
+        if (!this.connection) {
+            await this.init();
+        }
+
+        await this.channel.assertExchange(exchange, 'fanout', { durable: true });
+        this.channel.publish(exchange, queue, Buffer.from(JSON.stringify(msg)), { deliveryMode: 2 });
+    }
+
+    /**
+     * @param {String} queue Queue name
+     * @param {Function} handler Handler that will be invoked with given message and acknowledge function (msg, ack)
+     */
+    async subscribe(queue, handler) {
+        if (!this.connection) {
+            await this.init();
+        }
+        if (this.queues[queue]) {
+            const existingHandler = _.find(this.queues[queue], (h) => h === handler);
+            if (existingHandler) {
+                return () => this.unsubscribe(queue, existingHandler);
+            }
+            this.queues[queue].push(handler);
+            return () => this.unsubscribe(queue, handler);
+        }
+
+        await this.channel.assertQueue(queue, { durable: true });
+        await this.channel.prefetch(1);
+        this.queues[queue] = [handler];
+        this.channel.consume(queue, async (msg) => {
+            const ack = _.once(() => this.channel.ack(msg));
+            const nack = _.once(() => this.channel.nack(msg, false, true));
+
+            try {
+                await Promise.all(this.queues[queue].map((h) => h(msg, ack)));
+                ack(); // Acknowledge if all handlers succeed
+            } catch (error) {
+                console.error('Error processing message:', error);
+                nack(); // Reject message on failure
+            }
+
+        });
+        return () => this.unsubscribe(queue, handler);
+    }
+
+    /**
+     * @param {String} exchange Queue name
+     * @param {String} routing Queue name
+     * @param {Function} handler Handler that will be invoked with given message and acknowledge function (msg, ack)
+     */
+    async subscribeExchange(exchange, routing, handler) {
+        if (!this.connection) {
+            await this.init();
+        }
+
+        await this.channel.assertExchange(exchange, 'fanout', {
+            durable: true,
+        });
+
+        const { queue } = await this.channel.assertQueue('', {
+            exclusive: true,
+            durable: true
+        });
+
+        await this.channel.bindQueue(queue, exchange, routing);
+
+        this.channel.consume(
+            queue,
+            async (msg) => {
+                const ack = _.once(() => this.channel.ack(msg));
+                handler(msg, ack);
+            }
+        );
+    }
+
+    async unsubscribe(queue, handler) {
+        _.pull(this.queues[queue], handler);
+    }
+}
+
+/**
+ * @return {Promise<MessageBroker>}
+ */
+MessageBroker.getInstance = async function () {
+    if (!instance) {
+        const broker = new MessageBroker();
+        instance = broker.init();
+    }
+    return instance;
+};
+
+module.exports = MessageBroker;