@platform-x/hep-message-broker-client 1.0.0

package/README.md

@@ -0,0 +1 @@
+# hep-message-broker-client

package/dist/src/Util/commonUtil.d.ts

@@ -0,0 +1,16 @@
+/**
+ * stringToBase64 - to convert string into base64
+ * @param {string} toEncode- string request
+ */
+export declare const stringToBase64: (toEncode: string) => string;
+/**
+ * singleJSONParseHandler - to parse the json
+ * @param jsonString
+ * @param defaultValue
+ */
+export declare const singleJSONParseHandler: (jsonString: string, defaultValue: any) => any;
+/**
+ * Function to generate a correlation ID for tracing
+ * @returns
+ */
+export declare const generateCorrelationId: () => string;

package/dist/src/Util/commonUtil.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCorrelationId = exports.singleJSONParseHandler = exports.stringToBase64 = void 0;
+const logger_1 = require("./logger");
+const requestTracer_1 = require("./requestTracer");
+/**
+ * stringToBase64 - to convert string into base64
+ * @param {string} toEncode- string request
+ */
+const stringToBase64 = (toEncode) => {
+    return Buffer.from(toEncode, 'ascii').toString('base64');
+};
+exports.stringToBase64 = stringToBase64;
+/**
+ * singleJSONParseHandler - to parse the json
+ * @param jsonString
+ * @param defaultValue
+ */
+const singleJSONParseHandler = (jsonString, defaultValue) => {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (err) {
+        logger_1.Logger.warn(`Error while parsing JSON for value ${jsonString}`, 'doubleJSONParseHandler');
+        return defaultValue;
+    }
+};
+exports.singleJSONParseHandler = singleJSONParseHandler;
+/**
+ * Function to generate a correlation ID for tracing
+ * @returns
+ */
+const generateCorrelationId = () => {
+    const traceId = (0, requestTracer_1.getTraceId)() ? (0, requestTracer_1.getTraceId)() : 'trace-id';
+    const messageId = Math.random().toString(36).substring(2);
+    return `${traceId}__${messageId}`;
+};
+exports.generateCorrelationId = generateCorrelationId;
+//# sourceMappingURL=commonUtil.js.map

package/dist/src/Util/logger.d.ts

@@ -0,0 +1,68 @@
+export interface payLoadInterface {
+    statusCode?: number;
+    data?: any;
+}
+export interface LoggerInterface {
+    info(message: string, method: string): void;
+    warn(message: string, method: string, payload?: object): void;
+    error(message: string, method: string, payload?: object): void;
+    debug(message: string, method: string, payload?: object): void;
+}
+export declare class LoggerClass implements LoggerInterface {
+    private logger;
+    private infoLevel;
+    private debugLevel;
+    private errorLevel;
+    private warnLevel;
+    private blockedKeywords;
+    constructor();
+    /**
+     * It's written to handle JSON.circular error
+     * @param obj
+     * @returns
+     */
+    customstringify(obj: any): string;
+    /**
+     * for info log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    info(message: string, method: string): void;
+    /**
+     * for warn log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    warn(message: string, method: string, payload?: any): void;
+    /**
+     * for error log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    error(message: string, method: string, payload?: any): void;
+    /**
+     * for debug log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    debug(message: string, method: string, payload?: any): void;
+    /**
+     * to map log levels and handle from config
+     */
+    private mapLogLevels;
+    /**
+     * to sanitize logs from unwanted fields to be shown
+     * @param request
+     * @returns
+     */
+    private sanitizeLog;
+}
+export declare const Logger: LoggerClass;

package/dist/src/Util/logger.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LoggerClass = void 0;
+const bunyan_1 = __importDefault(require("bunyan"));
+const index_1 = __importDefault(require("../config/index"));
+const bunyan_format_1 = __importDefault(require("bunyan-format"));
+const requestTracer_1 = require("./requestTracer");
+class LoggerClass {
+    constructor() {
+        this.infoLevel = false;
+        this.debugLevel = false;
+        this.errorLevel = false;
+        this.warnLevel = false;
+        this.blockedKeywords = ['currentPassword', 'clientSecret', 'newPassword'];
+        this.mapLogLevels();
+        this.logger = bunyan_1.default.createLogger({
+            name: index_1.default.APP_NAME,
+            level: 'trace', // by default enabling all levels, controlled through env separately
+            stream: (0, bunyan_format_1.default)({
+                outputMode: index_1.default.NODE_ENV === 'development' ? 'short' : 'bunyan',
+                levelInString: true,
+                color: true,
+            }),
+        });
+    }
+    /**
+     * It's written to handle JSON.circular error
+     * @param obj
+     * @returns
+     */
+    customstringify(obj) {
+        let cache = [];
+        let str = JSON.stringify(obj, (key, value) => {
+            {
+                this.info(`Logger customstringify ${key}`, 'customstringify');
+                if (typeof value === 'object' && value !== null) {
+                    if (cache.indexOf(value) !== -1) {
+                        // Circular reference found, discard key
+                        return;
+                    }
+                    // Store value in our collection 
+                    cache.push(value);
+                }
+                return value;
+            }
+        });
+        cache = null; // reset the cache
+        return str;
+    }
+    /**
+     * for info log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    info(message, method) {
+        if (!this.infoLevel) {
+            return;
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+        };
+        this.logger.info(` start ${JSON.stringify(loggerParams)}==end`);
+    }
+    /**
+     * for warn log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    warn(message, method, payload) {
+        if (!this.warnLevel) {
+            return;
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+            statusCode: payload === null || payload === void 0 ? void 0 : payload.statusCode,
+        };
+        let finalPayload = (payload === null || payload === void 0 ? void 0 : payload.length) ? payload : {};
+        this.logger.warn(` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(this.sanitizeLog(finalPayload))}==end`);
+    }
+    /**
+     * for error log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    error(message, method, payload) {
+        if (!this.errorLevel) {
+            return;
+        }
+        if (payload instanceof Error) {
+            payload = {
+                message,
+                method,
+                traceId: (0, requestTracer_1.getTraceId)(),
+                stack: payload === null || payload === void 0 ? void 0 : payload.stack,
+            };
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+            spanId: (0, requestTracer_1.getSpanId)(),
+            statusCode: payload === null || payload === void 0 ? void 0 : payload.statusCode,
+        };
+        let finalPayload = (payload === null || payload === void 0 ? void 0 : payload.length) ? payload : {};
+        this.logger.error(` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(this.sanitizeLog(finalPayload))}==end`);
+    }
+    /**
+     * for debug log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    debug(message, method, payload) {
+        if (!this.debugLevel) {
+            return;
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+            statusCode: payload === null || payload === void 0 ? void 0 : payload.statusCode,
+        };
+        let finalPayload = (payload === null || payload === void 0 ? void 0 : payload.length) ? payload : {};
+        this.logger.debug(` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(this.sanitizeLog(finalPayload))}==end`);
+    }
+    /**
+     * to map log levels and handle from config
+     */
+    mapLogLevels() {
+        if (index_1.default.LOG_LEVELS.length) {
+            index_1.default.LOG_LEVELS.forEach((element) => {
+                const logLevel = element.trim();
+                if (logLevel === 'info') {
+                    this.infoLevel = true;
+                }
+                else if (logLevel === 'debug') {
+                    this.debugLevel = true;
+                }
+                else if (logLevel === 'error') {
+                    this.errorLevel = true;
+                }
+                else if (logLevel === 'warn') {
+                    this.warnLevel = true;
+                }
+            });
+        }
+    }
+    /**
+     * to sanitize logs from unwanted fields to be shown
+     * @param request
+     * @returns
+     */
+    sanitizeLog(request) {
+        try {
+            if (request) {
+                // let obj: any = {};
+                Object.keys(request).forEach((key) => {
+                    let value = request[key];
+                    if (request[key] === 'options') {
+                        delete request.options;
+                    }
+                    else {
+                        if (this.blockedKeywords.find((blockedKey) => key.toLowerCase() === blockedKey.toLowerCase())) {
+                            request[key] = 'XXXXXXXXXX';
+                        }
+                        else {
+                            request[key] = value;
+                        }
+                    }
+                });
+                return request;
+            }
+        }
+        catch (err) {
+            this.error('Logger sanitize error', err);
+        }
+    }
+}
+exports.LoggerClass = LoggerClass;
+exports.Logger = new LoggerClass();
+//# sourceMappingURL=logger.js.map

package/dist/src/Util/requestTracer.d.ts

@@ -0,0 +1,7 @@
+import { NextFunction, Request, Response } from 'express';
+/**
+ * setTracers - to set the request tracers on the request
+ */
+export declare const setTracers: (req: Request, res: Response, next: NextFunction) => void;
+export declare const getTraceId: () => any;
+export declare const getSpanId: () => any;

package/dist/src/Util/requestTracer.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpanId = exports.getTraceId = exports.setTracers = void 0;
+const cls_hooked_1 = __importDefault(require("cls-hooked"));
+const uuid_1 = require("uuid");
+const TRACE_ID_HEADER_NAME = 'Platform-X-Trace-Id';
+const nsid = `rtracer:${(0, uuid_1.v4)()}`;
+const ns = cls_hooked_1.default.createNamespace(nsid);
+const traceIdKey = 'traceId';
+const spanIdKey = 'spanId';
+/**
+ * setTracers - to set the request tracers on the request
+ */
+const setTracers = (req, res, next) => {
+    const headerName = TRACE_ID_HEADER_NAME.toLocaleLowerCase();
+    ns.bindEmitter(req);
+    ns.bindEmitter(res);
+    const traceId = req.headers[headerName] || (0, uuid_1.v4)(); // to be passed in headers
+    const spanId = (0, uuid_1.v4)(); // will be unique for services
+    ns.run(() => {
+        ns.set(traceIdKey, traceId);
+        ns.set(spanIdKey, spanId);
+        next();
+    });
+};
+exports.setTracers = setTracers;
+const getTraceId = () => ns.get(traceIdKey);
+exports.getTraceId = getTraceId;
+const getSpanId = () => ns.get(spanIdKey);
+exports.getSpanId = getSpanId;
+//# sourceMappingURL=requestTracer.js.map

package/dist/src/config/ConfigManager.d.ts

@@ -0,0 +1,9 @@
+declare class ConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): ConfigManager;
+    loadConfig(configPath: string): void;
+    getConfig(): any;
+}
+export default ConfigManager;

package/dist/src/config/ConfigManager.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const index_1 = __importDefault(require("./index"));
+const logger_1 = require("../Util/logger");
+class ConfigManager {
+    constructor() {
+        this.config = {};
+        this.loadConfig(index_1.default.RABBITMQ.CONFIG_PATH);
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    loadConfig(configPath) {
+        if (fs.existsSync(configPath)) {
+            // Do something
+            this.config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }
+        else {
+            logger_1.Logger.error("Config file missing!", "loadConfig");
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+}
+exports.default = ConfigManager;
+//# sourceMappingURL=ConfigManager.js.map

package/dist/src/config/index.d.ts

@@ -0,0 +1,29 @@
+declare const _default: {
+    LOG_LEVELS: string[];
+    NODE_ENV: string;
+    APP_NAME: string;
+    RABBITMQ: {
+        USER: string;
+        PASS: string;
+        HOST: string;
+        PORT: string;
+        MAIN_QUEUE: string;
+        MAIN_EXCHANGE: string;
+        DLX_QUEUE: string;
+        DLX_EXCHANGE: string;
+        RETRY_QUEUE: string;
+        RETRY_EXCHANGE: string;
+        MAX_RETRIES: number;
+        HEARTBEAT: number;
+        TTL: string;
+        BACKOFF_TIME: number;
+        IS_ENABLED: string;
+        RABBITMQ_CONFIG: string;
+        PREFETCH_COUNT: number;
+        CONNECTION_ERROR: string | boolean;
+        PUBLISHER_ERROR: string | boolean;
+        CONSUMER_ERROR: string | boolean;
+        CONFIG_PATH: string;
+    };
+};
+export default _default;

package/dist/src/config/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+exports.default = {
+    LOG_LEVELS: ['info', 'error', 'warn', 'debug'],
+    NODE_ENV: 'development',
+    APP_NAME: 'hep-message-broker-client',
+    RABBITMQ: {
+        USER: (_a = process.env.RABBITMQ_USER) !== null && _a !== void 0 ? _a : 'root',
+        PASS: (_b = process.env.RABBITMQ_PASS) !== null && _b !== void 0 ? _b : 'root',
+        HOST: (_c = process.env.RABBITMQ_HOST) !== null && _c !== void 0 ? _c : '127.0.0.1',
+        PORT: (_d = process.env.RABBITMQ_PORT) !== null && _d !== void 0 ? _d : '5672',
+        MAIN_QUEUE: 'main_queue',
+        MAIN_EXCHANGE: 'assets_metadata_generate_exchange',
+        DLX_QUEUE: 'dead_letter_queue',
+        DLX_EXCHANGE: 'assets_dlx_exchange',
+        RETRY_QUEUE: 'retry_queue',
+        RETRY_EXCHANGE: 'assets_metadata_generate_retry_exchange',
+        MAX_RETRIES: Number((_f = (_e = process.env.RABBITMQ_MAX_RETRIES) === null || _e === void 0 ? void 0 : _e.trim()) !== null && _f !== void 0 ? _f : 1),
+        HEARTBEAT: Number((_h = (_g = process.env.RABBITMQ_HEARTBEAT) === null || _g === void 0 ? void 0 : _g.trim()) !== null && _h !== void 0 ? _h : 5),
+        TTL: (_j = process.env.RABBITMQ_TTL) !== null && _j !== void 0 ? _j : "3000|6000|9000",
+        BACKOFF_TIME: Number((_l = (_k = process.env.BACKOFF_TIME) === null || _k === void 0 ? void 0 : _k.trim()) !== null && _l !== void 0 ? _l : 1000),
+        IS_ENABLED: (_m = process.env.RABBITMQ_IS_ENABLED) !== null && _m !== void 0 ? _m : 'true',
+        RABBITMQ_CONFIG: (_o = process.env.RABBITMQ_CONFIG) !== null && _o !== void 0 ? _o : '',
+        PREFETCH_COUNT: Number((_p = process.env.RABBITMQ_PREFETCH) !== null && _p !== void 0 ? _p : 50),
+        CONNECTION_ERROR: (_q = process.env.RABBITMQ_CONNECTION_ERROR) !== null && _q !== void 0 ? _q : false,
+        PUBLISHER_ERROR: (_r = process.env.RABBITMQ_PUBLISHER_ERROR) !== null && _r !== void 0 ? _r : false,
+        CONSUMER_ERROR: (_s = process.env.RABBITMQ_CONSUMER_ERROR) !== null && _s !== void 0 ? _s : false,
+        CONFIG_PATH: (_t = process.env.CONFIG_PATH) !== null && _t !== void 0 ? _t : '/etc/rabbitmq/rabbitMQConfig.json',
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+import { MessageBrokerClient } from "./messageBroker/rabbitmq/MessageBrokerClient";
+export { MessageBrokerClient };

package/dist/src/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBrokerClient = void 0;
+const MessageBrokerClient_1 = require("./messageBroker/rabbitmq/MessageBrokerClient");
+Object.defineProperty(exports, "MessageBrokerClient", { enumerable: true, get: function () { return MessageBrokerClient_1.MessageBrokerClient; } });
+//# sourceMappingURL=index.js.map

package/dist/src/messageBroker/BaseRabbitMQClient.d.ts

@@ -0,0 +1,16 @@
+import * as amqp from 'amqplib';
+import ConfigManager from '../config/ConfigManager';
+import ConnectionManager from './ConnectionManager';
+declare class BaseRabbitMQClient {
+    readonly configManager: ConfigManager;
+    readonly connectionManager: ConnectionManager;
+    protected connection: amqp.Connection | undefined;
+    protected channel: amqp.Channel | undefined;
+    protected configData: any;
+    constructor();
+    /**
+    * Function for load the config data
+    */
+    private init;
+}
+export default BaseRabbitMQClient;

package/dist/src/messageBroker/BaseRabbitMQClient.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConfigManager_1 = __importDefault(require("../config/ConfigManager"));
+const config_1 = __importDefault(require("../config"));
+const ConnectionManager_1 = __importDefault(require("./ConnectionManager"));
+class BaseRabbitMQClient {
+    constructor() {
+        this.connectionManager = new ConnectionManager_1.default();
+        this.configData = {};
+        this.configManager = ConfigManager_1.default.getInstance();
+        this.configData = this.configManager.getConfig();
+        this.channel = this.connectionManager.getChannel();
+        this.connection = this.connectionManager.getConnection();
+        this.init();
+    }
+    /**
+    * Function for load the config data
+    */
+    init() {
+        var _a;
+        this.configManager.loadConfig((_a = config_1.default === null || config_1.default === void 0 ? void 0 : config_1.default.RABBITMQ) === null || _a === void 0 ? void 0 : _a.CONFIG_PATH);
+        this.configData = this.configManager.getConfig();
+    }
+}
+exports.default = BaseRabbitMQClient;
+//# sourceMappingURL=BaseRabbitMQClient.js.map

package/dist/src/messageBroker/ConnectionManager.d.ts

@@ -0,0 +1,60 @@
+import * as amqp from 'amqplib';
+interface ConnectionWrapper {
+    connection: amqp.Connection;
+    channel: amqp.Channel;
+}
+declare class ConnectionManager {
+    private static instance;
+    private readonly configManager;
+    protected connection: amqp.Connection | undefined;
+    protected channel: amqp.Channel | undefined;
+    protected configData: any;
+    constructor();
+    /**
+     * Function for get channel
+     */
+    getChannel(): amqp.Channel | undefined;
+    /**
+     * Function for get channel
+     */
+    getConnection(): amqp.Connection | undefined;
+    /**
+     * Function for create and return intance
+     * @returns
+     */
+    static getInstance(): Promise<ConnectionManager>;
+    /**
+      * Function to connect create to RabbitMQ
+      */
+    createConnection(): Promise<ConnectionWrapper>;
+    /**
+     * Function for bind connection event handler on close and error setupQueuesAndExchanges
+     * @returns
+     */
+    private bindConnectionEventHandler;
+    /**
+      * Function to check the status of the connection
+      * @returns boolean
+    */
+    isConnected(): Promise<boolean>;
+    /**
+        * Function to initialize the connection, channel and setup the queues and exchanges
+        * @param reqData
+        * @returns
+    */
+    initialize(): Promise<{
+        connection: amqp.Connection | undefined;
+        channel: amqp.Channel | undefined;
+    } | undefined>;
+    /**
+      * Function to setup the queues and exchanges
+      * @params array
+      * @rtrun
+    */
+    private setupQueuesAndExchanges;
+    /**
+     * Function for load the config data
+     */
+    private init;
+}
+export default ConnectionManager;