@itentialopensource/adapter-utils 5.6.0 → 5.7.0

package/CHANGELOG.md

@@ -1,4 +1,12 @@
 
+## 5.7.0 [08-21-2024]
+
+* Update gzip logic
+
+See merge request itentialopensource/adapter-utils!297
+
+---
+
 ## 5.6.0 [07-31-2024]
 
 * Add abilities to refresh token and set msa query

package/lib/connectorRest.js

@@ -780,34 +780,61 @@ function makeRequest(request, entitySchema, callProperties, startTrip, attempt,
     // make the call to System
     const httpRequest = useProt.request(request.header, (res) => {
       let respStr = '';
-      res.setEncoding('utf8');
-
+      if (res.headers['content-encoding'] !== 'gzip') {
+        res.setEncoding('utf8');
+      }
+      const chunks = [];
       // process data from response
       res.on('data', (replyData) => {
+        chunks.push(replyData);
         respStr += replyData;
       });
 
       // process end of response
       res.on('end', () => {
+        let buffer = '';
+        if (res.headers['content-encoding'] === 'gzip') {
+          buffer = Buffer.concat(chunks);
+        }
+
         const tripDiff = process.hrtime(roundTTime);
         const tripEnd = `${Math.round(((tripDiff[0] * NS_PER_SEC) + tripDiff[1]) / 1000000)}ms`;
-        const callResp = {
-          status: 'success',
-          code: res.statusCode,
-          headers: res.headers,
-          response: respStr,
-          request: {
-            protocol: protStr,
-            host: request.header.hostname,
-            port: request.header.port,
-            uri: request.header.path,
-            method: request.header.method,
-            payload: request.body
-          },
-          redirects: attempt,
-          tripTime: tripEnd
-        };
-
+        let callResp = {};
+        if (res.headers['content-encoding'] === 'gzip') {
+          callResp = {
+            status: 'success',
+            code: res.statusCode,
+            headers: res.headers,
+            response: buffer,
+            request: {
+              protocol: protStr,
+              host: request.header.hostname,
+              port: request.header.port,
+              uri: request.header.path,
+              method: request.header.method,
+              payload: request.body
+            },
+            redirects: attempt,
+            tripTime: tripEnd
+          };
+        } else {
+          callResp = {
+            status: 'success',
+            code: res.statusCode,
+            headers: res.headers,
+            response: respStr,
+            request: {
+              protocol: protStr,
+              host: request.header.hostname,
+              port: request.header.port,
+              uri: request.header.path,
+              method: request.header.method,
+              payload: request.body
+            },
+            redirects: attempt,
+            tripTime: tripEnd
+          };
+        }
         // if there was a cookie or biscotti returned, need to set cookie on the new request
         if (request.header.headers) {
           const headKeys = Object.keys(request.header.headers);

package/lib/propertyUtil.js

@@ -534,8 +534,8 @@ class AdapterPropertyUtil {
       }
       if (entitySchema.responseDatatype.toUpperCase() !== 'JSON' && entitySchema.responseDatatype.toUpperCase() !== 'XML'
         && entitySchema.responseDatatype.toUpperCase() !== 'URLENCODE' && entitySchema.responseDatatype.toUpperCase() !== 'XML2JSON'
-        && entitySchema.requestDatatype.toUpperCase() !== 'GZIP2XML2JSON' && entitySchema.requestDatatype.toUpperCase() !== 'GZIP2XML'
-        && entitySchema.requestDatatype.toUpperCase() !== 'GZIP2JSON') {
+        && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2XML2JSON' && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2XML'
+        && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2JSON' && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2PLAIN') {
         entitySchema.responseDatatype = 'PLAIN';
       }
 
@@ -952,7 +952,9 @@ class AdapterPropertyUtil {
           entitySchema.requestDatatype = 'PLAIN';
         }
         if (entitySchema.responseDatatype.toUpperCase() !== 'JSON' && entitySchema.responseDatatype.toUpperCase() !== 'XML'
-          && entitySchema.responseDatatype.toUpperCase() !== 'URLENCODE' && entitySchema.responseDatatype.toUpperCase() !== 'XML2JSON') {
+          && entitySchema.responseDatatype.toUpperCase() !== 'URLENCODE' && entitySchema.responseDatatype.toUpperCase() !== 'XML2JSON'
+        && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2XML2JSON' && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2XML'
+        && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2JSON' && entitySchema.responseDatatype.toUpperCase() !== 'GZIP2PLAIN') {
           entitySchema.responseDatatype = 'PLAIN';
         }
 

package/lib/restHandler.js

@@ -8,7 +8,7 @@ const querystring = require('querystring');
 const jsonQuery = require('json-query');
 const jsonxml = require('jsontoxml');
 const xml2js = require('xml2js');
-const pako = require('pako');
+const zlib = require('zlib');
 
 const globalSchema = JSON.parse(require('fs').readFileSync(require('path').join(__dirname, '/../schemas/globalSchema.json')));
 
@@ -53,19 +53,6 @@ function matchResponse(uriPath, method, type, mockresponses) {
   return null;
 }
 
-/*
- * INTERNAL FUNCTION: Parse XML
- */
-function parseXML(xmlString, callback) {
-  const parser = new xml2js.Parser({ explicitArray: false, attrkey: '_attr' });
-  parser.parseString(xmlString, (error, result) => {
-    if (error) {
-      return callback(error);
-    }
-    return callback(null, result);
-  });
-}
-
 /*
  * INTERNAL FUNCTION: recursively inspect body data if heirarchical
  */
@@ -491,62 +478,58 @@ function handleRestRequest(request, entityId, entitySchema, callProperties, filt
       if (entitySchema && entitySchema.responseDatatype && entitySchema.responseDatatype.toUpperCase() === 'URLENCODE') {
         // return the response
         retResponse = querystring.parse(resObj.response.trim());
-      } else if (entitySchema && entitySchema.responseDatatype && (entitySchema.responseDatatype.toUpperCase() === 'GZIP2PLAIN'
-          || entitySchema.responseDatatype.toUpperCase() === 'GZIP2JSON' || entitySchema.responseDatatype.toUpperCase() === 'GZIP2XML'
-          || entitySchema.responseDatatype.toUpperCase() === 'GZIP2XML2JSON')) {
-        // If response is GZIP
+      } if (entitySchema && entitySchema.responseDatatype
+        && ['GZIP2PLAIN', 'GZIP2JSON', 'GZIP2XML', 'GZIP2XML2JSON'].includes(entitySchema.responseDatatype.toUpperCase())) {
         const responseDatatype = entitySchema.responseDatatype.toUpperCase();
-        const responseBody = pako.inflate(Buffer.from(resObj.response, 'binary'), { to: 'string' });
-        // Handle conversion based on responseDatatype
-        if (responseDatatype === 'GZIP2PLAIN') {
-          retObject.response = responseBody;
-        } else if (responseDatatype === 'GZIP2JSON') {
-          // Parse responseBody as JSON
-          retObject.response = JSON.parse(responseBody);
-        } else if (responseDatatype === 'GZIP2XML' || responseDatatype === 'GZIP2XML2JSON') {
-          parseXML(responseBody, (error, xmlResult) => {
-            if (error) {
-              log.warn(`${origin}: Error parsing XML response: ${error}`);
+
+        return zlib.gunzip(resObj.response, (err, unzipresponse) => {
+          if (err) {
+            log.warn(`${origin}: Error inflating gzip response: ${err}`);
+            return callback(retObject);
+          }
+
+          const responseBody = unzipresponse.toString('utf8'); // Convert buffer to string
+          if (responseDatatype === 'GZIP2PLAIN') {
+            retObject.response = responseBody;
+            log.debug(`${origin}: RESPONSE: ${retObject.response}`);
+            return callback(retObject);
+          } if (responseDatatype === 'GZIP2JSON') {
+            try {
+              retObject.response = JSON.parse(responseBody);
+              log.debug(`${origin}: RESPONSE: ${retObject.response}`);
+              return callback(retObject); // Parse responseBody as JSON
+            } catch (jsonErr) {
+              log.warn(`${origin}: Error parsing JSON response: ${jsonErr}`);
               return callback(retObject);
             }
-
-            retObject.response = xmlResult;
-
-            if (responseDatatype === 'GZIP2XML2JSON') {
-              // Optionally convert XML to JSON
-              try {
-                const parser = new xml2js.Parser({ explicitArray: false, attrkey: '_attr' });
-                return parser.parseString(xmlResult, (err, result) => {
-                  if (err) {
-                    log.warn(`${origin}: Unable to parse xml to json ${err}`);
-                    return callback(retObject);
-                  }
-                  // Logic to convert keys specified to array if object
-                  if (xmlArrayKeys) {
-                    setArrays(result, xmlArrayKeys);
-                  }
-                  retObject.response = result;
-                  return callback(retObject);
-                });
-              } catch (ex) {
-                log.warn(`${origin}: Unable to get json from xml ${ex}`);
+          } else if (responseDatatype === 'GZIP2XML' || responseDatatype === 'GZIP2XML2JSON') {
+            xml2js.parseString(responseBody, { explicitArray: false, attrkey: '_attr' }, (xmlErr, xmlResult) => {
+              if (xmlErr) {
+                log.warn(`${origin}: Error parsing XML response: ${xmlErr}`);
                 return callback(retObject);
               }
-            }
 
-            log.debug(`${origin}: RESPONSE: ${retObject.response}`);
-            return callback(retObject);
-          });
-        }
-      } else {
-        // process the response - parse it
-        try {
-          retResponse = JSON.parse(resObj.response.trim());
-        } catch (ex) {
-          // otherwise log parse failure and return the unparsed response
-          log.warn(`${origin}: An error occurred parsing the resulting JSON: ${ex}: Actual Response is: ${resObj}`);
+              retObject.response = xmlResult;
+
+              if (responseDatatype === 'GZIP2XML2JSON') {
+              // Optionally convert XML to JSON, already done above by xml2js
+                if (xmlArrayKeys) {
+                  setArrays(retObject.response, xmlArrayKeys); // Handle array conversion
+                }
+              }
+              return callback(retObject);
+            });
+          }
           return callback(retObject);
-        }
+        });
+      }
+      // process the response - parse it
+      try {
+        retResponse = JSON.parse(resObj.response.trim());
+      } catch (ex) {
+        // otherwise log parse failure and return the unparsed response
+        log.warn(`${origin}: An error occurred parsing the resulting JSON: ${ex}: Actual Response is: ${resObj}`);
+        return callback(retObject);
       }
 
       // Make the call to translate the received Entity to Pronghorn Entity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itentialopensource/adapter-utils",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "description": "Itential Adapter Utility Libraries",
   "scripts": {
     "postinstall": "node utils/setup.js",
@@ -39,12 +39,12 @@
     "jsontoxml": "^1.0.1",
     "jsonwebtoken": "^9.0.1",
     "mongodb": "^3.7.4",
-    "pako": "^2.1.0",
     "querystring": "^0.2.0",
     "readline-sync": "^1.4.10",
     "socks-proxy-agent": "^8.0.1",
     "uuid": "^9.0.0",
-    "xml2js": "^0.6.0"
+    "xml2js": "^0.6.0",
+    "zlib": "^1.0.5"
   },
   "devDependencies": {
     "chai": "^4.3.7",