@itentialopensource/adapter-utils 4.48.0 → 4.48.2

package/CHANGELOG.md

@@ -1,4 +1,24 @@
 
+## 4.48.2 [10-04-2022]
+
+* Changes to have token data passed in url instead of body
+
+Closes ADAPT-2404
+
+See merge request itentialopensource/adapter-utils!239
+
+---
+
+## 4.48.1 [09-22-2022]
+
+* Add capability to send base64 and buffer in formData
+
+Closes ADAPT-2380
+
+See merge request itentialopensource/adapter-utils!238
+
+---
+
 ## 4.48.0 [08-16-2022]
 
 * Changes to support entitypath object with multiple paths

package/lib/connectorRest.js

@@ -255,11 +255,11 @@ function matchMock(uriPath, method, type, mockresponses, respDatatype) {
   for (let p = 0; p < mockresponses.length; p += 1) {
     // is this the mock data for this call
     if (Object.hasOwnProperty.call(mockresponses[p], 'name')
-        && uriPath === mockresponses[p].name) {
+      && uriPath === mockresponses[p].name) {
       if (Object.hasOwnProperty.call(mockresponses[p], 'method')
-          && method.toUpperCase() === mockresponses[p].method.toUpperCase()) {
+        && method.toUpperCase() === mockresponses[p].method.toUpperCase()) {
         if (Object.hasOwnProperty.call(mockresponses[p], 'type')
-            && type.toUpperCase() === mockresponses[p].type.toUpperCase()) {
+          && type.toUpperCase() === mockresponses[p].type.toUpperCase()) {
           // This is the mock data we really want as it best matches the request
           const specificResp = {
             status: 'success',
@@ -270,7 +270,7 @@ function matchMock(uriPath, method, type, mockresponses, respDatatype) {
           if (Object.hasOwnProperty.call(mockresponses[p], 'response')) {
             // if a status is defined in the response, use it
             if (Object.hasOwnProperty.call(mockresponses[p].response, 'response')
-                && Object.hasOwnProperty.call(mockresponses[p].response, 'status')) {
+              && Object.hasOwnProperty.call(mockresponses[p].response, 'status')) {
               specificResp.code = mockresponses[p].response.status;
 
               if (respDatatype && respDatatype.toUpperCase() === 'XML2JSON') {
@@ -396,7 +396,7 @@ function returnStub(request, entitySchema, callProperties) {
 
   // if there is a request body, see if there is something that matches a specific input
   if (reqBody && (!entitySchema || !entitySchema.requestDatatype
-      || entitySchema.requestDatatype.toUpperCase() === 'JSON' || entitySchema.requestDatatype.toUpperCase() === 'URLENCODE')) {
+    || entitySchema.requestDatatype.toUpperCase() === 'JSON' || entitySchema.requestDatatype.toUpperCase() === 'URLENCODE')) {
     let reqBdObj = null;
     if (entitySchema && entitySchema.requestDatatype && entitySchema.requestDatatype.toUpperCase() === 'URLENCODE') {
       reqBdObj = querystring.parse(reqBody.trim());
@@ -661,38 +661,60 @@ function makeRequest(request, entitySchema, callProperties, startTrip, attempt,
       }
       // add the data for each field into the form
       const mykeys = Object.keys(mybody);
-      for (let k = 0; k < mykeys.length; k += 1) {
-        if (mykeys[k] === 'file') {
-          let fileVal = mybody[mykeys[k]];
-          if (fileVal.indexOf('@') === 0) {
-            // if there are multiple parts - first part is file, other part can be name
-            const filePart = fileVal.split(';');
-            let fileName = null;
-            fileVal = fs.readFileSync(`node_modules/@itentialopensource/adapter-forwardnetworks/uploads/${filePart[0].substring(1)}`);
-
-            // see if we have a filename that we should add to the formdata
-            for (let p = 1; p < filePart.length; p += 1) {
-              if (filePart[p].indexOf('name=') === 0) {
-                fileName = filePart[p].substring(5);
+      if (mykeys.length === 2 && mykeys[0] === 'file' && mykeys[1] === 'convertBase64ToBuffer') {
+        const filePart = mybody[mykeys[0]].split(';');
+        let fileName = null;
+        // see if we have a filename that we should add to the formdata
+        for (let p = 1; p < filePart.length; p += 1) {
+          if (filePart[p].indexOf('name=') === 0) {
+            fileName = filePart[p].substring(5);
+          }
+        }
+        if (mybody.convertBase64ToBuffer === true) {
+          let fileBuffer = filePart[filePart.length - 1];
+          if (filePart[filePart.length - 1].startsWith('base64')) {
+            fileBuffer = Buffer.from(filePart[filePart.length - 1].substring(7), 'base64');
+          }
+          log.debug(`APPENDING: ${mykeys[0]}, WITH VALUE ${fileBuffer}, AND NAME ${fileName}`);
+          formData.append(mykeys[0], fileBuffer, fileName);
+        } else {
+          log.debug(`APPENDING: ${mykeys[0]}, WITH VALUE ${filePart[filePart.length - 1]}, AND NAME ${fileName}`);
+          formData.append(mykeys[0], filePart[filePart.length - 1], fileName);
+        }
+      } else {
+        for (let k = 0; k < mykeys.length; k += 1) {
+          if (mykeys[k] === 'file') {
+            let fileVal = mybody[mykeys[k]];
+            if (fileVal.indexOf('@') === 0) {
+              // if there are multiple parts - first part is file, other part can be name
+              const filePart = fileVal.split(';');
+              let fileName = null;
+              fileVal = fs.readFileSync(`node_modules/@itentialopensource/adapter-forwardnetworks/uploads/${filePart[0].substring(1)}`);
+
+              // see if we have a filename that we should add to the formdata
+              for (let p = 1; p < filePart.length; p += 1) {
+                if (filePart[p].indexOf('name=') === 0) {
+                  fileName = filePart[p].substring(5);
+                }
+              }
+              if (fileName) {
+                // with filename
+                log.debug(`APPENDING: ${mykeys[k]}, WITH VALUE ${fileVal}, AND NAME ${fileName}`);
+                formData.append(mykeys[k], fileVal, fileName);
+              } else {
+                // with read in file but no file name
+                log.debug(`APPENDING: ${mykeys[k]}, WITH VALUE ${fileVal}`);
+                formData.append(mykeys[k], fileVal);
               }
-            }
-            if (fileName) {
-              // with filename
-              log.debug(`APPENDING: ${mykeys[k]}, WITH VALUE ${fileVal}, AND NAME ${fileName}`);
-              formData.append(mykeys[k], fileVal, fileName);
             } else {
-              // with read in file but no file name
+              // no file or file name just contents - original
               log.debug(`APPENDING: ${mykeys[k]}, WITH VALUE ${fileVal}`);
               formData.append(mykeys[k], fileVal);
             }
           } else {
-            // no file or file name just contents - original
-            log.debug(`APPENDING: ${mykeys[k]}, WITH VALUE ${fileVal}`);
-            formData.append(mykeys[k], fileVal);
+            log.debug(`APPENDING: ${mykeys[k]}, WITH VALUE ${mybody[mykeys[k]]}`);
+            formData.append(mykeys[k], mybody[mykeys[k]]);
           }
-        } else {
-          log.debug(`APPENDING: ${mykeys[k]}, WITH VALUE ${mybody[mykeys[k]]}`);
-          formData.append(mykeys[k], mybody[mykeys[k]]);
         }
       }
       // get the new headers
@@ -888,7 +910,7 @@ function makeRequest(request, entitySchema, callProperties, startTrip, attempt,
 
     // write to the http request data to the body if not a get (gets do not have data in the body)
     if ((request.header.method !== 'GET' || entitySchema.sendGetBody)
-        && ((typeof request.body === 'object' && Object.keys(request.body).length > 0)
+      && ((typeof request.body === 'object' && Object.keys(request.body).length > 0)
         || (typeof request.body === 'string' && request.body !== '{}') || entitySchema.sendEmpty)) {
       if (entitySchema.requestDatatype.toUpperCase() === 'FORM') {
         // pass the formData to the request
@@ -1205,7 +1227,7 @@ function getToken(reqPath, options, tokenSchema, bodyString, callProperties, cal
 
       // process primary token from header
       if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.token
-          && tokenSchema.responseSchema.properties.token.placement && tokenSchema.responseSchema.properties.token.placement.toUpperCase() === 'HEADER') {
+        && tokenSchema.responseSchema.properties.token.placement && tokenSchema.responseSchema.properties.token.placement.toUpperCase() === 'HEADER') {
         if (!tokenSchema.responseSchema.properties.token.external_name) {
           const errorObj = transUtilInst.formatErrorObject(origin, 'Unable To Get Primary Token', ['Primary Token', result.code], null, null, null);
           log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
@@ -1794,7 +1816,7 @@ function buildTokenRequest(reqPath, reqBody, callProperties, callback) {
 
       // only add global options if there are global options to add
       if (globalRequest && globalRequest.uriOptions
-          && Object.keys(globalRequest.uriOptions).length > 0) {
+        && Object.keys(globalRequest.uriOptions).length > 0) {
         const optionString = querystring.stringify(globalRequest.uriOptions);
 
         // if no query paramters yet - start with ?
@@ -1966,6 +1988,17 @@ function buildTokenRequest(reqPath, reqBody, callProperties, callback) {
             bodyString = JSON.stringify(tokenEntity);
           } else if (tokenSchema.requestDatatype && tokenSchema.requestDatatype.toUpperCase() === 'URLENCODE') {
             bodyString = querystring.stringify(tokenEntity);
+          } else if (tokenSchema.requestDatatype && tokenSchema.requestDatatype.toUpperCase() === 'URLQUERY') {
+            // if the datatype is URLQUERY need to put into the query on the request
+            bodyString = querystring.stringify(tokenEntity);
+
+            // append to the path
+            if (options.path.indexOf('?') < 0) {
+              options.path = `${options.path}?${bodyString}`;
+            } else {
+              options.path = `${options.path}&${bodyString}`;
+            }
+            bodyString = '{}';
           }
 
           // if there is a body, set the content length of the body and add it to
@@ -2106,7 +2139,7 @@ function validToken(user, reqBody, invalidToken, callback) {
         // if the token expired (or will expire within a minute),
         // or it is invalid (failed) remove it from the token list
         if (tokenList[i].expire < expireCheck
-            || tokenList[i].token.token === invalidToken) {
+          || tokenList[i].token.token === invalidToken) {
           tokenList.splice(i, 1);
           break;
         }
@@ -2820,7 +2853,7 @@ function handleEndThrottleResponse(request, myTransTime, claimedLic, makeResp, r
 
       // If the request was successful
       if (makeResp !== null && makeResp.code !== undefined
-          && Number(makeResp.code) >= 200 && Number(makeResp.code) <= 299) {
+        && Number(makeResp.code) >= 200 && Number(makeResp.code) <= 299) {
         const newResp = {
           icode: `AD.${makeResp.code}`,
           response: makeResp.response,
@@ -2919,7 +2952,7 @@ function retryInvalidResponse(request, callProperties, myTransTime, claimedLic,
       let retries = numRetries;
       if (callProperties && callProperties.request && callProperties.request.limit_retry_error) {
         if (typeof callProperties.request.limit_retry_error === 'number'
-            || typeof callProperties.request.limit_retry_error === 'string') {
+          || typeof callProperties.request.limit_retry_error === 'string') {
           retryError = [Number(callProperties.request.limit_retry_error)];
         } else if (Array.isArray(callProperties.request.limit_retry_error)) {
           retryError = [];
@@ -2927,10 +2960,10 @@ function retryInvalidResponse(request, callProperties, myTransTime, claimedLic,
             if (typeof callProperties.request.limit_retry_error[l] === 'number') {
               retryError.push(Number(callProperties.request.limit_retry_error[l]));
             } else if (typeof callProperties.request.limit_retry_error[l] === 'string'
-                && callProperties.request.limit_retry_error[l].indexOf('-') < 0) {
+              && callProperties.request.limit_retry_error[l].indexOf('-') < 0) {
               retryError.push(Number(callProperties.request.limit_retry_error[l]));
             } else if (typeof callProperties.request.limit_retry_error[l] === 'string'
-                && callProperties.request.limit_retry_error[l].indexOf('-') >= 0) {
+              && callProperties.request.limit_retry_error[l].indexOf('-') >= 0) {
               const srange = Number(callProperties.request.limit_retry_error[l].split('-')[0]);
               const erange = Number(callProperties.request.limit_retry_error[l].split('-')[1]);
               for (let r = srange; r <= erange; r += 1) {
@@ -2947,7 +2980,7 @@ function retryInvalidResponse(request, callProperties, myTransTime, claimedLic,
       // if the response is valid - good data or legitimate data error
       // stop trying if we have tried enough
       if (numTries > retries || (mres !== null && mres.code !== undefined && !retryError.includes(Number(mres.code))
-          && (authMethod !== 'request_token' || Number(mres.code) !== Number(tokenError)))) {
+        && (authMethod !== 'request_token' || Number(mres.code) !== Number(tokenError)))) {
         const newresp = mres;
         newresp.retries = numTries;
 
@@ -3083,7 +3116,7 @@ function noQueueRequest(request, callProperties, overallTime, entitySchema, call
       let retries = numRetries;
       if (callProperties && callProperties.request && callProperties.request.limit_retry_error) {
         if (typeof callProperties.request.limit_retry_error === 'number'
-            || typeof callProperties.request.limit_retry_error === 'string') {
+          || typeof callProperties.request.limit_retry_error === 'string') {
           retryError = [Number(callProperties.request.limit_retry_error)];
         } else if (Array.isArray(callProperties.request.limit_retry_error)) {
           retryError = [];
@@ -3091,10 +3124,10 @@ function noQueueRequest(request, callProperties, overallTime, entitySchema, call
             if (typeof callProperties.request.limit_retry_error[l] === 'number') {
               retryError.push(Number(callProperties.request.limit_retry_error[l]));
             } else if (typeof callProperties.request.limit_retry_error[l] === 'string'
-                && callProperties.request.limit_retry_error[l].indexOf('-') < 0) {
+              && callProperties.request.limit_retry_error[l].indexOf('-') < 0) {
               retryError.push(Number(callProperties.request.limit_retry_error[l]));
             } else if (typeof callProperties.request.limit_retry_error[l] === 'string'
-                && callProperties.request.limit_retry_error[l].indexOf('-') >= 0) {
+              && callProperties.request.limit_retry_error[l].indexOf('-') >= 0) {
               const srange = Number(callProperties.request.limit_retry_error[l].split('-')[0]);
               const erange = Number(callProperties.request.limit_retry_error[l].split('-')[1]);
               for (let r = srange; r <= erange; r += 1) {
@@ -3110,14 +3143,14 @@ function noQueueRequest(request, callProperties, overallTime, entitySchema, call
 
       // if invalid token, handle that and retry
       if (mres !== null && mres.code !== undefined && Number(mres.code) === Number(tokenError)
-          && authMethod === 'request_token') {
+        && authMethod === 'request_token') {
         // if we took an invalid token - try one more time
         return handleInvalidToken(request, callProperties, 0, { request_id: 0 }, mres, overallTime, overallTime, 0, 1, entitySchema, callback);
       }
 
       // if the response is valid - good data or legitimate data error
       if (retries < 1 || (mres !== null && mres.code !== undefined && !retryError.includes(Number(mres.code))
-          && (authMethod !== 'request_token' || Number(mres.code) !== Number(tokenError)))) {
+        && (authMethod !== 'request_token' || Number(mres.code) !== Number(tokenError)))) {
         return handleEndResponse(request, mres, overallTime, callback);
       }
 
@@ -3182,7 +3215,7 @@ function queueThrottleRequest(request, callProperties, myRequestId, myTransTime,
           let retries = numRetries;
           if (callProperties && callProperties.request && callProperties.request.limit_retry_error) {
             if (typeof callProperties.request.limit_retry_error === 'number'
-                || typeof callProperties.request.limit_retry_error === 'string') {
+              || typeof callProperties.request.limit_retry_error === 'string') {
               retryError = [Number(callProperties.request.limit_retry_error)];
             } else if (Array.isArray(callProperties.request.limit_retry_error)) {
               retryError = [];
@@ -3190,10 +3223,10 @@ function queueThrottleRequest(request, callProperties, myRequestId, myTransTime,
                 if (typeof callProperties.request.limit_retry_error[l] === 'number') {
                   retryError.push(Number(callProperties.request.limit_retry_error[l]));
                 } else if (typeof callProperties.request.limit_retry_error[l] === 'string'
-                    && callProperties.request.limit_retry_error[l].indexOf('-') < 0) {
+                  && callProperties.request.limit_retry_error[l].indexOf('-') < 0) {
                   retryError.push(Number(callProperties.request.limit_retry_error[l]));
                 } else if (typeof callProperties.request.limit_retry_error[l] === 'string'
-                    && callProperties.request.limit_retry_error[l].indexOf('-') >= 0) {
+                  && callProperties.request.limit_retry_error[l].indexOf('-') >= 0) {
                   const srange = Number(callProperties.request.limit_retry_error[l].split('-')[0]);
                   const erange = Number(callProperties.request.limit_retry_error[l].split('-')[1]);
                   for (let r = srange; r <= erange; r += 1) {
@@ -3209,14 +3242,14 @@ function queueThrottleRequest(request, callProperties, myRequestId, myTransTime,
 
           // if invalid token, handle that and retry
           if (mres !== null && mres.code !== undefined && Number(mres.code) === Number(tokenError)
-              && authMethod === 'request_token') {
+            && authMethod === 'request_token') {
             // if we took an invalid token - try one more time
             return handleInvalidToken(request, callProperties, myTransTime, claimedLic, mres, reqTime, overallTime, waitEnd, 1, entitySchema, callback);
           }
 
           // if the response is valid - good data or legitimate data error
           if (retries < 1 || (mres !== null && mres.code !== undefined && !retryError.includes(Number(mres.code))
-              && (authMethod !== 'request_token' || Number(mres.code) !== Number(tokenError)))) {
+            && (authMethod !== 'request_token' || Number(mres.code) !== Number(tokenError)))) {
             return handleEndThrottleResponse(request, myTransTime, claimedLic, mres, reqTime, overallTime, waitEnd, callback);
           }
 
@@ -3366,13 +3399,13 @@ class ConnectorRest {
 
       // set the invalid token error (optional - default is null)
       if (typeof props.authentication.invalid_token_error === 'number'
-          || typeof props.authentication.invalid_token_error === 'string') {
+        || typeof props.authentication.invalid_token_error === 'string') {
         tokenError = Number(props.authentication.invalid_token_error);
       }
 
       // set the token timeout (optional - default is null)
       if (typeof props.authentication.token_timeout === 'number'
-          || typeof props.authentication.token_timeout === 'string') {
+        || typeof props.authentication.token_timeout === 'string') {
         tokenTimeout = Number(props.authentication.token_timeout);
       }
 
@@ -3453,19 +3486,19 @@ class ConnectorRest {
     if (props.request) {
       // set the number of redirects (optional - default is 0)
       if (typeof props.request.number_redirects === 'number'
-          || typeof props.request.number_redirects === 'string') {
+        || typeof props.request.number_redirects === 'string') {
         numRedirects = Number(props.request.number_redirects);
       }
 
       // set the number of retries (optional - default is 3)
       if (typeof props.request.number_retries === 'number'
-          || typeof props.request.number_retries === 'string') {
+        || typeof props.request.number_retries === 'string') {
         numRetries = Number(props.request.number_retries);
       }
 
       // set the request retry error (optional - default is 0)
       if (typeof props.request.limit_retry_error === 'number'
-          || typeof props.request.limit_retry_error === 'string') {
+        || typeof props.request.limit_retry_error === 'string') {
         limitRetryError = [Number(props.request.limit_retry_error)];
       } else if (Array.isArray(props.request.limit_retry_error)) {
         limitRetryError = [];
@@ -3473,10 +3506,10 @@ class ConnectorRest {
           if (typeof props.request.limit_retry_error[l] === 'number') {
             limitRetryError.push(Number(props.request.limit_retry_error[l]));
           } else if (typeof props.request.limit_retry_error[l] === 'string'
-              && props.request.limit_retry_error[l].indexOf('-') < 0) {
+            && props.request.limit_retry_error[l].indexOf('-') < 0) {
             limitRetryError.push(Number(props.request.limit_retry_error[l]));
           } else if (typeof props.request.limit_retry_error[l] === 'string'
-              && props.request.limit_retry_error[l].indexOf('-') >= 0) {
+            && props.request.limit_retry_error[l].indexOf('-') >= 0) {
             const srange = Number(props.request.limit_retry_error[l].split('-')[0]);
             const erange = Number(props.request.limit_retry_error[l].split('-')[1]);
             for (let r = srange; r <= erange; r += 1) {
@@ -3488,7 +3521,7 @@ class ConnectorRest {
 
       // set the request attempt timeout (optional - default is 5000)
       if (typeof props.request.attempt_timeout === 'number'
-          || typeof props.request.attempt_timeout === 'string') {
+        || typeof props.request.attempt_timeout === 'string') {
         attemptTimeout = Number(props.request.attempt_timeout);
       }
 
@@ -3910,7 +3943,7 @@ class ConnectorRest {
         }
 
         if (pres !== null && pres.code !== undefined
-            && (Number(pres.code) < 200 || Number(pres.code) > 299)) {
+          && (Number(pres.code) < 200 || Number(pres.code) > 299)) {
           let errorObj = null;
 
           if (pres.code === -2) {

package/lib/propertyUtil.js

@@ -326,8 +326,8 @@ class AdapterPropertyUtil {
 
       // need to make sure we have supported datatypes - PLAIN is best if not supported - no translation or encoding
       if (entitySchema.requestDatatype.toUpperCase() !== 'JSON' && entitySchema.requestDatatype.toUpperCase() !== 'XML'
-          && entitySchema.requestDatatype.toUpperCase() !== 'URLENCODE' && entitySchema.requestDatatype.toUpperCase() !== 'FORM'
-          && entitySchema.requestDatatype.toUpperCase() !== 'JSON2XML') {
+          && entitySchema.requestDatatype.toUpperCase() !== 'URLENCODE' && entitySchema.requestDatatype.toUpperCase() !== 'URLQUERY'
+          && entitySchema.requestDatatype.toUpperCase() !== 'FORM' && entitySchema.requestDatatype.toUpperCase() !== 'JSON2XML') {
         entitySchema.requestDatatype = 'PLAIN';
       }
       if (entitySchema.responseDatatype.toUpperCase() !== 'JSON' && entitySchema.responseDatatype.toUpperCase() !== 'XML'
@@ -761,8 +761,8 @@ class AdapterPropertyUtil {
 
         // need to make sure we have supported datatypes - PLAIN is best if not supported - no translation or encoding
         if (entitySchema.requestDatatype.toUpperCase() !== 'JSON' && entitySchema.requestDatatype.toUpperCase() !== 'XML'
-            && entitySchema.requestDatatype.toUpperCase() !== 'URLENCODE' && entitySchema.requestDatatype.toUpperCase() !== 'FORM'
-            && entitySchema.requestDatatype.toUpperCase() !== 'JSON2XML') {
+            && entitySchema.requestDatatype.toUpperCase() !== 'URLENCODE' && entitySchema.requestDatatype.toUpperCase() !== 'URLQUERY'
+            && entitySchema.requestDatatype.toUpperCase() !== 'FORM' && entitySchema.requestDatatype.toUpperCase() !== 'JSON2XML') {
           entitySchema.requestDatatype = 'PLAIN';
         }
         if (entitySchema.responseDatatype.toUpperCase() !== 'JSON' && entitySchema.responseDatatype.toUpperCase() !== 'XML'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itentialopensource/adapter-utils",
-  "version": "4.48.0",
+  "version": "4.48.2",
   "description": "Itential Adapter Utility Libraries",
   "scripts": {
     "postinstall": "node utils/setup.js",