@platform-x/hep-notification-client 1.0.0

package/dist/src/common/service/requestService.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestHandler = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../util/logger");
+const https_1 = __importDefault(require("https"));
+const errorHandler_1 = require("../util/errorHandler");
+const constants_1 = require("../../platform-x/constants");
+class HttpRequestHandler {
+    // NOSONAR-NEXT-LINE
+    constructor() {
+        this.requestTimeout = 1000 * 30;
+    } // NOSONAR
+    /**
+     * post - handler to do post api calls
+     * @param requestConfig
+     * @returns
+     */
+    post(requestConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('HttpRequestHandler: Reached post method', 'post');
+            const { url, body } = requestConfig;
+            const defaultOptions = {
+                headers: {
+                    'Content-Type': constants_1.HTTP_CONTENT_TYPE_JSON,
+                },
+            };
+            let options = requestConfig.options || defaultOptions;
+            options.httpsAgent = new https_1.default.Agent({
+                rejectUnauthorized: true,
+            });
+            if (!options.headers) {
+                options.headers = {};
+            }
+            options.timeout = this.requestTimeout;
+            return axios_1.default
+                .post(url, body, options)
+                .then((res) => {
+                logger_1.Logger.info('HttpRequestHandler: Successfull Response', 'post');
+                return res.data;
+            })
+                .catch((err) => {
+                var _a;
+                let apiError = new errorHandler_1.ApiError(err.message, (_a = err.response) === null || _a === void 0 ? void 0 : _a.status);
+                logger_1.Logger.error('HttpRequestHandler: Error in post', 'post', err);
+                throw apiError;
+            });
+        });
+    }
+    /**
+     * get - handler to do get api calls
+     * @param requestConfig
+     * @returns
+     */
+    get(requestConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('HttpRequestHandler: Reached get method', 'get');
+            const { url } = requestConfig;
+            const defaultOptions = {};
+            let options = requestConfig.options || defaultOptions;
+            options.httpsAgent = new https_1.default.Agent({
+                rejectUnauthorized: true,
+            });
+            if (!options.headers) {
+                options.headers = {};
+            }
+            options.timeout = this.requestTimeout;
+            return axios_1.default
+                .get(url, options)
+                .then((res) => {
+                logger_1.Logger.info('HttpRequestHandler: Successfull Response', 'get');
+                return res.data;
+            })
+                .catch((err) => {
+                var _a;
+                let apiError = new errorHandler_1.ApiError(err.message, (_a = err.response) === null || _a === void 0 ? void 0 : _a.status);
+                logger_1.Logger.error('HttpRequestHandler: Error in get', 'get', err);
+                throw apiError;
+            });
+        });
+    }
+}
+exports.HttpRequestHandler = HttpRequestHandler;
+//# sourceMappingURL=requestService.js.map

package/dist/src/common/service/twilioService.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwilioService = void 0;
+const twilio_1 = __importDefault(require("twilio"));
+const logger_1 = require("../util/logger");
+class TwilioService {
+    /**
+     * Constructor to initialize Twilio client and sender number
+     * @param accountSid - Twilio Account SID
+     * @param authToken - Twilio Auth Token
+     * @param senderNumber - Twilio Sender Phone Number
+     */
+    constructor(accountSid, authToken, senderNumber) {
+        this.client = (0, twilio_1.default)(accountSid, authToken);
+        this.senderNumber = senderNumber;
+    }
+    /**
+     * Send an SMS using Twilio
+     * @param to - Recipient's phone number
+     * @param message - Message content
+     * @returns Promise resolving with the Twilio response
+     */
+    sendSMS(to, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('twilioService: Reached sendSMS', 'sendSMS');
+            logger_1.Logger.debug('twilioService: check message and recipient number', 'sendSMS', { to, message });
+            try {
+                const response = yield this.client.messages.create({
+                    body: message,
+                    from: this.senderNumber,
+                    to,
+                });
+                return response;
+            }
+            catch (error) {
+                logger_1.Logger.error('twilioService: error in send SMS by twilio', 'sendSMS', error);
+                throw new Error('Failed to send SMS');
+            }
+        });
+    }
+}
+exports.TwilioService = TwilioService;
+//# sourceMappingURL=twilioService.js.map

package/dist/src/common/util/commonUtil.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.validateMessage = exports.validatePhoneNumber = void 0;
+const errorHandler_1 = require("./errorHandler");
+/**
+ * Validate a phone number for format and length
+ * @param phoneNumber
+ * @returns
+ */
+const validatePhoneNumber = (phoneNumber) => {
+    // Regular expression for validating international phone numbers
+    const phoneRegex = /^\+?[1-9]\d{1,14}$/; // E.164 format
+    return phoneRegex === null || phoneRegex === void 0 ? void 0 : phoneRegex.test(phoneNumber);
+};
+exports.validatePhoneNumber = validatePhoneNumber;
+/**
+ * Validate a message for length and content
+ * @param message
+ * @returns
+ */
+const validateMessage = (message) => {
+    var _a;
+    const maxLength = 250; // Standard SMS max length
+    return ((_a = message === null || message === void 0 ? void 0 : message.trim()) === null || _a === void 0 ? void 0 : _a.length) > 0 && (message === null || message === void 0 ? void 0 : message.length) <= maxLength;
+};
+exports.validateMessage = validateMessage;
+/**
+ * Validate both phone number and message
+ * @param phoneNumber
+ * @param message
+ * @returns
+ */
+const validate = (phoneNumber, message) => {
+    const errors = [];
+    if (!(0, exports.validatePhoneNumber)(phoneNumber)) {
+        (0, errorHandler_1.throwError)('Invalid phone number format. Ensure it follows +915647374757 like this.');
+    }
+    if (!(0, exports.validateMessage)(message)) {
+        (0, errorHandler_1.throwError)('Message must be between 1 and 250 characters.');
+    }
+    return { valid: true, errors: '' };
+};
+exports.validate = validate;
+//# sourceMappingURL=commonUtil.js.map

package/dist/src/common/util/errorHandler.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwError = exports.errorMapper = exports.CustomError = exports.SolrError = exports.ApiError = exports.CommonErrorTemplate = exports.HTTP_STATUS_MAP = void 0;
+exports.HTTP_STATUS_MAP = new Map([
+    [500, 'Internal Server Error']
+]);
+class CommonErrorTemplate extends Error {
+    constructor(msg, code) {
+        super(msg);
+        this.code = code || 500 /* HTTP_STATUS_CODE.INTERNAL_SERVER_ERROR */;
+        this.type =
+            exports.HTTP_STATUS_MAP.get(this.code) || "Internal Server Error" /* HTTP_STATUS_TYPE.INTERNAL_SERVER_ERROR */;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            type: this.type,
+            message: this.message,
+        };
+    }
+}
+exports.CommonErrorTemplate = CommonErrorTemplate;
+class ApiError extends CommonErrorTemplate {
+    constructor(msg, code) {
+        super(msg, code);
+        this.name = 'ApiError';
+        Error.captureStackTrace(this, ApiError);
+    }
+}
+exports.ApiError = ApiError;
+class SolrError extends CommonErrorTemplate {
+    constructor(msg, code) {
+        super(msg, code);
+        this.name = 'SolrError';
+        Error.captureStackTrace(this, SolrError);
+    }
+}
+exports.SolrError = SolrError;
+class CustomError {
+    constructor(errObj, code, type, message, stack) {
+        this.code = code;
+        this.type = type;
+        this.message = message;
+        this.stack = stack;
+        this.errorObj = errObj;
+    }
+    toJSON() {
+        // NOSONAR
+        return {
+            code: this.code,
+            type: this.type,
+            message: this.message,
+        };
+    }
+}
+exports.CustomError = CustomError;
+/**
+ * errorMapper - to map error object to custom error
+ */
+const errorMapper = (err, statusCode, type) => {
+    let error;
+    let customError;
+    let code = statusCode || 500 /* HTTP_STATUS_CODE.INTERNAL_SERVER_ERROR */;
+    let errorType = type || exports.HTTP_STATUS_MAP.get(code) || "Internal Server Error" /* HTTP_STATUS_TYPE.INTERNAL_SERVER_ERROR */;
+    if (typeof err === 'string') {
+        error = new Error(err);
+        customError = new CustomError(null, code, errorType, error.message, error.stack);
+        return customError;
+    }
+    else if (err.stack &&
+        err.message &&
+        !(err instanceof CustomError) &&
+        !err.toJSON) {
+        customError = new CustomError(null, code, errorType, err.message, err.stack);
+        return customError;
+    }
+    else {
+        return err;
+    }
+};
+exports.errorMapper = errorMapper;
+/**
+ * throwError - to throw custome error
+ */
+const throwError = (err, statusCode, type) => {
+    throw (0, exports.errorMapper)(err, statusCode, type);
+};
+exports.throwError = throwError;
+//# sourceMappingURL=errorHandler.js.map

package/dist/src/common/util/logger.js

@@ -0,0 +1,193 @@
+"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) => {
+            {
+                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 !== undefined ? 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 !== undefined ? 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 !== undefined ? 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) {
+                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/common/util/requestTracer.js

@@ -0,0 +1,17 @@
+"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 = void 0;
+const cls_hooked_1 = __importDefault(require("cls-hooked"));
+const uuid_1 = require("uuid");
+const nsid = `rtracer:${(0, uuid_1.v4)()}`;
+const ns = cls_hooked_1.default.createNamespace(nsid);
+const traceIdKey = 'traceId';
+const spanIdKey = 'spanId';
+const getTraceId = () => ns.get(traceIdKey);
+exports.getTraceId = getTraceId;
+const getSpanId = () => ns.get(spanIdKey);
+exports.getSpanId = getSpanId;
+//# sourceMappingURL=requestTracer.js.map

package/dist/src/common/util/solrConnector.js

@@ -0,0 +1,157 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolrClient = void 0;
+const logger_1 = require("./logger");
+const index_1 = __importDefault(require("../../config/index"));
+const errorHandler_1 = require("./errorHandler");
+const constants_1 = require("../../platform-x/constants");
+const solr = require('solr-client');
+class SolrClient {
+    constructor(core) {
+        this.host = index_1.default.SOLR.HOST || '';
+        this.port = Number(index_1.default.SOLR.PORT);
+        this.path = index_1.default.SOLR.PATH || '/solr';
+        this.secure = false;
+        this.core = core || process.env.SOLR_CORE || '';
+        const options = {
+            host: this.host,
+            port: this.port,
+            core: this.core,
+            path: this.path,
+            secure: this.secure,
+        };
+        this.solrNodeClient = solr.createClient(options);
+        this.solrQuery = null;
+    }
+    getQuery() {
+        return this.solrQuery;
+    }
+    createQuery() {
+        this.solrQuery = this.solrNodeClient.createQuery();
+        return {
+            query: this.query.bind(this),
+            filterQuery: this.filterQuery.bind(this),
+            sort: this.sort.bind(this),
+            filterList: this.filterList.bind(this),
+            paginate: this.paginate.bind(this),
+        };
+    }
+    executeSearch() {
+        logger_1.Logger.info('SOLR ExecuteSearch Reached', 'executeSearch');
+        const q = this.solrQuery;
+        logger_1.Logger.debug('Before calling search method', 'executeSearch', q);
+        //try {
+        return new Promise((resolve, reject) => {
+            this.solrNodeClient.search(q, function (err, res) {
+                if (err) {
+                    logger_1.Logger.error(`Error in Solr Search for query:--------------------->`, 'executeSearch', err);
+                    let solrError = new errorHandler_1.SolrError(err.message || err.name, Number(err.statusCode));
+                    logger_1.Logger.error('Error in Solr Search for query: ${q}', 'solrSearch', err);
+                    reject(solrError);
+                }
+                else {
+                    logger_1.Logger.debug('Before returning search result', 'executeSearch', res);
+                    resolve(res.response.docs);
+                }
+            });
+        });
+        // } catch (err: any) {
+        //   Logger.info(`SOLR EXECUTION ERRROR------${err}`);
+        //   throw err;
+        // }
+    }
+    /**
+     * solrSearch- fn to call solr search
+     * @param queryParams
+     * @param fields
+     * @param fieldType
+     * @param sortData
+     * @returns
+     */
+    solrSearch(queryParams, fields, fieldType, sortData, filterQuery) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.debug('Before calling solrSearch method', 'solrSearch', queryParams);
+            return new Promise((resolve, reject) => {
+                logger_1.Logger.info('Reached Solr Search', 'solrSearch');
+                logger_1.Logger.debug('Reached Solr Search', 'solrSearch', { queryParams });
+                const defaultRows = constants_1.DEFAULT_SOLR_ROWS;
+                let query = this.solrNodeClient.createQuery();
+                if (filterQuery) {
+                    query.matchFilter(filterQuery === null || filterQuery === void 0 ? void 0 : filterQuery.filterKey, filterQuery === null || filterQuery === void 0 ? void 0 : filterQuery.filterValue);
+                }
+                if (queryParams) {
+                    query.q(fieldType);
+                }
+                else {
+                    query.q(`*:*`);
+                }
+                if (queryParams && queryParams.pagination) {
+                    query.start(queryParams.pagination.start ? queryParams.pagination.start : 0);
+                    query.rows(queryParams.pagination.rows
+                        ? queryParams.pagination.rows
+                        : defaultRows);
+                }
+                else {
+                    query.start(0);
+                    query.rows(defaultRows);
+                }
+                if (fields) {
+                    let fieldsTemp = Array.isArray(fields) ? fields : Object.keys(fields);
+                    query.fl(fieldsTemp);
+                }
+                if (sortData) {
+                    query.sort(sortData);
+                }
+                this.solrNodeClient.search(query, function (err, res) {
+                    if (err) {
+                        let solrError = new errorHandler_1.SolrError(err.message || err.name, Number(err.statusCode));
+                        logger_1.Logger.error(`Error in Solr Search for query: ${query}`, 'solrSearch', err);
+                        reject(solrError);
+                    }
+                    else {
+                        logger_1.Logger.debug('Before returning search result', 'solrSearch', res);
+                        resolve(res.response.docs);
+                    }
+                });
+            });
+        });
+    }
+    query(query) {
+        let queryString = query || `*:*`;
+        this.solrQuery.q(queryString);
+    }
+    paginate(start, rows) {
+        this.solrQuery.start(start || 0);
+        this.solrQuery.rows(rows || constants_1.DEFAULT_SOLR_ROWS);
+    }
+    filterList(fields) {
+        if (fields) {
+            let fieldsTemp = Array.isArray(fields) ? fields : Object.keys(fields);
+            this.solrQuery.fl(fieldsTemp);
+        }
+    }
+    sort(fields) {
+        if (fields) {
+            this.solrQuery.sort(fields);
+        }
+    }
+    filterQuery(fields) {
+        if (fields === null || fields === void 0 ? void 0 : fields.length) {
+            this.solrQuery.fq(fields);
+        }
+    }
+}
+exports.SolrClient = SolrClient;
+//# sourceMappingURL=solrConnector.js.map