@adobe/acc-js-sdk 1.1.3 → 1.1.6

package/src/cacheRefresher.js

@@ -0,0 +1,227 @@
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+(function () {
+    "use strict";
+
+    const { DomUtil } = require("./domUtil.js");
+    const XtkCaster = require('./xtkCaster.js').XtkCaster;
+    const { Cache } = require('./cache.js');
+    const { CampaignException } = require('./campaign.js');
+
+    /**
+     * @private
+     * @class
+     * @constructor
+     * @memberof Campaign
+     */
+    class RefresherStateCache extends Cache {
+
+        /**
+         * A cache to store state of the refresher. Not intended to be used directly,
+         * but an internal cache for the Campaign.Client object
+         * 
+         * Cached object are made of
+         * - the key is the propertie name
+         * - the value is a string
+         * 
+         * @param {Storage} storage is an optional Storage object, such as localStorage or sessionStorage
+         * @param {string} rootKey is an optional root key to use for the storage object
+         * @param {number} ttl is the TTL for objects in ms. Defaults to 5 mins
+         */
+        constructor(storage, rootKey, ttl) {
+            super(storage, rootKey, ttl);
+        }
+
+        /**
+         * Cache a property of the refresh (buildNumber, last refresh time) and its value
+         * 
+         * @param {string} name is the propertie name
+         * @param {string} rawValue string value
+         */
+        put(name, rawValue) {
+            return super.put(name, { value: rawValue });
+        }
+
+        /**
+         * Get the value of a property of the refresh (buildNumber, last refresh time)
+         * 
+         * @param {string} name the propertie name
+         * @returns {*} the value
+         */
+        get(name) {
+            const option = super.get(name);
+            return option ? option.value : undefined;
+        }
+    }
+
+    class CacheRefresher {
+
+        /**
+        * A class to refresh regulary a Cache every n seconds, by sending a query to get the last modified entities.
+        * The refresh mechanism can be activated by calling client.startRefreshCaches().
+        * This mechanism depends on the xtk:session:GetModifiedEntities API which is introduced in ACC 8.4 and above.
+        *
+        * @param {Cache} cache is the cache to refresh
+        * @param {Client} client is the ACC API Client.
+        * @param {string} cacheSchemaId is the id of the schema present in the cache to be refreshed every 10 seconds
+        * @param {string} rootKey is used as the root key of cache items in the refresher state cache
+        */
+        constructor(cache, client, cacheSchemaId, rootKey) {
+            const connectionParameters = client._connectionParameters;
+            this._cache = cache;
+            this._client = client;
+            this._connectionParameters = connectionParameters;
+            this._cacheSchemaId = cacheSchemaId;
+
+            this._storage = connectionParameters._options._storage;
+            this._refresherStateCache  = new RefresherStateCache(this._storage, `${rootKey}.RefresherStateCache`, 1000*3600);
+
+            this._lastTime = undefined;
+            this._buildNumber = undefined;
+            this._intervalId = null;
+            this._running = false;
+        }
+
+        /**
+         * Start auto refresh
+         * @param {integer} refreshFrequency frequency of the refresh in ms (default value is 10,000 ms)
+         */
+        startAutoRefresh(refreshFrequency) {
+            if (this._intervalId != null) {
+                clearInterval(this._intervalId);
+            }
+            this._intervalId = setInterval(() => {
+                this._safeCallAndRefresh();
+            }, refreshFrequency || 10000); // every 10 seconds by default
+        }
+
+        // Protect _callAndRefresh from reentrance
+        async _safeCallAndRefresh() {
+            if (this._running) {
+                // This call is already running and maybe taking a long time to complete. Do not make things
+                // harder and just skip this run
+                return;
+            }
+            this._running = true;
+            try {
+                await this._callAndRefresh();
+            } catch(ex) {
+                if (ex.errorCode === "SDK-000010") {
+                    // client is not logged, this is not an error.
+                    return;
+                }
+                console.warn(`Failed to refresh cache for ${this._cacheSchemaId}`, ex);
+            }
+              finally {
+                this._running = false;
+            }
+        }
+
+        // Get last modified entities for the Campaign server and remove from cache last modified entities
+        async _callAndRefresh() {
+            const that = this;
+            const soapCall = this._client._prepareSoapCall("xtk:session", "GetModifiedEntities", true, this._connectionParameters._options.extraHttpHeaders);
+
+            if (this._lastTime === undefined) {
+                const storedTime = this._refresherStateCache.get("time");
+                if (storedTime != undefined) {
+                    this._lastTime = storedTime;
+                }
+            }
+            if (this._buildNumber === undefined) {
+                const storedBuildNumber = this._refresherStateCache.get("buildNumber");
+                if (storedBuildNumber != undefined) {
+                    this._buildNumber = storedBuildNumber;
+                }
+            }
+
+            // Use Json because xtk:schema does not work directly in DomUtil.parse(`<cache buildNumber="9469" time="2022-06-30T00:00:00.000"><xtk:schema></xtk:schema></cache>`);
+            // due to the colon character
+            let jsonCache;
+            if (this._lastTime === undefined || this._buildNumber === undefined) {
+                jsonCache = {
+                    [this._cacheSchemaId]: {}
+                };
+            } else {
+                jsonCache = {
+                    buildNumber: this._buildNumber,
+                    lastModified: this._lastTime,
+                    [this._cacheSchemaId]: {}
+                };
+            }
+
+            const xmlDoc = DomUtil.fromJSON("cache", jsonCache, 'SimpleJson');
+            soapCall.writeDocument("cacheEntities", xmlDoc);
+
+            // Client is not logged: do not attempt to refresh caches at all
+            if (!this._client.isLogged())
+              throw CampaignException.NOT_LOGGED_IN(soapCall, `Cannot call GetModifiedEntities: session not connected`);
+
+            // Do a soap call GetModifiedEntities instead of xtksession.GetModifiedEnties because we don't want to go through methodCache 
+            // which might not contain the method GetModifiedEntities just after a build updgrade from a old version of acc 
+            return this._client._makeSoapCall(soapCall)
+                .then(() => {
+                    let doc = soapCall.getNextDocument();
+                    soapCall.checkNoMoreArgs();
+                    doc = that._client._toRepresentation(doc, 'xml');
+                    that._lastTime = DomUtil.getAttributeAsString(doc, "time"); // save time to be able to send it as an attribute in the next soap call
+                    that._buildNumber = DomUtil.getAttributeAsString(doc, "buildNumber");
+                    that._refresh(doc);
+                    that._refresherStateCache.put("time", that._lastTime);
+                    that._refresherStateCache.put("buildNumber", that._buildNumber);
+                })
+                .catch((ex) => {
+                    // if the method GetModifiedEntities is not found in this acc version we disable the autoresfresh of the cache
+                    if (soapCall.methodName == "GetModifiedEntities" && ex.errorCode == "SOP-330006") {
+                        this.stopAutoRefresh();
+                    } else {
+                        throw ex;
+                    }
+                });
+        }
+
+        // Refresh Cache : remove entities modified recently listed in xmlDoc
+        _refresh(xmlDoc) {
+            const clearCache = XtkCaster.asBoolean(DomUtil.getAttributeAsString(xmlDoc, "emptyCache"));
+            if (clearCache == true) {
+                this._cache.clear();
+            } else {
+                var child = DomUtil.getFirstChildElement(xmlDoc, "entityCache");
+                while (child) {
+                    const pkSchemaId = DomUtil.getAttributeAsString(child, "pk");
+                    const schemaId = DomUtil.getAttributeAsString(child, "schema");
+                    if (schemaId === this._cacheSchemaId) {
+                        this._cache.remove(pkSchemaId);
+                        // Notify listeners to refresh in SchemaCache
+                        if (schemaId === "xtk:schema") {
+                            const schemaIds = pkSchemaId.split("|");
+                            this._client._notifyCacheChangeListeners(schemaIds[1]);
+                        }
+                    }
+                    child = DomUtil.getNextSiblingElement(child);
+                }
+            }
+        }
+
+        /**
+         * Stop auto refreshing the cache
+         */
+        stopAutoRefresh() {
+            clearInterval(this._intervalId);
+            this._intervalId = null;
+        }
+    }
+
+    // Public exports
+    exports.CacheRefresher = CacheRefresher;
+
+})();

package/src/client.js

@@ -31,6 +31,7 @@ const Cipher = require('./crypto.js').Cipher;
 const DomUtil = require('./domUtil.js').DomUtil;
 const MethodCache = require('./methodCache.js').MethodCache;
 const OptionCache = require('./optionCache.js').OptionCache;
+const CacheRefresher = require('./cacheRefresher.js').CacheRefresher;
 const request = require('./transport.js').request;
 const Application = require('./application.js').Application;
 const EntityAccessor = require('./entityAccessor.js').EntityAccessor;
@@ -105,13 +106,13 @@ const xtkObjectHandler = {
  * @private
  * @memberof Campaign
  */
-const clientHandler = (representation, headers) => {
+const clientHandler = (representation, headers, pushDownOptions) => {
     return {
         get: function(client, namespace) {
 
             // Force XML or JSON representation (NLWS.xml or NLWS.json)
-            if (namespace == "xml") return new Proxy(client, clientHandler("xml", headers));
-            if (namespace == "json") return new Proxy(client, clientHandler("SimpleJson", headers));
+            if (namespace == "xml") return new Proxy(client, clientHandler("xml", headers, pushDownOptions));
+            if (namespace == "json") return new Proxy(client, clientHandler("SimpleJson", headers, pushDownOptions));
 
             // Override HTTP headers (NLWS.headers({...}))
             // Unlike NLWS.xml or NLWS.json, NLWS.headers returns a function. This function takes key/value
@@ -123,16 +124,30 @@ const clientHandler = (representation, headers) => {
                 const newHeaders = {};
                 if (headers) for (let h in headers) newHeaders[h] = headers[h];
                 if (methodHeaders) for (let h in methodHeaders) newHeaders[h] = methodHeaders[h];
-                return new Proxy(client, clientHandler(representation, newHeaders));
+                return new Proxy(client, clientHandler(representation, newHeaders, pushDownOptions));
+            };
+
+            // Pushes down addition options to the SOAP and transport layers
+            if (namespace == "pushDown") return (methodPushDownOptions) => {
+                // Build of copy of the pushDownOptions in order to accomodate
+                // chained calls, such as NLWS.pushDown(...).pushDown(...)
+                const newPushDownOptions = {};
+                if (pushDownOptions) for (let h in pushDownOptions) newPushDownOptions[h] = pushDownOptions[h];
+                if (methodPushDownOptions) for (let h in methodPushDownOptions) newPushDownOptions[h] = methodPushDownOptions[h];
+                return new Proxy(client, clientHandler(representation, headers, newPushDownOptions));
             };
 
             return new Proxy({ client:client, namespace:namespace}, {
                 get: function(callContext, methodName) {
                     callContext.representation = representation;
                     callContext.headers = callContext.headers || client._connectionParameters._options.extraHttpHeaders;
+                    callContext.pushDownOptions = {};
                     if (headers) {
                         for (let h in headers) callContext.headers[h] = headers[h];
                     }
+                    if (pushDownOptions) {
+                        for (let h in pushDownOptions) callContext.pushDownOptions[h] = pushDownOptions[h];
+                    }
 
                     if (methodName == ".") return callContext;
 
@@ -270,6 +285,8 @@ class Credentials {
     * @property {{ name:string, value:string}} extraHttpHeaders - optional key/value pair of HTTP header (will override any other headers)
     * @property {string} clientApp - optional name/version of the application client of the SDK. This will be passed in HTTP headers for troubleshooting
     * @property {boolean} noSDKHeaders - set to disable "ACC-SDK" HTTP headers
+    * @property {boolean} noMethodInURL - Can be set to true to remove the method name from the URL
+    * @property {number} timeout - Can be set to change the HTTP call timeout. Value is passed in ms.
     * @memberOf Campaign
  */
  
@@ -291,7 +308,7 @@ class ConnectionParameters {
     constructor(endpoint, credentials, options) {
         // this._options will be populated with the data from "options" and with
         // default values. But the "options" parameter will not be modified
-        this._options = {};
+        this._options = Object.assign({}, options);
 
         // Default value
         if (options === undefined || options === null)
@@ -340,6 +357,7 @@ class ConnectionParameters {
         }
         this._options.clientApp = options.clientApp;
         this._options.noSDKHeaders = !!options.noSDKHeaders;
+        this._options.noMethodInURL = !!options.noMethodInURL;
     }
 
     /**
@@ -515,13 +533,16 @@ class Client {
         const rootKey = `acc.js.sdk.${sdk.getSDKVersion().version}.${instanceKey}.cache`;
 
         this._entityCache = new XtkEntityCache(this._storage, `${rootKey}.XtkEntityCache`, connectionParameters._options.entityCacheTTL);
+        this._entityCacheRefresher = new CacheRefresher(this._entityCache, this, "xtk:schema", `${rootKey}.XtkEntityCache`);
         this._methodCache = new MethodCache(this._storage, `${rootKey}.MethodCache`, connectionParameters._options.methodCacheTTL);
         this._optionCache = new OptionCache(this._storage, `${rootKey}.OptionCache`, connectionParameters._options.optionCacheTTL);
+        this._optionCacheRefresher = new CacheRefresher(this._optionCache, this, "xtk:option", `${rootKey}.OptionCache`);
         this.NLWS = new Proxy(this, clientHandler());
 
         this._transport = connectionParameters._options.transport;
         this._traceAPICalls = connectionParameters._options.traceAPICalls;
         this._observers = [];
+        this._cacheChangeListeners = [];
         this._refreshClient = connectionParameters._options.refreshClient;
 
         // expose utilities
@@ -716,10 +737,11 @@ class Client {
      * @return {SOAP.SoapMethodCall} a SoapMethodCall which have been initialized with security tokens... and to which the method
      * parameters should be set
      */
-    _prepareSoapCall(urn, method, internal, extraHttpHeaders) {
+    _prepareSoapCall(urn, method, internal, extraHttpHeaders, pushDownOptions) {
         const soapCall = new SoapMethodCall(this._transport, urn, method, 
                                             this._sessionToken, this._securityToken, 
-                                            this._getUserAgentString(), this._connectionParameters._options.charset,
+                                            this._getUserAgentString(),
+                                            Object.assign({}, this._connectionParameters._options, pushDownOptions),
                                             extraHttpHeaders);
         soapCall.internal = !!internal;
         return soapCall;
@@ -831,6 +853,7 @@ class Client {
             that._sessionToken = credentials._sessionToken;
             that._securityToken = "";
             that.application = new Application(that);
+            that.application._registerCacheChangeListener();
             return Promise.resolve();
         }
         else if (credentials._type == "SecurityToken") {
@@ -839,6 +862,7 @@ class Client {
             that._sessionToken = "";
             that._securityToken = credentials._securityToken;
             that.application = new Application(that);
+            that.application._registerCacheChangeListener();
             return Promise.resolve();
         }
         else if (credentials._type == "UserPassword" || credentials._type == "BearerToken") {
@@ -890,6 +914,7 @@ class Client {
                 that._securityToken = securityToken;
 
                 that.application = new Application(that);
+                that.application._registerCacheChangeListener();
             });
         }
         else {
@@ -915,10 +940,13 @@ class Client {
     logoff() {
         var that = this;
         if (!that.isLogged()) return;
+        that.application._unregisterCacheChangeListener();
+        that._unregisterAllCacheChangeListeners();
+        this.stopRefreshCaches();
         const credentials = this._connectionParameters._credentials;
         if (credentials._type != "SessionToken" && credentials._type != "AnonymousUser") {
             var soapCall = that._prepareSoapCall("xtk:session", "Logoff", false, this._connectionParameters._options.extraHttpHeaders);
-                return this._makeSoapCall(soapCall).then(function() {
+            return this._makeSoapCall(soapCall).then(function() {
                 that._sessionToken = "";
                 that._securityToken = "";
                 that.application = null;
@@ -940,15 +968,15 @@ class Client {
      * @return the option value, casted in the expected data type. If the option does not exist, it will return null.
      */
     async getOption(name, useCache = true) {
-        var value;
-        if (useCache)
-            value = this._optionCache.get(name);
-        if (value === undefined) {
-            const option = await this.NLWS.xtkSession.getOption(name);
-            value = this._optionCache.put(name, option);
-            this._optionCache.put(name, option);
-        }
-        return value;
+      var value;
+      if (useCache) {
+        value = this._optionCache.get(name);
+      }
+      if (value === undefined) {
+        const option = await this.NLWS.xtkSession.getOption(name);
+        value = this._optionCache.put(name, option);
+      }
+      return value;
     }
 
     /**
@@ -1014,6 +1042,50 @@ class Client {
         this.clearOptionCache();
     }
 
+    /**
+     * Start auto refresh of all caches
+     * @param {integer} refreshFrequency refresh frequency in ms. 10000 ms by default.
+     */
+    startRefreshCaches(refreshFrequency) {
+        if (refreshFrequency === undefined || refreshFrequency === null)
+            refreshFrequency = 10000;
+        this._optionCacheRefresher.startAutoRefresh(refreshFrequency);
+        // Start auto refresh for entityCache a little later
+        setTimeout(() => { this._entityCacheRefresher.startAutoRefresh(refreshFrequency); }, refreshFrequency/2);
+    }
+    /**
+     * Stop auto refresh of all caches
+     */
+    stopRefreshCaches() {
+        this._optionCacheRefresher.stopAutoRefresh();
+        this._entityCacheRefresher.stopAutoRefresh();
+    }
+
+    // Register a callback to be called when a schema has been modified and should be removed
+    // from the caches
+    _registerCacheChangeListener(listener) {
+        this._cacheChangeListeners.push(listener);
+    }
+
+    // Unregister a cache change listener
+    _unregisterCacheChangeListener(listener) {
+        for (var i = 0; i < this._cacheChangeListeners.length; i++) {
+            if (this._cacheChangeListeners[i] == listener) {
+                this._cacheChangeListeners.splice(i, 1);
+                break;
+            }
+        }
+    }
+
+    // Unregister all cache change listener
+    _unregisterAllCacheChangeListeners() {
+        this._cacheChangeListeners = [];
+    }
+
+    _notifyCacheChangeListeners(schemaId) {
+        this._cacheChangeListeners.map((listener) => listener.invalidateCacheItem(schemaId));
+    }
+
     /**
      * Tests if a package is installed
      * 
@@ -1083,11 +1155,12 @@ class Client {
         var that = this;
         var entity = that._entityCache.get("xtk:schema", schemaId);
         if (!entity) {
-            entity = await that.getEntityIfMoreRecent("xtk:schema", schemaId, "xml", internal);
-        }
-        if (entity)
+          entity = await that.getEntityIfMoreRecent("xtk:schema", schemaId, "xml", internal);
+          if (entity) {
             that._entityCache.put("xtk:schema", schemaId, entity);
-
+            that._methodCache.put(entity);
+          }
+        }
         entity = that._toRepresentation(entity, representation);
         return entity;
     }
@@ -1162,7 +1235,7 @@ class Client {
         // console.log(method.toXMLString());
 
         var urn = that._methodCache.getSoapUrn(schemaId, methodName);
-        var soapCall = that._prepareSoapCall(urn, methodName, false, callContext.headers);
+        var soapCall = that._prepareSoapCall(urn, methodName, false, callContext.headers, callContext.pushDownOptions);
 
         // If method is called with one parameter which is a function, then we assume it's a hook: the function will return
         // the actual list of parameters
@@ -1234,7 +1307,7 @@ class Client {
                         if (type == "DOMDocument")
                             soapCall.writeDocument(paramName, xmlValue);
                         else
-                            soapCall.writeElement(paramName, xmlValue.documentElement);
+                            soapCall.writeElement(paramName, xmlValue);
                     }
                     else
                         throw CampaignException.BAD_SOAP_PARAMETER(soapCall, paramName, paramValue, `Unsupported parameter type '${type}' for parameter '${paramName}' of method '${methodName}' of schema '${schemaId}`);

package/src/index.js

@@ -23,7 +23,8 @@ const DomUtil = require('./domUtil.js').DomUtil;
 const XtkCaster = require('./xtkCaster.js').XtkCaster;
 const { Client, Credentials, ConnectionParameters } = require('./client.js');
 const request = require('./transport.js').request;
-const { TestUtil } = require('./testUtil');
+const { TestUtil } = require('./testUtil.js');
+const { HttpError } = require('./transport.js');
 
 /**
  * Get/Set the transport function (defaults to Axios). This function is used for testing / mocking the transport layer.
@@ -210,6 +211,7 @@ sdk.XtkCaster = XtkCaster;
 sdk.Credentials = Credentials;
 sdk.DomUtil = DomUtil;
 sdk.ConnectionParameters = ConnectionParameters;
+sdk.HttpError = HttpError;
 
 // Public exports
 module.exports = sdk;

package/src/soap.js

@@ -78,14 +78,15 @@ const NS_XSD = "http://www.w3.org/2001/XMLSchema";
  * @param {string} sessionToken Campaign session token
  * @param {string} securityToken  Campaign security token
  * @param {string} userAgentString The user agent string to use for HTTP requests
- * @param {string} charset The charset encoding used for http requests, usually UTF-8
+ * @param {string} pushDownOptions Options to push down to the request (comes from connectionParameters._options)
  * @param {{ name:string, value:string}} extraHttpHeaders key/value pair of HTTP header (will override any other headers)
  * @memberof SOAP
  */
 class SoapMethodCall {
     
-    constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString, charset, extraHttpHeaders) {
+    constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString, pushDownOptions, extraHttpHeaders) {
         this.request = undefined;       // The HTTP request (object litteral passed to the transport layer)
+        this.requestOptions = undefined;
         this.response = undefined;      // The HTTP response object (in case of success)
 
         // Current URN and method (for error reporting)
@@ -102,7 +103,8 @@ class SoapMethodCall {
         this._sessionToken = sessionToken || "";
         this._securityToken = securityToken || "";
         this._userAgentString = userAgentString;
-        this._charset = charset || "";
+        this._pushDownOptions = pushDownOptions || {};
+        this._charset = this._pushDownOptions.charset || '';
         this._extraHttpHeaders = extraHttpHeaders || {};
 
         // THe SOAP call being built
@@ -289,6 +291,7 @@ class SoapMethodCall {
     writeElement(tag, element) {
         const node = this._addNode(tag, "ns:Element", null, SOAP_ENCODING_XML);
         if (element !== null && element !== undefined) {
+            if (element.nodeType === 9) element = element.documentElement;
             const child = this._doc.importNode(element, true);
             node.appendChild(child);
         }
@@ -517,7 +520,7 @@ class SoapMethodCall {
      * @param {string} url is the Campaign SOAP endpoint (soaprouter.jsp)
      * @returns {Object} an options object describing the HTTP request, with cookies, headers and body
      */
-    _createHTTPRequest(url) {
+    _createHTTPRequest(url, requestOptions) {
 
         const headers = {
             'Content-type': `application/soap+xml${this._charset ? ";charset=" + this._charset : ""}`,
@@ -533,23 +536,24 @@ class SoapMethodCall {
             if (this.internal) headers["ACC-SDK-Call-Internal"] = "1";
         }
 
-        const options = {
+        const request = {
             url: url,
             method: 'POST',
             headers: headers,
             data: DomUtil.toXMLString(this._doc)
         };
         if (this._sessionToken)
-            options.headers.Cookie = '__sessiontoken=' + this._sessionToken;
+            request.headers.Cookie = '__sessiontoken=' + this._sessionToken;
         if (this._userAgentString)
-            options.headers['User-Agent'] = this._userAgentString;
+            request.headers['User-Agent'] = this._userAgentString;
 
         // Override http headers with custom headers
         for (let h in this._extraHttpHeaders) {
-            options.headers[h] = this._extraHttpHeaders[h];
+            request.headers[h] = this._extraHttpHeaders[h];
         }
 
-        return options;
+        const extraOptions = Object.assign({}, this._pushDownOptions, requestOptions);
+        return [ request, extraOptions ];
     }
     
     /**
@@ -595,9 +599,11 @@ class SoapMethodCall {
             sessionTokenElem.textContent = this._sessionToken;
             this._method.prepend(sessionTokenElem);
         }
-        const options = this._createHTTPRequest(url);
+        const noMethodInURL = !!this._pushDownOptions.noMethodInURL;
+        const actualUrl = noMethodInURL ? url : `${url}?${this.urn}:${this.methodName}`;
+
         // Prepare request and empty response objects
-        this.request = options;
+        [this.request, this.requestOptions] = this._createHTTPRequest(actualUrl);
         this.response = undefined;
     }
 
@@ -610,7 +616,7 @@ class SoapMethodCall {
      */
     async execute() {
         const that = this;
-        const promise = this._transport(this.request);
+        const promise = this._transport(this.request, this.requestOptions);
         return promise.then(function(body) {
             if (body.indexOf(`XSV-350008`) != -1)
                 throw CampaignException.SESSION_EXPIRED();

package/src/testUtil.js

@@ -1,4 +1,4 @@
-const { DomUtil } = require("./domUtil");
+const { DomUtil } = require("./domUtil.js");
 
 /*
 Copyright 2022 Adobe. All rights reserved.
@@ -14,7 +14,7 @@ governing permissions and limitations under the License.
 (function() {
 "use strict";    
   
-const { newSchema } = require("./application");
+const { newSchema } = require("./application.js");
 
 /**********************************************************************************
  * 

package/src/transport.js

@@ -14,13 +14,27 @@ governing permissions and limitations under the License.
 
 const { Util } = require('./util.js');
 
+/**
+ * @memberof Utils
+ * @class
+ * @constructor
+ */
 class HttpError {
+  /* Encapsulates an error from an HTTP call
+    * @param {string|number} statusCode - The Http status code
+    * @param {string?} statusText - The Http status text corresponding to the error code
+    * @param {any?} data - The payload of the HTTP response, which usually contains details about the error
+  */
   constructor(statusCode, statusText, data) {
       this.statusCode = statusCode;
       this.statusText = statusText || "";
       this.data = data;
   }
 
+  /**
+   * Returns a short description of the error
+   * @returns {string} a short descrption of the error
+   */
   toString() {
     return `${this.statusCode}${this.statusText ? " " + this.statusText : ""}`;
   }
@@ -52,13 +66,14 @@ if (!Util.isBrowser()) {
    * - request
    */
 
-  const request = (options) => {
+   const request = (options, requestOptions) => {
+    requestOptions = requestOptions || {};
     const request = {
       method: options.method || "GET",
       url: options.url,
       headers: options.headers,
       data: options.data,
-      timeout: 5000,
+      timeout: requestOptions.timeout || 5000,
     };
     return axios(request)
     .then((response) => {