playov2-js-utilities 0.3.70 → 0.3.74

package/lib/playo.utils/playo.error.handler.js

@@ -1,24 +1,24 @@
-const {generatePlayoResponse} = require("./playo.res.generator");
-const LOGGER = require("../logger");
-
-const playoError = (error, sourceFunction = "") => {
-    return {
-        stack: error.stack,
-        source: {
-            sourceFunction,
-            errorType: error.name || "Unknown error"
-        },        
-        type: error.type
-    }
-}   
-
-const badResponseErrorHandler = (error, message = "", requestId) => {
-    const  {stack, source = {}} = error;
-    LOGGER.prepareErrorLog(requestId, {errorStack: stack, source}, message);
-    return generatePlayoResponse("BAD_REQUEST", 0, {message}, "OOPs!! something does not seem right, we are on it ;)");
-}
-
-module.exports = {
-    badResponseErrorHandler,
-    playoError
+const {generatePlayoResponse} = require("./playo.res.generator");
+const LOGGER = require("../logger");
+
+const playoError = (error, sourceFunction = "") => {
+    return {
+        stack: error.stack,
+        source: {
+            sourceFunction,
+            errorType: error.name || "Unknown error"
+        },        
+        type: error.type
+    }
+}   
+
+const badResponseErrorHandler = (error, message = "", requestId) => {
+    const  {stack, source = {}} = error;
+    LOGGER.prepareErrorLog(requestId, {errorStack: stack, source}, message);
+    return generatePlayoResponse("BAD_REQUEST", 0, {message}, "OOPs!! something does not seem right, we are on it ;)");
+}
+
+module.exports = {
+    badResponseErrorHandler,
+    playoError
 }

package/lib/playo.utils/playo.http.handler.js

@@ -1,163 +1,163 @@
-const Axios = require('axios');
-const TIMEOUT_DURATION = 15 * 1000 // seconds, used as default
-const Logger = require('../logger.js');
-
-
-/**
- * Axios response handler
- * @param {Response} resp  
- * resp structure | 
- * on success {
- *      status: HTTP status code returned by the service
- *      data,
- *      config: request config    
- *  } 
- * on fail : {
- *      code: error code | http errorcode like ECONNREFUSED, ETIMEOUT etc
- *      message: error message | description of the error code
- *      config: request config
- *  }
- * @param {String} requestId 
- * @returns 
- */
-const playoResponseHandler = (resp, requestId) => {
-    
-    if(!resp) {
-        resp = { 
-            isAxiosError: true,
-            code: "NO_RESPONSE",
-            message: "No response from the service",
-            data : {requestStatus: 0}
-        }
-    }
-
-    if (resp.isAxiosError) {
-        //if axios error is triggered then axios throws HTTP code for timeout or other forms of unsuccessful errors
-        const {
-            code = "UNCAUGHT_ERROR",
-            message = "encountered uncaught error",
-            config = { url: '' },
-            response = { data: { requestStatus: 0 } }
-        } = resp;
-        const { url } = config;
-        const { data = { requestStatus: 0, statusError: "POTENTIAL-BAD-GATEWAY" } } = response;
-        data["message"] = message;
-        Logger.prepareErrorLog(requestId, { code, message }, `Api call to url to ${url} failed`)
-        throw (data);
-    }
-
-    const { status, data = {requestStatus: null}, config = { url: '' } } = resp;
-    const { url = '' } = config;
-    if (status >= 200 && status < 400) {
-        const { requestStatus, message = 'success' } = data;
-        if (!requestStatus && requestStatus != 0) { //if the service does not provide request status 
-            data["requestStatus"] = 1;
-        }
-        Logger.prepareInfoLog(requestId, { status, requestStatus: data.requestStatus, message }, `Api call to url to ${url} succeeded with status ${status}`)
-        return data
-    }
-
-    if(status >= 400) {
-        Logger.prepareErrorLog(requestId, data, `Api call to url to ${url} failed`)
-        throw (data);
-    }
-
-    else { // ideally this should not get triggered unless there is fault in calling lib itself
-        Logger.prepareErrorLog(requestId, { response: resp }, "axios error");
-        throw ({ requestStatus: 0, message: "Failed to handle response" })
-    }
-}
-
-
-/**
- * Makes a get http request - throws error to be handled by calling function
- * @param {String} url 
- * @param {Object} headers 
- * @param {Object} query 
- * @param {String} requestId 
- * @param {Boolean} shouldTimeOut - Defaults to false
- * @param {Number} timeout - in seconds, Defaults to 10 seconds
- * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
- */
-const get = async (url, headers = {}, query = {}, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION, apiName = '') => {
-    try {
-        const resp = await Axios.get(url, { headers, params: query, timeout });
-        return responseHandler(resp, requestId, apiName);
-    } catch (error) {
-        Logger.prepareErrorLog(requestId, { url, headers, query }, `Api call to url to ${url} failed!`);
-        return responseHandler(error.response, requestId, apiName);
-    }
-};
-
-/**
- * Makes a POST http request - throws error to be handled by calling function
- * @param {String} url 
- * @param {Object} headers 
- * @param {Object} query 
- * @param {Object} body 
- * @param {String} requestId 
- * @param {Boolean} shouldTimeOut - Defaults to false
- * @param {Number} timeout - in seconds, Defaults to 10 seconds
- * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
- */
-const post = async (url, headers = {}, query = {}, body = {}, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION, apiName = '') => {
-    try {
-        const options = { headers, params: query, timeout };
-        const resp = await Axios.post(url, body, options);
-        return responseHandler(resp, requestId, apiName);
-    } catch (error) {
-        Logger.prepareErrorLog(requestId, { url, headers, query, body }, `Api call to url to ${url} failed due to ${error.response.message}`);
-        return responseHandler(error.response, requestId, apiName);
-    }
-};
-
-/**
- * Makes a PUT http request - throws error to be handled by calling function
- * @param {String} url 
- * @param {Object} headers 
- * @param {Object} query 
- * @param {Object} body 
- * @param {String} requestId 
- * @param {Boolean} shouldTimeOut - Defaults to false
- * @param {Number} timeout - in seconds, Defaults to 10 seconds
- * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
- */
-const put = async (url, headers = {}, query = {}, body = {}, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION, apiName = '') => {
-    try {
-        const options = { headers, params: query, timeout };
-        const resp = await Axios.put(url, body, options);
-        return responseHandler(resp, requestId, apiName);
-    } catch (error) {
-        Logger.prepareErrorLog(requestId, { url, headers, query, body }, `Api call to url to ${url} failed due to ${error.response.message}`);
-        return responseHandler(error.response, requestId, apiName);
-    }
-};
-
-/**
- * Makes a DELETE http request - throws error to be handled by calling function
- * @param {String} url 
- * @param {Object} headers 
- * @param {Object} query 
- * @param {Object} body 
- * @param {String} requestId 
- * @param {Boolean} shouldTimeOut - Defaults to false
- * @param {Number} timeout - in seconds, Defaults to 10 seconds
- * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
- */
-const remove = async (url, headers = {}, query = {}, body, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION) => {
-    try {
-        const options = { headers, params: query, data: body, timeout };
-        const resp = await Axios.delete(url, options);
-        return responseHandler(resp, requestId);
-    } catch (error) {
-        Logger.prepareErrorLog(requestId, { url, headers, query, body }, `Api call to url to ${url} failed due to ${error.response.message}`);
-        return responseHandler(error.response, requestId, apiName);
-    }
-};
-
-module.exports = {
-    get,
-    post,
-    put,
-    remove
+const Axios = require('axios');
+const TIMEOUT_DURATION = 15 * 1000 // seconds, used as default
+const Logger = require('../logger.js');
+
+
+/**
+ * Axios response handler
+ * @param {Response} resp  
+ * resp structure | 
+ * on success {
+ *      status: HTTP status code returned by the service
+ *      data,
+ *      config: request config    
+ *  } 
+ * on fail : {
+ *      code: error code | http errorcode like ECONNREFUSED, ETIMEOUT etc
+ *      message: error message | description of the error code
+ *      config: request config
+ *  }
+ * @param {String} requestId 
+ * @returns 
+ */
+const playoResponseHandler = (resp, requestId) => {
+    
+    if(!resp) {
+        resp = { 
+            isAxiosError: true,
+            code: "NO_RESPONSE",
+            message: "No response from the service",
+            data : {requestStatus: 0}
+        }
+    }
+
+    if (resp.isAxiosError) {
+        //if axios error is triggered then axios throws HTTP code for timeout or other forms of unsuccessful errors
+        const {
+            code = "UNCAUGHT_ERROR",
+            message = "encountered uncaught error",
+            config = { url: '' },
+            response = { data: { requestStatus: 0 } }
+        } = resp;
+        const { url } = config;
+        const { data = { requestStatus: 0, statusError: "POTENTIAL-BAD-GATEWAY" } } = response;
+        data["message"] = message;
+        Logger.prepareErrorLog(requestId, { code, message }, `Api call to url to ${url} failed`)
+        throw (data);
+    }
+
+    const { status, data = {requestStatus: null}, config = { url: '' } } = resp;
+    const { url = '' } = config;
+    if (status >= 200 && status < 400) {
+        const { requestStatus, message = 'success' } = data;
+        if (!requestStatus && requestStatus != 0) { //if the service does not provide request status 
+            data["requestStatus"] = 1;
+        }
+        Logger.prepareInfoLog(requestId, { status, requestStatus: data.requestStatus, message }, `Api call to url to ${url} succeeded with status ${status}`)
+        return data
+    }
+
+    if(status >= 400) {
+        Logger.prepareErrorLog(requestId, data, `Api call to url to ${url} failed`)
+        throw (data);
+    }
+
+    else { // ideally this should not get triggered unless there is fault in calling lib itself
+        Logger.prepareErrorLog(requestId, { response: resp }, "axios error");
+        throw ({ requestStatus: 0, message: "Failed to handle response" })
+    }
+}
+
+
+/**
+ * Makes a get http request - throws error to be handled by calling function
+ * @param {String} url 
+ * @param {Object} headers 
+ * @param {Object} query 
+ * @param {String} requestId 
+ * @param {Boolean} shouldTimeOut - Defaults to false
+ * @param {Number} timeout - in seconds, Defaults to 10 seconds
+ * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
+ */
+const get = async (url, headers = {}, query = {}, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION, apiName = '') => {
+    try {
+        const resp = await Axios.get(url, { headers, params: query, timeout });
+        return responseHandler(resp, requestId, apiName);
+    } catch (error) {
+        Logger.prepareErrorLog(requestId, { url, headers, query }, `Api call to url to ${url} failed!`);
+        return responseHandler(error.response, requestId, apiName);
+    }
+};
+
+/**
+ * Makes a POST http request - throws error to be handled by calling function
+ * @param {String} url 
+ * @param {Object} headers 
+ * @param {Object} query 
+ * @param {Object} body 
+ * @param {String} requestId 
+ * @param {Boolean} shouldTimeOut - Defaults to false
+ * @param {Number} timeout - in seconds, Defaults to 10 seconds
+ * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
+ */
+const post = async (url, headers = {}, query = {}, body = {}, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION, apiName = '') => {
+    try {
+        const options = { headers, params: query, timeout };
+        const resp = await Axios.post(url, body, options);
+        return responseHandler(resp, requestId, apiName);
+    } catch (error) {
+        Logger.prepareErrorLog(requestId, { url, headers, query, body }, `Api call to url to ${url} failed due to ${error.response.message}`);
+        return responseHandler(error.response, requestId, apiName);
+    }
+};
+
+/**
+ * Makes a PUT http request - throws error to be handled by calling function
+ * @param {String} url 
+ * @param {Object} headers 
+ * @param {Object} query 
+ * @param {Object} body 
+ * @param {String} requestId 
+ * @param {Boolean} shouldTimeOut - Defaults to false
+ * @param {Number} timeout - in seconds, Defaults to 10 seconds
+ * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
+ */
+const put = async (url, headers = {}, query = {}, body = {}, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION, apiName = '') => {
+    try {
+        const options = { headers, params: query, timeout };
+        const resp = await Axios.put(url, body, options);
+        return responseHandler(resp, requestId, apiName);
+    } catch (error) {
+        Logger.prepareErrorLog(requestId, { url, headers, query, body }, `Api call to url to ${url} failed due to ${error.response.message}`);
+        return responseHandler(error.response, requestId, apiName);
+    }
+};
+
+/**
+ * Makes a DELETE http request - throws error to be handled by calling function
+ * @param {String} url 
+ * @param {Object} headers 
+ * @param {Object} query 
+ * @param {Object} body 
+ * @param {String} requestId 
+ * @param {Boolean} shouldTimeOut - Defaults to false
+ * @param {Number} timeout - in seconds, Defaults to 10 seconds
+ * @param {Function} responseHandler - Caller should pass it's own http response handler. Defaults to playo's response function handler
+ */
+const remove = async (url, headers = {}, query = {}, body, requestId = '', responseHandler = playoResponseHandler, timeout = TIMEOUT_DURATION) => {
+    try {
+        const options = { headers, params: query, data: body, timeout };
+        const resp = await Axios.delete(url, options);
+        return responseHandler(resp, requestId);
+    } catch (error) {
+        Logger.prepareErrorLog(requestId, { url, headers, query, body }, `Api call to url to ${url} failed due to ${error.response.message}`);
+        return responseHandler(error.response, requestId, apiName);
+    }
+};
+
+module.exports = {
+    get,
+    post,
+    put,
+    remove
 }

package/lib/playo.utils/playo.res.generator.js

@@ -1,59 +1,59 @@
-// these file's functionality should be in utils.js file 
-const httpStatusMap = {
-    'OK': 200,
-    'BAD_REQUEST': 400,
-    'URL_NOT_FOUND': 404,
-    'INTERNAL_ERROR': 500,
-};
-
-const responseStatusMessageMap = {
-    1: "Success",
-    0: "Failed",
-    2: "Invalid Request",
-    3: "warning",
-}
-
-/**
- * Function to generate dynamic playo response
- * @typedef {"OK" | "BAD_REQUEST" | "URL_NOT_FOUND" | "INTERNAL_ERROR" } httpMessage
- * @typedef {0 | 1 | 2 | 3} requestStatus
- * @param {httpMessage} httpMessage ['OK', 'BAD_REQUEST', 'URL_NOT_FOUND', 'INTERNAL_ERROR']
- * @param {requestStatus} requestStatus [0, 1, 2, 3]
- * @param {Object} jsonData 
- * @param {String} customMessage 
- * @returns {Object} - 
- * {
- *    httpStatus: 200,
- *    httpMessage: 'Ok',
- *    playoResponse: {
- *          requestStatus: 1,
- *          message: "Success",
- *          data: {}
- *     }
- * }
- */
-const generatePlayoResponse = (httpMessage = 'Ok', requestStatus = 1, jsonData = {}, customMessage = null, addOnJson = {}) => {
-
-    const httpStatus = httpStatusMap[httpMessage] || 200;
-
-    const playoResponse = {
-        requestStatus,
-        message: responseStatusMessageMap[requestStatus] || "Success",
-        data: jsonData,
-        ...addOnJson
-    }
-
-    if (customMessage) {
-        playoResponse.message = customMessage;
-    }
-
-    return {
-        httpStatus,
-        httpMessage,
-        playoResponse
-    }
-}
-
-module.exports = {
-    generatePlayoResponse
+// these file's functionality should be in utils.js file 
+const httpStatusMap = {
+    'OK': 200,
+    'BAD_REQUEST': 400,
+    'URL_NOT_FOUND': 404,
+    'INTERNAL_ERROR': 500,
+};
+
+const responseStatusMessageMap = {
+    1: "Success",
+    0: "Failed",
+    2: "Invalid Request",
+    3: "warning",
+}
+
+/**
+ * Function to generate dynamic playo response
+ * @typedef {"OK" | "BAD_REQUEST" | "URL_NOT_FOUND" | "INTERNAL_ERROR" } httpMessage
+ * @typedef {0 | 1 | 2 | 3} requestStatus
+ * @param {httpMessage} httpMessage ['OK', 'BAD_REQUEST', 'URL_NOT_FOUND', 'INTERNAL_ERROR']
+ * @param {requestStatus} requestStatus [0, 1, 2, 3]
+ * @param {Object} jsonData 
+ * @param {String} customMessage 
+ * @returns {Object} - 
+ * {
+ *    httpStatus: 200,
+ *    httpMessage: 'Ok',
+ *    playoResponse: {
+ *          requestStatus: 1,
+ *          message: "Success",
+ *          data: {}
+ *     }
+ * }
+ */
+const generatePlayoResponse = (httpMessage = 'Ok', requestStatus = 1, jsonData = {}, customMessage = null, addOnJson = {}) => {
+
+    const httpStatus = httpStatusMap[httpMessage] || 200;
+
+    const playoResponse = {
+        requestStatus,
+        message: responseStatusMessageMap[requestStatus] || "Success",
+        data: jsonData,
+        ...addOnJson
+    }
+
+    if (customMessage) {
+        playoResponse.message = customMessage;
+    }
+
+    return {
+        httpStatus,
+        httpMessage,
+        playoResponse
+    }
+}
+
+module.exports = {
+    generatePlayoResponse
 }

package/lib/profanityFilter/profanityFilter.js

@@ -1,16 +1,15 @@
-const { profanityWords } = require("./profanityWords");
-const Filter = require("bad-words");
-const profanityFilter = new Filter();
-const profanityWordList = profanityWords.split(",");
-
-const excludeWords = ["dink", "dings", "swastik", "swastika", "islam"];
-
-profanityFilter.addWords(...profanityWordList);
-profanityFilter.removeWords(...excludeWords);
-
-const checkProfanity = (message) => {
-  return profanityFilter.isProfane(message);
-};
-
-module.exports = { checkProfanity };
-
+const {profanityWords} = require("./profanityWords");
+const Filter = require("bad-words");
+const profanityFilter = new Filter(); 
+const profanityWordList = profanityWords.split(",");
+
+const excludeWords = ['swastik', 'swastika', 'islam'];
+
+profanityFilter.addWords(...profanityWordList);
+profanityFilter.removeWords(...excludeWords)
+
+const checkProfanity = (message) => {
+    return profanityFilter.isProfane(message);
+}
+
+module.exports = { checkProfanity }