@itentialopensource/adapter-utils 5.10.28 → 5.11.0

package/.eslintrc.js

@@ -9,6 +9,7 @@ module.exports = {
     'json'
   ],
   parserOptions: {
+    ecmaVersion: 2020,
     sourceType: 'module'
   },
   rules: {

package/lib/connectorRest.js

@@ -36,6 +36,18 @@ const validator = require('validator');
 
 const ThrottleCl = require(path.join(__dirname, '/throttle.js'));
 
+// Load properties schema to extract valid enum values
+const propertiesSchema = require(path.join(__dirname, '../schemas/propertiesSchema.json'));
+
+// Token placement constants
+const TokenPlacement = Object.freeze({
+  HEADER: 'HEADER',
+  BODY: 'BODY',
+  XML2JSON: 'XML2JSON',
+  QUERY: 'QUERY',
+  PATH: 'PATH'
+});
+
 const allowFailover = 'AD.300';
 const noFailover = 'AD.500';
 let transUtilInst = null;
@@ -113,6 +125,32 @@ let refTokenReq = null;
 let refTokenTimeout = -1;
 let runRefreshToken = false;
 let addSensitiveItems = [];
+let authRequestDatatype = null;
+let authResponseDatatype = null;
+let tokenResponsePlacement = null;
+// Extract valid values from schema (filter out empty string which is just for default)
+const VALID_AUTH_REQUEST_DATATYPES = propertiesSchema.definitions.authentication.properties.auth_request_datatype.enum.filter((v) => v !== '');
+const VALID_AUTH_RESPONSE_DATATYPES = propertiesSchema.definitions.authentication.properties.auth_response_datatype.enum.filter((v) => v !== '');
+const VALID_TOKEN_RESPONSE_PLACEMENTS = propertiesSchema.definitions.authentication.properties.token_response_placement.enum.filter((v) => v !== '');
+
+/**
+ * Validates an authentication property value against a list of valid values
+ * @param {*} value - The value to validate
+ * @param {Array} validValues - Array of valid values
+ * @param {string} propertyName - Name of the property for error messaging
+ * @returns {string|undefined} - Returns the validated value or undefined if invalid/empty
+ */
+function validateAuthProperty(value, validValues, propertyName) {
+  if (typeof value !== 'string' || value === '') {
+    return;
+  }
+
+  if (!validValues.includes(value)) {
+    throw new Error(`Invalid ${propertyName}: '${value}'. Must be one of: ${validValues.join(', ')}`);
+  }
+
+  return value;
+}
 
 // Other global variables
 let id = null;
@@ -1100,6 +1138,20 @@ function findExpireInResult(result) {
   return expire;
 }
 
+/*
+ * INTERNAL FUNCTION: gets the effective token placement
+ * (adapter property overrides schema)
+ */
+function getTokenPlacement(tokenSchema, tokenProperty) {
+  if (tokenResponsePlacement) {
+    return tokenResponsePlacement.toUpperCase();
+  }
+  if (tokenSchema?.responseSchema?.properties?.[tokenProperty]?.placement) {
+    return tokenSchema.responseSchema.properties[tokenProperty].placement.toUpperCase();
+  }
+  return null;
+}
+
 /*
  * INTERNAL FUNCTION: makes the request and processes the response
  * for the request to get the token
@@ -1107,6 +1159,7 @@ function findExpireInResult(result) {
 async function getToken(reqPath, options, tokenSchema, bodyString, callProperties, callback) {
   const origin = `${id}-connectorRest-getToken`;
   log.trace(origin);
+  const responseDatatype = authResponseDatatype || (tokenSchema && tokenSchema.responseDatatype);
 
   const p = new Promise((resolve, reject) => {
     try {
@@ -1225,8 +1278,7 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
         };
 
         // 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') {
+        if (getTokenPlacement(tokenSchema, 'token') === TokenPlacement.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}`);
@@ -1306,8 +1358,7 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
         }
 
         // process second token from header
-        if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.tokenp2
-          && tokenSchema.responseSchema.properties.tokenp2.placement && tokenSchema.responseSchema.properties.tokenp2.placement.toUpperCase() === 'HEADER') {
+        if (getTokenPlacement(tokenSchema, 'tokenp2') === TokenPlacement.HEADER) {
           if (!tokenSchema.responseSchema.properties.tokenp2.external_name) {
             const errorObj = transUtilInst.formatErrorObject(origin, 'Unable To Get Secondary Token', ['Secondary Token', result.code], null, null, null);
             log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
@@ -1388,11 +1439,10 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
 
         // process the body
         // if response is just a string
-        if (Object.hasOwnProperty.call(tokenSchema, 'responseDatatype') && tokenSchema.responseDatatype.toUpperCase() === 'PLAIN') {
+        if (responseDatatype && responseDatatype.toUpperCase() === 'PLAIN') {
           log.debug('Attempting to get tokens from text body repsonse');
 
-          if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.token
-            && tokenSchema.responseSchema.properties.token.placement && tokenSchema.responseSchema.properties.token.placement.toUpperCase() === 'BODY') {
+          if (getTokenPlacement(tokenSchema, 'token') === TokenPlacement.BODY) {
             currResult.token = result.response;
 
             // if we got a stringified string - we can remove the double quotes wrapping it
@@ -1400,8 +1450,7 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
               currResult.token = currResult.token.substring(1, currResult.token.length - 1);
             }
           }
-          if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.tokenp2
-            && tokenSchema.responseSchema.properties.tokenp2.placement && tokenSchema.responseSchema.properties.tokenp2.placement.toUpperCase() === 'BODY') {
+          if (getTokenPlacement(tokenSchema, 'tokenp2') === TokenPlacement.BODY) {
             currResult.tokenp2 = result.response;
 
             // if we got a stringified string - we can remove the double quotes wrapping it
@@ -1413,15 +1462,14 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
           // return the string as there is no other processing needed
           return resolve(currResult);
         }
-        if (Object.hasOwnProperty.call(tokenSchema, 'responseDatatype') && tokenSchema.responseDatatype.toUpperCase() === 'XML') {
+
+        if (responseDatatype && responseDatatype.toUpperCase() === 'XML') {
           log.debug('Attempting to get tokens from XML body repsonse');
 
-          if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.token
-            && tokenSchema.responseSchema.properties.token.placement && tokenSchema.responseSchema.properties.token.placement.toUpperCase() === 'BODY') {
+          if (getTokenPlacement(tokenSchema, 'token') === TokenPlacement.BODY) {
             currResult.token = result.response;
           }
-          if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.tokenp2
-            && tokenSchema.responseSchema.properties.tokenp2.placement && tokenSchema.responseSchema.properties.tokenp2.placement.toUpperCase() === 'BODY') {
+          if (getTokenPlacement(tokenSchema, 'tokenp2') === TokenPlacement.BODY) {
             currResult.tokenp2 = result.response;
           }
 
@@ -1432,7 +1480,7 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
         // if response can be put into a JSON object
         let tempResult = null;
         if (result.response) {
-          if (Object.hasOwnProperty.call(tokenSchema, 'responseDatatype') && tokenSchema.responseDatatype.toUpperCase() === 'XML2JSON') {
+          if (responseDatatype && responseDatatype.toUpperCase() === TokenPlacement.XML2JSON) {
             log.debug('Attempting to get tokens from XML2JSON repsonse');
 
             try {
@@ -1446,17 +1494,15 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
               });
             } catch (ex) {
               log.warn(`${origin}: Unable to get json from xml ${ex}`);
-              if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.token
-                && tokenSchema.responseSchema.properties.token.placement && tokenSchema.responseSchema.properties.token.placement.toUpperCase() === 'BODY') {
+              if (getTokenPlacement(tokenSchema, 'token') === TokenPlacement.BODY) {
                 currResult.token = result.response;
               }
-              if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.tokenp2
-                && tokenSchema.responseSchema.properties.tokenp2.placement && tokenSchema.responseSchema.properties.tokenp2.placement.toUpperCase() === 'BODY') {
+              if (getTokenPlacement(tokenSchema, 'tokenp2') === TokenPlacement.BODY) {
                 currResult.tokenp2 = result.response;
               }
             }
           }
-          if (Object.hasOwnProperty.call(tokenSchema, 'responseDatatype') && tokenSchema.responseDatatype.toUpperCase() === 'URLENCODE') {
+          if (responseDatatype && responseDatatype.toUpperCase() === 'URLENCODE') {
             log.debug('Attempting to get tokens from URLENCODE repsonse');
             tempResult = querystring.parse(result.response.trim());
           } else {
@@ -1509,20 +1555,16 @@ async function getToken(reqPath, options, tokenSchema, bodyString, callPropertie
           translated = translated[0];
         }
 
-        if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.token
-          && tokenSchema.responseSchema.properties.token.placement && tokenSchema.responseSchema.properties.token.placement.toUpperCase() === 'BODY') {
+        if (getTokenPlacement(tokenSchema, 'token') === TokenPlacement.BODY) {
           currResult.token = translated.token;
         }
-        if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.tokenp2
-          && tokenSchema.responseSchema.properties.tokenp2.placement && tokenSchema.responseSchema.properties.tokenp2.placement.toUpperCase() === 'BODY') {
+        if (getTokenPlacement(tokenSchema, 'tokenp2') === TokenPlacement.BODY) {
           currResult.tokenp2 = translated.tokenp2;
         }
-        if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.expires
-          && tokenSchema.responseSchema.properties.expires.placement && tokenSchema.responseSchema.properties.expires.placement.toUpperCase() === 'BODY') {
+        if (getTokenPlacement(tokenSchema, 'expires') === TokenPlacement.BODY) {
           currResult.expires = translated.expires;
         }
-        if (tokenSchema.responseSchema && tokenSchema.responseSchema.properties && tokenSchema.responseSchema.properties.refreshToken
-          && tokenSchema.responseSchema.properties.refreshToken.placement && tokenSchema.responseSchema.properties.refreshToken.placement.toUpperCase() === 'BODY') {
+        if (getTokenPlacement(tokenSchema, 'refreshToken') === TokenPlacement.BODY) {
           currResult.refreshToken = translated.refreshToken;
         }
         // return the token that we find in the translated object
@@ -1669,13 +1711,15 @@ async function buildTokenRequest(reqPath, reqBody, callProperties, callback) {
 
         // set the Content Type headers based on the type of request data for the call
         if (thisAHdata['Content-Type'] === undefined || thisAHdata['Content-Type'] === null) {
-          if (tokenSchema && tokenSchema.requestDatatype && tokenSchema.requestDatatype.toUpperCase() === 'PLAIN') {
+          // Check adapter property override first, then fall back to tokenSchema
+          const requestDatatype = authRequestDatatype || (tokenSchema && tokenSchema.requestDatatype);
+          if (requestDatatype && requestDatatype.toUpperCase() === 'PLAIN') {
             // add the Plain headers if they were not set already
             thisAHdata['Content-Type'] = 'text/plain';
-          } else if (tokenSchema && tokenSchema.requestDatatype && tokenSchema.requestDatatype.toUpperCase() === 'XML') {
+          } else if (requestDatatype && requestDatatype.toUpperCase() === 'XML') {
             // add the XML headers if they were not set already
             thisAHdata['Content-Type'] = 'application/xml';
-          } else if (tokenSchema && tokenSchema.requestDatatype && tokenSchema.requestDatatype.toUpperCase() === 'URLENCODE') {
+          } else if (requestDatatype && requestDatatype.toUpperCase() === 'URLENCODE') {
             // add the URLENCODE headers if they were not set already
             thisAHdata['Content-Type'] = 'application/x-www-form-urlencoded';
           } else {
@@ -1685,13 +1729,14 @@ async function buildTokenRequest(reqPath, reqBody, callProperties, callback) {
         }
         // set the Accept headers based on the type of response data for the call
         if (thisAHdata.Accept === undefined || thisAHdata.Accept === null) {
-          if (tokenSchema && tokenSchema.responseDatatype && tokenSchema.responseDatatype.toUpperCase() === 'PLAIN') {
+          const responseDatatype = authResponseDatatype || (tokenSchema && tokenSchema.responseDatatype);
+          if (responseDatatype && responseDatatype.toUpperCase() === 'PLAIN') {
             // add the Plain headers if they were not set already
             thisAHdata.Accept = 'text/plain';
-          } else if (tokenSchema && tokenSchema.responseDatatype && (tokenSchema.responseDatatype.toUpperCase() === 'XML' || tokenSchema.responseDatatype.toUpperCase() === 'XML2JSON')) {
+          } else if (responseDatatype && (responseDatatype.toUpperCase() === 'XML' || responseDatatype.toUpperCase() === TokenPlacement.XML2JSON)) {
             // add the XML headers if they were not set already
             thisAHdata.Accept = 'application/xml';
-          } else if (tokenSchema && tokenSchema.responseDatatype && tokenSchema.responseDatatype.toUpperCase() === 'URLENCODE') {
+          } else if (responseDatatype && responseDatatype.toUpperCase() === 'URLENCODE') {
             // add the URLENCODE headers if they were not set already
             thisAHdata.Accept = 'application/x-www-form-urlencoded';
           } else {
@@ -2159,11 +2204,13 @@ async function buildTokenRequest(reqPath, reqBody, callProperties, callback) {
             bodyString = tokenEntity;
 
             // if it is JSON or URLENCODE need to put body into right format
-            if (!tokenSchema.requestDatatype || tokenSchema.requestDatatype.toUpperCase() === 'JSON' || tokenSchema.requestDatatype.toUpperCase() === 'FORM') {
+            // Check adapter property override first, then fall back to tokenSchema
+            const requestDatatype = authRequestDatatype || (tokenSchema && tokenSchema.requestDatatype);
+            if (!requestDatatype || requestDatatype.toUpperCase() === 'JSON' || requestDatatype.toUpperCase() === 'FORM') {
               bodyString = JSON.stringify(tokenEntity);
-            } else if (tokenSchema.requestDatatype && tokenSchema.requestDatatype.toUpperCase() === 'URLENCODE') {
+            } else if (requestDatatype && requestDatatype.toUpperCase() === 'URLENCODE') {
               bodyString = querystring.stringify(tokenEntity);
-            } else if (tokenSchema.requestDatatype && tokenSchema.requestDatatype.toUpperCase() === 'URLQUERY') {
+            } else if (requestDatatype && requestDatatype.toUpperCase() === 'URLQUERY') {
               // if the datatype is URLQUERY need to put into the query on the request
               if (authQueryEncode != null) {
                 if (authQueryEncode === true) {
@@ -4275,6 +4322,36 @@ class ConnectorRest {
       if (props.authentication.sensitive) {
         addSensitiveItems = props.authentication.sensitive;
       }
+
+      // set the auth request datatype override (optional - default is null)
+      const validatedAuthRequestDatatype = validateAuthProperty(
+        props.authentication.auth_request_datatype,
+        VALID_AUTH_REQUEST_DATATYPES,
+        'auth_request_datatype'
+      );
+      if (validatedAuthRequestDatatype !== undefined) {
+        authRequestDatatype = validatedAuthRequestDatatype;
+      }
+
+      // set the auth response datatype override (optional - default is null)
+      const validatedAuthResponseDatatype = validateAuthProperty(
+        props.authentication.auth_response_datatype,
+        VALID_AUTH_RESPONSE_DATATYPES,
+        'auth_response_datatype'
+      );
+      if (validatedAuthResponseDatatype !== undefined) {
+        authResponseDatatype = validatedAuthResponseDatatype;
+      }
+
+      // set the token response placement override (optional - default is null)
+      const validatedTokenResponsePlacement = validateAuthProperty(
+        props.authentication.token_response_placement,
+        VALID_TOKEN_RESPONSE_PLACEMENTS,
+        'token_response_placement'
+      );
+      if (validatedTokenResponsePlacement !== undefined) {
+        tokenResponsePlacement = validatedTokenResponsePlacement;
+      }
     }
 
     // set the stub mode (optional - default is false)

package/package.json

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

package/schemas/propertiesSchema.json

@@ -272,6 +272,44 @@
           "description": "This property turns on logging of Authentication Information and should only be true when debugging authentication and connectivity",
           "default": false
         },
+        "auth_request_datatype": {
+          "type": "string",
+          "description": "Override the request data type for token authentication requests. When set, this overrides the schema's requestDatatype",
+          "default": "",
+          "enum": [
+            "",
+            "JSON",
+            "JSON2XML",
+            "PLAIN",
+            "XML",
+            "URLENCODE",
+            "URLQUERY",
+            "FORM"
+          ]
+        },
+        "auth_response_datatype": {
+          "type": "string",
+          "description": "Override the response data type for token authentication requests. When set, this overrides the schema's responseDatatype",
+          "default": "",
+          "enum": [
+            "",
+            "JSON",
+            "XML2JSON",
+            "PLAIN",
+            "XML",
+            "URLENCODE"
+          ]
+        },
+        "token_response_placement": {
+          "type": "string",
+          "description": "Override where to extract the token from the authentication response (HEADER or BODY). When set, this overrides the schema's token placement setting",
+          "default": "",
+          "enum": [
+            "",
+            "HEADER",
+            "BODY"
+          ]
+        },
         "client_id": {
           "type": "string",
           "description": "The client id for OAuth requests - can also use username depending on schema",