@itentialopensource/adapter-utils 5.10.16 → 5.10.18

package/README.md

@@ -3,7 +3,7 @@ Itential Adapter Utilities
 
 Itential Adapter Utilities is a set of Node.js runtime libraries used by Itential Adapters.
 
-Many of the capabilities supported in Itential Adapters are built into this library so that they can e better maintained and added to adapters.
+Many of the capabilities supported in Itential Adapters are built into this library so that they can be better maintained and added to adapters.
 
 # Usage
 

package/lib/connectorRest.js

@@ -267,54 +267,6 @@ function waitForSystem(callProperties) {
   });
 }
 
-/*
- * INTERNAL FUNCTION: Get the best match for the moc k data response
- */
-function matchMock(uriPath, method, type, mockresponses, respDatatype) {
-  // Go through the mock data keys to find the proper data to return
-  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) {
-      if (Object.hasOwnProperty.call(mockresponses[p], 'method')
-        && method.toUpperCase() === mockresponses[p].method.toUpperCase()) {
-        if (Object.hasOwnProperty.call(mockresponses[p], 'type')
-          && type.toUpperCase() === mockresponses[p].type.toUpperCase()) {
-          // This is the mock data we really want as it best matches the request
-          const specificResp = {
-            status: 'success',
-            code: 200,
-            response: {}
-          };
-
-          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')) {
-              specificResp.code = mockresponses[p].response.status;
-
-              if (respDatatype && respDatatype.toUpperCase() === 'XML2JSON') {
-                specificResp.response = mockresponses[p].response.response;
-              } else {
-                specificResp.response = JSON.stringify(mockresponses[p].response.response);
-              }
-            } else if (respDatatype && respDatatype.toUpperCase() === 'XML2JSON') {
-              // if no response field, assume that the entire data is the response
-              specificResp.response = mockresponses[p].response;
-            } else {
-              specificResp.response = JSON.stringify(mockresponses[p].response);
-            }
-          }
-
-          return specificResp;
-        }
-      }
-    }
-  }
-
-  return null;
-}
-
 /*
  * INTERNAL FUNCTION: recursively inspect body data if heirarchical
  */
@@ -347,20 +299,20 @@ function checkBodyData(uriPath, method, reqBdObj, mockresponses, respDatatype) {
           for (let a = 0; a < bVal.length; a += 1) {
             // should match fieldName-fieldValue
             const compStr = `${reqBKeys[k]}-${bVal[a]}`;
-            specificResp = matchMock(uriPath, method, compStr, mockresponses, respDatatype);
+            specificResp = transUtilInst.matchResponse(uriPath, method, compStr, mockresponses, respDatatype);
 
             // if the data match is found break the for loop - will return below
-            if (specificResp !== null) {
+            if (specificResp !== null && specificResp.response) {
               break;
             }
           }
         } else {
           // should match fieldName-fieldValue
           const compStr = `${reqBKeys[k]}-${bVal}`;
-          specificResp = matchMock(uriPath, method, compStr, mockresponses, respDatatype);
+          specificResp = transUtilInst.matchResponse(uriPath, method, compStr, mockresponses, respDatatype);
         }
 
-        if (specificResp !== null) {
+        if (specificResp !== null && specificResp.response) {
           break;
         }
       }
@@ -441,56 +393,9 @@ function returnStub(request, entitySchema, callProperties) {
   }
 
   // if there are path variables, see if there is something that matches a specific variable
-  if (uriPath.indexOf('{pathv') >= 0) {
-    const uriTemp = uriPath.split('?');
-    const actTemp = reqPath.split('?');
-    uriTemp[0] = uriTemp[0].replace(/{pathv/g, '/{pathv');
-    uriTemp[0] = uriTemp[0].replace(/{version/g, '/{version');
-    uriTemp[0] = uriTemp[0].replace(/{base/g, '/{base');
-    uriTemp[0] = uriTemp[0].replace(/\/\//g, '/');
-
-    // remove basepath from both paths
-    // get rid of base path from the uriPath
-    uriTemp[0] = uriTemp[0].replace(/\/{base_path}/g, '');
-    // if a base path was added to the request, remove it
-    if (callProperties && callProperties.base_path && callProperties.base_path !== '/') {
-      actTemp[0] = actTemp[0].replace(callProperties.base_path, '');
-    } else if (basepath && basepath !== '/') {
-      actTemp[0] = actTemp[0].replace(basepath, '');
-    }
-
-    // remove version from both paths
-    // get rid of version from the uriPath
-    uriTemp[0] = uriTemp[0].replace(/\/{version}/g, '');
-    // if a version was added to the request, remove it
-    if (callProperties && callProperties.version) {
-      actTemp[0] = actTemp[0].replace(`/${callProperties.version}`, '');
-    } else if (version && version !== '/') {
-      actTemp[0] = actTemp[0].replace(`/${version}`, '');
-    }
-
-    const uriArray = uriTemp[0].split('/');
-    const actArray = actTemp[0].split('/');
-
-    // if this is one of the generic requests need to pad the actual array or mock data for specific path variable will not work
-    if (entitySchema.entitypath.indexOf('/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}') >= 0) {
-      for (let e = actArray.length; e < uriArray.length; e += 1) {
-        actArray.push('');
-      }
-    }
-
-    // the number of items in both should be the same
-    if (uriArray.length === actArray.length) {
-      for (let i = 0; i < uriArray.length; i += 1) {
-        if (uriArray[i].indexOf('{pathv') >= 0) {
-          specificResp = matchMock(uriPath, method, actArray[i], mockresponses, entitySchema.responseDatatype);
-
-          if (specificResp !== null) {
-            return specificResp;
-          }
-        }
-      }
-    }
+  specificResp = transUtilInst.getRespObjKeyFromPath(uriPath, reqPath, callProperties, basepath, version, method, false, entitySchema);
+  if (specificResp !== null && specificResp.response) {
+    return specificResp;
   }
 
   // if there are queiries or options, see if there is something that matches a specific input
@@ -504,9 +409,9 @@ function returnStub(request, entitySchema, callProperties) {
       if (qval !== undefined && qval !== null && qval !== '') {
         // stringifies it - in case it was not a string
         qval = `${qval}`;
-        specificResp = matchMock(uriPath, method, qval, mockresponses, entitySchema.responseDatatype);
+        specificResp = transUtilInst.matchResponse(uriPath, method, qval, mockresponses, entitySchema.responseDatatype);
 
-        if (specificResp !== null) {
+        if (specificResp !== null && specificResp.response) {
           return specificResp;
         }
       }
@@ -515,79 +420,36 @@ function returnStub(request, entitySchema, callProperties) {
 
   // if there is a request body, see if there is a specific response for body
   if (reqBody) {
-    specificResp = matchMock(uriPath, method, 'WITHBODY', mockresponses, entitySchema.responseDatatype);
-
-    if (specificResp !== null) {
+    specificResp = transUtilInst.matchResponse(uriPath, method, 'WITHBODY', mockresponses, entitySchema.responseDatatype);
+    if (specificResp !== null && specificResp.response) {
       return specificResp;
     }
   }
 
-  // if there are path variables, see if there is a specific response for path vars
-  if (uriPath.indexOf('{pathv') >= 0) {
-    const uriTemp = uriPath.split('?');
-    const actTemp = reqPath.split('?');
-    uriTemp[0] = uriTemp[0].replace(/{pathv/g, '/{pathv');
-    uriTemp[0] = uriTemp[0].replace(/{version/g, '/{version');
-    uriTemp[0] = uriTemp[0].replace(/{base_path}/g, '/{base_path}');
-    uriTemp[0] = uriTemp[0].replace(/\/\//g, '/');
-
-    // remove basepath from both paths
-    // get rid of base path from the uriPath
-    uriTemp[0] = uriTemp[0].replace(/\/{base_path}/g, '');
-    // if a base path was added to the request, remove it
-    if (callProperties && callProperties.base_path && callProperties.base_path !== '/') {
-      actTemp[0] = actTemp[0].replace(callProperties.base_path, '');
-    } else if (basepath && basepath !== '/') {
-      actTemp[0] = actTemp[0].replace(basepath, '');
-    }
-
-    // remove version from both paths
-    // get rid of version from the uriPath
-    uriTemp[0] = uriTemp[0].replace(/\/{version}/g, '');
-    // if a version was added to the request, remove it
-    if (callProperties && callProperties.version) {
-      actTemp[0] = actTemp[0].replace(`/${callProperties.version}`, '');
-    } else if (version && version !== '/') {
-      actTemp[0] = actTemp[0].replace(`/${version}`, '');
-    }
-
-    const uriArray = uriTemp[0].split('/');
-    const actArray = actTemp[0].split('/');
-
-    // the number of items in both should be the same
-    if (uriArray.length === actArray.length) {
-      let cnt = 1;
-      for (let i = 0; i < uriArray.length; i += 1) {
-        if (uriArray[i].indexOf('{pathv') >= 0) {
-          specificResp = matchMock(uriPath, method, `WITHPATHV${cnt}`, mockresponses, entitySchema.responseDatatype);
-
-          if (specificResp !== null) {
-            return specificResp;
-          }
-          cnt += 1;
-        }
-      }
-    }
+  // if there are path variables, see if there is something that matches a specific variable
+  specificResp = transUtilInst.getRespObjKeyFromPath(uriPath, reqPath, callProperties, basepath, version, method, true, entitySchema);
+  if (specificResp !== null && specificResp.response) {
+    return specificResp;
   }
 
   // if there are queiries or options, see if there is a specific response for query or options
   if (uriPath.indexOf('?') >= 0) {
-    specificResp = matchMock(uriPath, method, 'WITHQUERY', mockresponses, entitySchema.responseDatatype);
+    specificResp = transUtilInst.matchResponse(uriPath, method, 'WITHQUERY', mockresponses, entitySchema.responseDatatype);
 
-    if (specificResp !== null) {
+    if (specificResp !== null && specificResp.response) {
       return specificResp;
     }
 
-    specificResp = matchMock(uriPath, method, 'WITHOPTIONS', mockresponses, entitySchema.responseDatatype);
+    specificResp = transUtilInst.matchResponse(uriPath, method, 'WITHOPTIONS', mockresponses, entitySchema.responseDatatype);
 
-    if (specificResp !== null) {
+    if (specificResp !== null && specificResp.response) {
       return specificResp;
     }
   }
 
-  specificResp = matchMock(uriPath, method, 'DEFAULT', mockresponses, entitySchema.responseDatatype);
+  specificResp = transUtilInst.matchResponse(uriPath, method, 'DEFAULT', mockresponses, entitySchema.responseDatatype);
 
-  if (specificResp !== null) {
+  if (specificResp !== null && specificResp.response) {
     return specificResp;
   }
 
@@ -3244,7 +3106,7 @@ function requestAuthenticate(request, entitySchema, invalidToken, callProperties
           }
 
           // format the authentication string
-          log.debug(`${origin}: ${JSON.stringify(propUtilInst.scrubSensitiveInfo(tres, addSensitiveItems))} being used for user: ${useUser}`);
+          log.debug(`${origin}: ${JSON.stringify(propUtilInst.scrubSensitiveInfo(tres, addSensitiveItems))} being used`);
           const authStrs = [];
           if (callProperties && callProperties.authentication && callProperties.authentication.auth_field_format) {
             if (Array.isArray(callProperties.authentication.auth_field_format)) {
@@ -3306,7 +3168,7 @@ function requestAuthenticate(request, entitySchema, invalidToken, callProperties
           return callback(null, errorObj);
         }
 
-        log.debug(`${origin}: ${JSON.stringify(propUtilInst.scrubSensitiveInfo(tokenObj, addSensitiveItems))} being used for user: ${useUser}`);
+        log.debug(`${origin}: ${JSON.stringify(propUtilInst.scrubSensitiveInfo(tokenObj, addSensitiveItems))} being used`);
         const authStrs = [];
         if (callProperties && callProperties.authentication && callProperties.authentication.auth_field_format) {
           if (Array.isArray(callProperties.authentication.auth_field_format)) {
@@ -4579,7 +4441,7 @@ class ConnectorRest {
       return waitForMongo()
         .then(() => {
           if (archiving) {
-            const colRes = this.dbUtil.createCollection(archiveColl, (err, res) => {
+            const colRes = this.dbUtil.createCollection(archiveColl, null, null, (err, res) => {
               if (err) {
                 log.error(`${origin}: collection ${archiveColl} could not be created.`);
                 return callback(false);
@@ -5113,7 +4975,7 @@ class ConnectorRest {
     try {
       if (!throttleEnabled) {
         log.error(`${origin}: Throttling not enabled, no queue`);
-        return [];
+        return callback([]);
       }
 
       return throttleEng.getQueue(callback);

package/lib/constants.js

@@ -0,0 +1,14 @@
+/* @copyright Itential, LLC 2025 */
+
+module.exports = {
+  // Global Strings
+  globalStrings: {
+    pathVarMarker: '{pathv', // path variable format is {pathv#} - number is dynamic can not match
+    versionMarker: '{version}',
+    basePathMarker: '{base_path}',
+    withPathVarPrefix: 'WITHPATHV',
+    urlSplit: '?',
+    pathSplit: '/',
+    globalFlag: 'g'
+  }
+};

package/lib/propertyUtil.js

@@ -550,6 +550,7 @@ class AdapterPropertyUtil {
             name: entitySchema.responseObjects[i].name,
             method: entitySchema.responseObjects[i].method,
             type: entitySchema.responseObjects[i].type,
+            key: entitySchema.responseObjects[i].key || '',
             file: entitySchema.responseObjects[i].mockFile
           };
 
@@ -969,6 +970,7 @@ class AdapterPropertyUtil {
               name: entitySchema.responseObjects[i].name,
               method: entitySchema.responseObjects[i].method,
               type: entitySchema.responseObjects[i].type,
+              key: entitySchema.responseObjects[i].key || '',
               file: entitySchema.responseObjects[i].mockFile
             };
 
@@ -1267,14 +1269,20 @@ class AdapterPropertyUtil {
             retData[key] = this.scrubSensitiveInfo(retData[key], addItems);
           }
         } else {
-          // go through sensitive word list - maybe can use find in
+          let gotit = false;
+          // go through sensitive word list to mask the entire string
           for (let j = 0; j < sensList.length; j += 1) {
             if (key.toLowerCase() === sensList[j]) {
               // if sensitive, mask
               retData[key] = '** masked **';
+              gotit = true;
               break;
             }
           }
+          // if not masking the string as a whole - may need to parse part of it
+          if (!gotit) {
+            retData[key] = this.scrubSensitiveInfo(retData[key], addItems);
+          }
         }
       });
 

package/lib/restHandler.js

@@ -28,31 +28,6 @@ let stripEscapes = false;
 let returnResponseHeaders = true;
 let healthcheckHeaders = null;
 let xmlArrayKeys = null;
-// INTERNAL FUNCTIONS
-/*
- * INTERNAL FUNCTION: Get the best match for the mock data response
- */
-function matchResponse(uriPath, method, type, mockresponses) {
-  // Go through the mock data keys to find the proper data to return
-  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) {
-      if (Object.hasOwnProperty.call(mockresponses[p], 'method')
-          && method.toUpperCase() === mockresponses[p].method.toUpperCase()) {
-        if (Object.hasOwnProperty.call(mockresponses[p], 'type')
-            && type.toUpperCase() === mockresponses[p].type.toUpperCase()) {
-          // This is the Key we really want as it best matches the request
-          if (Object.hasOwnProperty.call(mockresponses[p], 'key')) {
-            return mockresponses[p].key;
-          }
-        }
-      }
-    }
-  }
-
-  return null;
-}
 
 /*
  * INTERNAL FUNCTION: recursively inspect body data if heirarchical
@@ -84,9 +59,12 @@ function checkBodyData(uriPath, method, reqBdObj, mockresponses) {
         } else if (Array.isArray(bVal)) {
           // if an array of data, need to check each data in the array
           for (let a = 0; a < bVal.length; a += 1) {
-            // should match fieldName-fieldValue
+            // should match fieldName-fieldValue - NOTE: if we get the responseDatatype that should be passed in
             const compStr = `${reqBKeys[k]}-${bVal[a]}`;
-            specificResp = matchResponse(uriPath, method, compStr, mockresponses);
+            const response = transUtilInst.matchResponse(uriPath, method, compStr, mockresponses, null);
+            if (response) {
+              specificResp = response.key;
+            }
 
             // if the data match is found break the for loop - will return below
             if (specificResp !== null) {
@@ -94,9 +72,12 @@ function checkBodyData(uriPath, method, reqBdObj, mockresponses) {
             }
           }
         } else {
-          // should match fieldName-fieldValue
+          // should match fieldName-fieldValue - NOTE: if we get the responseDatatype that should be passed in
           const compStr = `${reqBKeys[k]}-${bVal}`;
-          specificResp = matchResponse(uriPath, method, compStr, mockresponses);
+          const response = transUtilInst.matchResponse(uriPath, method, compStr, mockresponses, null);
+          if (response) {
+            specificResp = response.key;
+          }
         }
 
         if (specificResp !== null) {
@@ -271,48 +252,10 @@ function handleRestRequest(request, entityId, entitySchema, callProperties, filt
         }
 
         // if there are path variables, see if there is something that matches a specific variable
-        if (respObjKey === null && uriPath.indexOf('{pathv') >= 0) {
-          const uriTemp = uriPath.split('?');
-          const actTemp = reqPath.split('?');
-          uriTemp[0] = uriTemp[0].replace(/{pathv/g, '/{pathv');
-          uriTemp[0] = uriTemp[0].replace(/{version/g, '/{version');
-          uriTemp[0] = uriTemp[0].replace(/{base/g, '/{base');
-          uriTemp[0] = uriTemp[0].replace(/\/\//g, '/');
-
-          // remove basepath from both paths
-          // get rid of base path from the uriPath
-          uriTemp[0] = uriTemp[0].replace(/\/{base_path}/g, '');
-          // if a base path was added to the request, remove it
-          if (callProperties && callProperties.base_path && callProperties.base_path !== '/') {
-            actTemp[0] = actTemp[0].replace(callProperties.base_path, '');
-          } else if (basepathGl && basepathGl !== '/') {
-            actTemp[0] = actTemp[0].replace(basepathGl, '');
-          }
-
-          // remove version from both paths
-          // get rid of version from the uriPath
-          uriTemp[0] = uriTemp[0].replace(/\/{version}/g, '');
-          // if a version was added to the request, remove it
-          if (callProperties && callProperties.version) {
-            actTemp[0] = actTemp[0].replace(`/${callProperties.version}`, '');
-          } else if (versionGl && versionGl !== '/') {
-            actTemp[0] = actTemp[0].replace(`/${versionGl}`, '');
-          }
-
-          const uriArray = uriTemp[0].split('/');
-          const actArray = actTemp[0].split('/');
-
-          // the number of items in both should be the same
-          if (uriArray.length === actArray.length) {
-            for (let i = 0; i < uriArray.length; i += 1) {
-              if (uriArray[i].indexOf('{pathv') >= 0) {
-                respObjKey = matchResponse(uriPath, method, actArray[i], responseKeys);
-
-                if (respObjKey !== null) {
-                  break;
-                }
-              }
-            }
+        if (respObjKey === null) {
+          const specificResp = transUtilInst.getRespObjKeyFromPath(uriPath, reqPath, callProperties, basepathGl, versionGl, method, false, entitySchema);
+          if (specificResp) {
+            respObjKey = specificResp.key;
           }
         }
 
@@ -326,7 +269,10 @@ function handleRestRequest(request, entityId, entitySchema, callProperties, filt
             if (qval !== undefined && qval !== null && qval !== '') {
               // stringifies it - in case it was not a string
               qval = `${qval}`;
-              respObjKey = matchResponse(uriPath, method, qval, responseKeys);
+              const specificResp = transUtilInst.matchResponse(uriPath, method, qval, responseKeys, entitySchema.responseDatatype);
+              if (specificResp) {
+                respObjKey = specificResp.key;
+              }
 
               if (respObjKey !== null) {
                 break;
@@ -337,68 +283,40 @@ function handleRestRequest(request, entityId, entitySchema, callProperties, filt
 
         // if there is a request body, see if there is a specific response for body
         if (respObjKey === null && reqBody) {
-          respObjKey = matchResponse(uriPath, method, 'WITHBODY', responseKeys);
+          const specificResp = transUtilInst.matchResponse(uriPath, method, 'WITHBODY', responseKeys, entitySchema.responseDatatype);
+          if (specificResp) {
+            respObjKey = specificResp.key;
+          }
         }
 
         // if there are path variables, see if there is a specific response for path vars
-        if (respObjKey === null && uriPath.indexOf('{pathv') >= 0) {
-          const uriTemp = uriPath.split('?');
-          const actTemp = reqPath.split('?');
-          uriTemp[0] = uriTemp[0].replace(/{pathv/g, '/{pathv');
-          uriTemp[0] = uriTemp[0].replace(/{version/g, '/{version');
-          uriTemp[0] = uriTemp[0].replace(/{base/g, '/{base');
-          uriTemp[0] = uriTemp[0].replace(/\/\//g, '/');
-
-          // remove basepath from both paths
-          // get rid of base path from the uriPath
-          uriTemp[0] = uriTemp[0].replace(/\/{base_path}/g, '');
-          // if a base path was added to the request, remove it
-          if (callProperties && callProperties.base_path && callProperties.base_path !== '/') {
-            actTemp[0] = actTemp[0].replace(callProperties.base_path, '');
-          } else if (basepathGl && basepathGl !== '/') {
-            actTemp[0] = actTemp[0].replace(basepathGl, '');
-          }
-
-          // remove version from both paths
-          // get rid of version from the uriPath
-          uriTemp[0] = uriTemp[0].replace(/\/{version}/g, '');
-          // if a version was added to the request, remove it
-          if (callProperties && callProperties.version) {
-            actTemp[0] = actTemp[0].replace(`/${callProperties.version}`, '');
-          } else if (versionGl && versionGl !== '/') {
-            actTemp[0] = actTemp[0].replace(`/${versionGl}`, '');
-          }
-
-          const uriArray = uriTemp[0].split('/');
-          const actArray = actTemp[0].split('/');
-
-          // the number of items in both should be the same
-          if (uriArray.length === actArray.length) {
-            let cnt = 1;
-            for (let i = 0; i < uriArray.length; i += 1) {
-              if (uriArray[i].indexOf('{pathv') >= 0) {
-                respObjKey = matchResponse(uriPath, method, `WITHPATHV${cnt}`, responseKeys);
-
-                if (respObjKey !== null) {
-                  break;
-                }
-                cnt += 1;
-              }
-            }
+        if (respObjKey === null) {
+          const specificResp = transUtilInst.getRespObjKeyFromPath(uriPath, reqPath, callProperties, basepathGl, versionGl, method, true, entitySchema);
+          if (specificResp) {
+            respObjKey = specificResp.key;
           }
         }
 
         // if there are queiries or options, see if there is a specific response for query or options
         if (respObjKey === null && uriPath.indexOf('?') >= 0) {
-          respObjKey = matchResponse(uriPath, method, 'WITHQUERY', responseKeys);
+          let specificResp = transUtilInst.matchResponse(uriPath, method, 'WITHQUERY', responseKeys, entitySchema.responseDatatype);
+          if (specificResp) {
+            respObjKey = specificResp.key;
+          }
 
           if (respObjKey === null) {
-            respObjKey = matchResponse(uriPath, method, 'WITHOPTIONS', responseKeys);
+            specificResp = transUtilInst.matchResponse(uriPath, method, 'WITHOPTIONS', responseKeys, entitySchema.responseDatatype);
+            if (specificResp) {
+              respObjKey = specificResp.key;
+            }
           }
         }
 
         if (respObjKey === null) {
-          respObjKey = matchResponse(uriPath, method, 'DEFAULT', responseKeys);
+          const specificResp = transUtilInst.matchResponse(uriPath, method, 'DEFAULT', responseKeys, entitySchema.responseDatatype);
+          if (specificResp) {
+            respObjKey = specificResp.key;
+          }
         }
 
         if (respObjKey === null) {
@@ -524,6 +442,7 @@ function handleRestRequest(request, entityId, entitySchema, callProperties, filt
           return callback(retObject);
         });
       }
+
       // process the response - parse it
       try {
         retResponse = JSON.parse(resObj.response.trim());

package/lib/throttle.js

@@ -442,7 +442,12 @@ function gettingCloseInterval(myRequest, transNum, callback) {
 
   try {
     let intRun = false;
-    const fastInt = (avgTotal / avgSize) * 0.5;
+    let fastInt = (avgTotal / avgSize) * 0.5;
+
+    // prevent timeout overflow errors - 15 min max
+    if (fastInt > 900000) {
+      fastInt = 900000;
+    }
 
     // rapid inner interval - should be done when it is almost my time to run.
     const intervalObject = setInterval(() => {
@@ -1128,6 +1133,11 @@ class SystemXThrottle {
           outerInterval *= 0.95;
         }
 
+        // prevent timeout overflow errors - 2 hours max
+        if (outerInterval > 7200000) {
+          outerInterval = 7200000;
+        }
+
         log.debug(`${origin}: Request ${queueItem.request_id} Transaction ${queueItem.transNum} Outer Interval set to: ${outerInterval}`);
 
         // outer interval to get a turn request

package/lib/translatorUtil.js

@@ -7,6 +7,7 @@
 /* eslint no-use-before-define: warn */
 /* eslint prefer-object-spread:warn */
 /* eslint prefer-destructuring:warn */
+/* eslint no-continue:warn */
 
 /* NodeJS internal utilities */
 const fs = require('fs');
@@ -17,6 +18,16 @@ const AjvCl = require('ajv');
 const jsonQuery = require('json-query');
 const cryptoJS = require('crypto-js');
 
+// get global strings
+const { globalStrings } = require(path.join(__dirname, 'constants.js'));
+const { pathVarMarker } = globalStrings;
+const { versionMarker } = globalStrings;
+const { basePathMarker } = globalStrings;
+const { withPathVarPrefix } = globalStrings;
+const { urlSplit } = globalStrings;
+const { pathSplit } = globalStrings;
+const { globalFlag } = globalStrings;
+
 let id = null;
 let propUtilInst = null;
 let translator = null;
@@ -943,6 +954,172 @@ class AdapterTranslatorUtil {
     return combinedObj;
   }
 
+  /**
+   * @summary Gets the property from call properties or global
+   *
+   * @function getPathProperty
+   * @param {String} globalProperty - global property value
+   * @param {String} propertyName - property name to find it in call properties
+   *
+   */
+  getPathProperty(globalProperty, propertyName, callProperties) {
+    const origin = `${this.myid}-translatorUtil-getPathProperty`;
+    log.trace(origin);
+
+    let propertyValue = `${pathSplit}${globalProperty}`;
+    if (callProperties && callProperties[propertyName]) {
+      propertyValue = `${pathSplit}${callProperties[propertyName]}`;
+    }
+
+    // remove any double slash that we may have introduced - consistency
+    return propertyValue.replace(new RegExp(`${pathSplit}${pathSplit}`, globalFlag), pathSplit);
+  }
+
+  /**
+   * @summary Matches the response to the response object to get the key
+   *
+   * @function matchResponse
+   * @param {String} uriPath - original path from the entitypath
+   * @param {String} method - method for the request
+   * @param {String} type - type for the mock response
+   * @param {Object} mockresponses - mock response objects
+   *
+   */
+  matchResponse(uriPath, method, type, mockresponses, respDatatype) {
+    const origin = `${this.myid}-translatorUtil-matchResponse`;
+    log.trace(origin);
+
+    // Go through the mock data keys to find the proper data to return
+    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
+          && Object.hasOwnProperty.call(mockresponses[p], 'method') && method.toUpperCase() === mockresponses[p].method.toUpperCase()
+          && Object.hasOwnProperty.call(mockresponses[p], 'type') && type.toUpperCase() === mockresponses[p].type.toUpperCase()) {
+        // This response best matches the request so return the key and data
+        const specificResp = {
+          key: '',
+          status: 'success',
+          code: 200,
+          response: {}
+        };
+
+        if (Object.hasOwnProperty.call(mockresponses[p], 'key')) {
+          specificResp.key = mockresponses[p].key;
+        }
+
+        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')) {
+            specificResp.code = mockresponses[p].response.status;
+
+            if (respDatatype && respDatatype.toUpperCase() === 'XML2JSON') {
+              specificResp.response = mockresponses[p].response.response;
+            } else {
+              specificResp.response = JSON.stringify(mockresponses[p].response.response);
+            }
+          } else if (respDatatype && respDatatype.toUpperCase() === 'XML2JSON') {
+            // if no response field, assume that the entire data is the response
+            specificResp.response = mockresponses[p].response;
+          } else {
+            specificResp.response = JSON.stringify(mockresponses[p].response);
+          }
+        }
+
+        return specificResp;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * @summary Gets the response object key from the path for determining how to match response
+   * This might be used by token calls in the connector so it might be good to move out of here!
+   *
+   * @function getRespObjKeyFromPath
+   * @param {String} uriPath - original path from the entitypath
+   * @param {String} reqPath - path after translations - actual call path
+   * @param {Object} callProperties - properties to override on this call
+   * @param {String} basepathGl - base path global property
+   * @param {String} versionGl - version global property
+   * @param {String} method - method type for the request
+   * @param {bollean} withPath - whether we are checking for with path vars
+   * @param {Object} entitySchema - the entity schema for the request
+   *
+   */
+  getRespObjKeyFromPath(uriPath, reqPath, callProperties, basepathGl, versionGl, method, withPath, entitySchema) {
+    const origin = `${this.myid}-translatorUtil-getRespObjKeyFromPath`;
+    log.trace(origin);
+    let specificResp = null;
+
+    // if there are path variables, see if there is something that matches a specific variable
+    if (uriPath.indexOf(pathVarMarker) >= 0) {
+      const uriTemp = uriPath.split(urlSplit);
+      const actTemp = reqPath.split(urlSplit);
+
+      // make sure the entitypath has a standard format since they can differ (e.g. slashes or no slashes)
+      uriTemp[0] = uriTemp[0].replace(new RegExp(pathVarMarker, globalFlag), `${pathSplit}${pathVarMarker}`);
+      uriTemp[0] = uriTemp[0].replace(new RegExp(versionMarker, globalFlag), `${pathSplit}${versionMarker}`);
+      uriTemp[0] = uriTemp[0].replace(new RegExp(basePathMarker, globalFlag), `${pathSplit}${basePathMarker}`);
+      uriTemp[0] = uriTemp[0].replace(new RegExp(`${pathSplit}${pathSplit}`, globalFlag), pathSplit);
+
+      // if the original path has {base_path}, remove base_path from both paths
+      if (uriTemp[0].indexOf(basePathMarker) >= 0) {
+        // get rid of base path marker from the original path
+        uriTemp[0] = uriTemp[0].replace(new RegExp(`${pathSplit}${basePathMarker}`, globalFlag), '');
+        // get rid of base path from the request path
+        if (basepathGl && basepathGl !== '/') {
+          actTemp[0] = actTemp[0].replace(this.getPathProperty(basepathGl, 'base_path', callProperties), '');
+        }
+      }
+
+      // if the original path has {version}, remove version from both paths
+      if (uriTemp[0].indexOf(versionMarker) >= 0) {
+        // get rid of version marker from the original path
+        uriTemp[0] = uriTemp[0].replace(new RegExp(`${pathSplit}${versionMarker}`, globalFlag), '');
+        // get rid of version from the request path
+        if (versionGl && versionGl !== '/') {
+          actTemp[0] = actTemp[0].replace(this.getPathProperty(versionGl, 'version', callProperties), '');
+        }
+      }
+
+      const uriArray = uriTemp[0].split(pathSplit);
+      const actArray = actTemp[0].split(pathSplit);
+
+      // if this is one of the generic requests need to pad the actual array or mock data for specific path variable will not work
+      if (entitySchema.entitypath.indexOf('/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}') >= 0) {
+        for (let e = actArray.length; e < uriArray.length; e += 1) {
+          actArray.push('');
+        }
+      }
+
+      // the number of items in both should be the same
+      if (uriArray.length === actArray.length) {
+        let varCount = 1;
+        // want to go through the path to find the path variables
+        for (let i = 0; i < uriArray.length; i += 1) {
+          // if this is a path variable in the original path
+          if (uriArray[i].indexOf(pathVarMarker) >= 0) {
+            // are we checking generic path vars (withPath) or specific path data
+            if (withPath) {
+              specificResp = this.matchResponse(uriPath, method, `${withPathVarPrefix}${varCount}`, entitySchema.mockresponses, entitySchema.responseDatatype);
+            } else {
+              specificResp = this.matchResponse(uriPath, method, actArray[i], entitySchema.mockresponses, entitySchema.responseDatatype);
+            }
+
+            if (specificResp !== null) {
+              break;
+            }
+            varCount += 1;
+          }
+        }
+      }
+    }
+
+    return specificResp;
+  }
+
   /**
    * @summary If the input is a stringified JSON object, return the JSON object. Otherwise,
    * return the object that was provided.

package/package.json

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