playov2-js-utilities 0.3.52 → 0.3.54

package/lib/index.js

@@ -13,5 +13,8 @@ module.exports = {
     MessagePublisher: require('./message_publisher'),
     middleware: require('./middleware'),
     profanityFilter: require("./profanityFilter/profanityFilter"),
-    playoResponseHandler: require("./responseHandler/responseHandler")
+    playoResponseHandler: require("./responseHandler/responseHandler"),
+    PLAYO_ERROR_HANDLER: require("./playo.utils/playo.error.handler"),
+    PLAYO_HTTP_HANDLER: require("./playo.utils/playo.http.handler"),
+    PLAYO_RESPONSE_GENERATOR: require("./playo.utils/playo.res.generator"),
 };

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

@@ -0,0 +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, {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

@@ -0,0 +1,148 @@
+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.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, 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
+    }
+
+    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, data: error.response }, `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, data: error.response.data }, `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, data: error.response.data }, `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, data: error.response.data }, `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

@@ -0,0 +1,58 @@
+// 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) => {
+    
+    const httpStatus = httpStatusMap[httpMessage] || 200;
+    
+    const playoResponse = {
+        requestStatus,
+        message: responseStatusMessageMap[requestStatus] || "Success",
+        data: jsonData
+    }
+
+    if(customMessage) {
+        playoResponse.message = customMessage;
+    }
+
+    return {
+        httpStatus,
+        httpMessage,
+        playoResponse
+    }
+}
+
+module.exports = {
+    generatePlayoResponse
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playov2-js-utilities",
-  "version": "0.3.52",
+  "version": "0.3.54",
   "description": "Private package for JS utility functions",
   "main": "index.js",
   "scripts": {
@@ -13,7 +13,7 @@
   "keywords": [
     "Playo"
   ],
-  "author": "Saurabh Agrawal",
+  "author": "Avish", 
   "license": "ISC",
   "homepage": "https://bitbucket.org/techmash/playov2-js-utilities#readme",
   "devDependencies": {