@adobe/acc-js-sdk 1.0.3 → 1.0.7

package/src/client.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
 Copyright 2020 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -10,7 +9,9 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-
+(function() {
+"use strict";    
+    
 
 /**********************************************************************************
  * 
@@ -86,7 +87,7 @@ const xtkObjectHandler = {
         });
 
     }
-}
+};
 
 /**
  * Java Script Proxy handler for NLWS. 
@@ -130,7 +131,7 @@ const clientHandler = {
                         var promise = callContext.client._callMethod(methodName, callContext, argumentsList);
                         return promise.then(function(optionAndValue) {
                             const optionName = argumentsList[0];
-                            client._optionCache.cache(optionName, optionAndValue);
+                            client._optionCache.put(optionName, optionAndValue);
                             return optionAndValue;
                         });
                     }
@@ -143,7 +144,7 @@ const clientHandler = {
                     return function(body) {
                         callContext.object = body;
                         return new Proxy(callContext, xtkObjectHandler);
-                    }
+                    };
                 }
 
                 return new Proxy(caller, {
@@ -160,27 +161,32 @@ const clientHandler = {
 // Campaign credentials
 // ========================================================================================
 
-/**
- * Credentials to a Campaign instance. Encapsulates the various types of credentials.
- * Do not create directly, use one of the methods in ConnectionParameters
- * 
+/** 
  * @class
  * @constructor
  * @private
- * @param {string} type the credentials type. Supported types are "UserPassword" and "ImsServiceToken" and "SessionToken" and "AnonymousUser"
- * @param {string} sessionToken the session token. It's exact form depends on the credentials type. For instance it can be "user/passord" for the "UserPassword" credentials type
- * @param {string} securityToken the security token. Will use an empty token if not specified
  * @memberof Campaign
  */
 class Credentials {
 
+    /**
+     * Credentials to a Campaign instance. Encapsulates the various types of credentials.
+     * Do not create directly, use one of the methods in ConnectionParameters
+     * @param {string} type the credentials type. Supported types are "UserPassword" and "ImsServiceToken" and "SessionToken" and "AnonymousUser"
+     * @param {string} sessionToken the session token. It's exact form depends on the credentials type. For instance it can be "user/passord" for the "UserPassword" credentials type
+     * @param {string} securityToken the security token. Will use an empty token if not specified
+     */
     constructor(type, sessionToken, securityToken) {
         if (type != "UserPassword" && type != "ImsServiceToken" && type != "SessionToken" && 
-            type != "AnonymousUser" && type != "SecurityToken")
+            type != "AnonymousUser" && type != "SecurityToken" && type != "BearerToken")
             throw CampaignException.INVALID_CREDENTIALS_TYPE(type);
         this._type = type;
         this._sessionToken = sessionToken || "";
         this._securityToken = securityToken || "";
+        if (type == "BearerToken") {
+            this._bearerToken = sessionToken || "";
+            this._sessionToken = "";
+        }
     }
 
     /**
@@ -218,19 +224,39 @@ class Credentials {
 // ========================================================================================
 
 /**
- * Creates a connection parameters object which can be used to create a Client object
- * to connect to a Campaign instance
- * 
+ * @typedef {Object} ConnectionOptions
+ * @property {string} representation - the representation to use, i.e. "SimpleJson" (the default), "BadgerFish", or "xml"
+ * @property {boolean} rememberMe - The Campaign `rememberMe` attribute which can be used to extend the lifetime of session tokens
+ * @property {number} entityCacheTTL - The TTL (in milliseconds) after which cached XTK entities expire. Defaults to 5 minutes
+ * @property {number} methodCacheTTL - The TTL (in milliseconds) after which cached XTK methods expire. Defaults to 5 minutes
+ * @property {number} optionCacheTTL - The TTL (in milliseconds) after which cached XTK options expire. Defaults to 5 minutes
+ * @property {boolean} traceAPICalls - Activates the tracing of all API calls
+ * @property {Utils.Transport} transport - Overrides the transport (i.e. HTTP layer)
+ * @property {boolean} noStorage - De-activate using of local storage. By default, and in addition to in-memory cache, entities, methods, and options are also persisted in local storage if there is one.
+ * @property {Storage} storage - Overrides the storage interface (i.e. LocalStorage)
+ * @memberOf Campaign
+ */
+ 
+
+/**
  * @class
  * @constructor
- * @param {string} endpoint The campaign endpoint (URL)
- * @param {Credentials} credentials The credentials for the connection
- * @param {*} options connection options. Currently only contains a "representation" attribute which controls what type of entities (xml or json) the SDK handles
  * @memberof Campaign
  */
 class ConnectionParameters {
-    
+
+    /**
+     * Creates a connection parameters object which can be used to create a Client object
+     * to connect to a Campaign instance
+     * @param {string} endpoint The campaign endpoint (URL)
+     * @param {Campaign.Credentials} credentials The credentials for the connection
+     * @param {Campaign.ConnectionOptions} options connection options
+     */
     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 = {};
+
         // Default value
         if (options === undefined || options === null)
             options = { };
@@ -240,18 +266,37 @@ class ConnectionParameters {
         if (typeof options  != "object")
             throw CampaignException.INVALID_CONNECTION_OPTIONS(options);
 
-        if (options.representation === undefined || options.representation === null)
-            options.representation = "SimpleJson";
+        this._options.representation = options.representation;
+        if (this._options.representation === undefined || this._options.representation === null)
+            this._options.representation = "SimpleJson";
 
-        if (options.representation != "xml" && options.representation != "BadgerFish" && options.representation != "SimpleJson")
-            throw CampaignException.INVALID_REPRESENTATION(options.representation, "Cannot create Campaign client");
+        if (this._options.representation != "xml" && this._options.representation != "BadgerFish" && this._options.representation != "SimpleJson")
+            throw CampaignException.INVALID_REPRESENTATION(this._options.representation, "Cannot create Campaign client");
 
         // Defaults for rememberMe
-        options.rememberMe = !!options.rememberMe;
+        this._options.rememberMe = !!options.rememberMe;
+
+        this._options.entityCacheTTL = options.entityCacheTTL || 1000*300; // 5 mins
+        this._options.methodCacheTTL = options.methodCacheTTL || 1000*300; // 5 mins
+        this._options.optionCacheTTL = options.optionCacheTTL || 1000*300; // 5 mins 
+        this._options.traceAPICalls = options.traceAPICalls === null || options.traceAPICalls ? !!options.traceAPICalls : false;
+        this._options.transport = options.transport || request;
 
         this._endpoint = endpoint;
         this._credentials = credentials;
-        this._options = options;
+
+        var storage;
+        if (!options.noStorage) {
+            storage = options.storage;
+            try {
+                if (!storage)
+                    storage = localStorage;    
+            } catch (ex) {
+                /* ignore error if localStorage not found */
+            }    
+        }
+        this._options._storage = storage;
+        this._options.refreshClient = options.refreshClient;
     }
 
     /**
@@ -260,7 +305,7 @@ class ConnectionParameters {
      * @param {string} endpoint The campaign endpoint (URL)
      * @param {string} user The user name
      * @param {string} password The user password
-     * @param {*} options connection options
+     * @param {Campaign.ConnectionOptions} options connection options
      * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
      */
     static ofUserAndPassword(endpoint, user, password, options) {
@@ -268,13 +313,25 @@ class ConnectionParameters {
         return new ConnectionParameters(endpoint, credentials, options);
     }
 
+    /**
+     * Creates connection parameters for a Campaign instance from bearer token
+     * 
+     * @param {string} endpoint The campaign endpoint (URL)
+     * @param {string} bearerToken IMS bearer token
+     * @param {*} options connection options
+     * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
+     */
+    static ofBearerToken(endpoint, bearerToken, options) {
+        const credentials = new Credentials("BearerToken", bearerToken);
+        return new ConnectionParameters(endpoint, credentials, options);
+    }
     /**
      * Creates connection parameters for a Campaign instance, using an IMS service token and a user name (the user to impersonate)
      * 
      * @param {string} endpoint The campaign endpoint (URL)
      * @param {string} user The user name
      * @param {string} serviceToken The IMS service token
-     * @param {*} options connection options
+     * @param {Campaign.ConnectionOptions} options connection options
      * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
      */
     static ofUserAndServiceToken(endpoint, user, serviceToken, options) {
@@ -288,7 +345,7 @@ class ConnectionParameters {
      * @static
      * @param {string} endpoint The campaign endpoint (URL)
      * @param {string} sessionToken The session token
-     * @param {*} options connection options
+     * @param {Campaign.ConnectionOptions} options connection options
      * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
      */
     static ofSessionToken(endpoint, sessionToken, options) {
@@ -305,7 +362,7 @@ class ConnectionParameters {
      * @static
      * @param {string} endpoint The campaign endpoint (URL)
      * @param {string} securityToken The session token
-     * @param {*} options connection options
+     * @param {Campaign.ConnectionOptions} options connection options
      * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
      */
     static ofSecurityToken(endpoint, securityToken, options) {
@@ -317,7 +374,7 @@ class ConnectionParameters {
      * Creates connection parameters for a Campaign instance for an anonymous user
      * 
      * @param {string} endpoint The campaign endpoint (URL)
-     * @param {*} options connection options
+     * @param {Campaign.ConnectionOptions} options connection options
      * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
      */
     static ofAnonymousUser(endpoint, options) {
@@ -356,9 +413,9 @@ class ConnectionParameters {
                     { "expr": "@type=3" }
                 ]
             }
-        }
+        };
         // Convert to current representation
-        queryDef = client.convertToRepresentation(queryDef, "SimpleJson");
+        queryDef = client._convertToRepresentation(queryDef, "SimpleJson");
         const query = client.NLWS.xtkQueryDef.create(queryDef);
         const extAccount = await query.executeQuery();
 
@@ -381,18 +438,20 @@ class ConnectionParameters {
 // ========================================================================================
 
 /**
- * ACC API Client.
- * Do not create directly, use SDK.init instead
- * 
  * @private
  * @class
  * @constructor
- * @param {Campaign.SDK} sdk is the global sdk object used to create the client
- * @param {Campaign.ConnectionParameters} user user name, for instance admin
  * @memberof Campaign
  */
 class Client {
-    
+
+    /**
+     * ACC API Client.
+     * Do not create directly, use SDK.init instead
+     * 
+     * @param {Campaign.SDK} sdk is the global sdk object used to create the client
+     * @param {Campaign.ConnectionParameters} user user name, for instance admin
+     */
     constructor(sdk, connectionParameters) {
         this.sdk = sdk;
         this._connectionParameters = connectionParameters; // ## TODO security concern (password kept in memory)
@@ -405,14 +464,22 @@ class Client {
         
         this._secretKeyCipher = undefined;
         
-        this._entityCache = new XtkEntityCache();
-        this._methodCache = new MethodCache();
-        this._optionCache = new OptionCache();
+        this._storage = connectionParameters._options._storage;
+        // TODO late cache initiallzation because need XtkDatabaseId / instance name
+        var instanceKey = connectionParameters._endpoint || "";
+        if (instanceKey.startsWith("http://")) instanceKey = instanceKey.substr(7);
+        if (instanceKey.startsWith("https://")) instanceKey = instanceKey.substr(8);
+        const rootKey = `acc.js.sdk.${sdk.getSDKVersion().version}.${instanceKey}.cache`;
+
+        this._entityCache = new XtkEntityCache(this._storage, `${rootKey}.XtkEntityCache`, connectionParameters._options.entityCacheTTL);
+        this._methodCache = new MethodCache(this._storage, `${rootKey}.MethodCache`, connectionParameters._options.methodCacheTTL);
+        this._optionCache = new OptionCache(this._storage, `${rootKey}.OptionCache`, connectionParameters._options.optionCacheTTL);
         this.NLWS = new Proxy(this, clientHandler);
 
-        this._transport = request;
-        this._traceAPICalls = false;
+        this._transport = connectionParameters._options.transport;
+        this._traceAPICalls = connectionParameters._options.traceAPICalls;
         this._observers = [];
+        this._refreshClient = connectionParameters._options.refreshClient;
 
         // expose utilities
 
@@ -447,7 +514,7 @@ class Client {
      * 
      * @returns {string} the user agent string
      */
-    getUserAgentString() {
+    _getUserAgentString() {
         const version = this.sdk.getSDKVersion();
         return `${version.name}/${version.version} ${version.description}`;
     }
@@ -460,7 +527,7 @@ class Client {
      * @param {string} representation the expected representation ('xml', 'BadgerFish', or 'SimpleJson'). If not set, will use the current representation
      * @returns {XML.XtkObject} the object converted in the requested representation
      */
-    toRepresentation(xml, representation) {
+    _toRepresentation(xml, representation) {
         representation = representation || this._representation;
         if (representation == "xml")
             return xml;
@@ -478,7 +545,7 @@ class Client {
      * @param {string} representation the expected representation ('xml', 'BadgerFish', or 'SimpleJson'). If not set, will use the current representation
      * @returns {DOMElement} the object converted to XML
      */
-    fromRepresentation(rootName, entity, representation) {
+    _fromRepresentation(rootName, entity, representation) {
         representation = representation || this._representation;
         if (representation == "xml")
             return entity;
@@ -498,12 +565,12 @@ class Client {
      * @param {string} toRepresentation the target representation ('xml', 'BadgerFish', or 'SimpleJson'). If not set, will use the current representation
      * @returns {DOMElement} the converted object
      */
-    convertToRepresentation(entity, fromRepresentation, toRepresentation) {
+    _convertToRepresentation(entity, fromRepresentation, toRepresentation) {
         toRepresentation = toRepresentation || this._representation;
-        if (this.isSameRepresentation(fromRepresentation, toRepresentation))
+        if (this._isSameRepresentation(fromRepresentation, toRepresentation))
             return entity;
-        var xml = this.fromRepresentation("root", entity, fromRepresentation);
-        entity = this.toRepresentation(xml, toRepresentation);
+        var xml = this._fromRepresentation("root", entity, fromRepresentation);
+        entity = this._toRepresentation(xml, toRepresentation);
         return entity;
     }
 
@@ -515,7 +582,7 @@ class Client {
      * @param {string} rep2 the second representation ('xml', 'BadgerFish', or 'SimpleJson')
      * @returns a boolean indicating if the 2 representations are the same or not
      */
-    isSameRepresentation(rep1, rep2) {
+    _isSameRepresentation(rep1, rep2) {
         if (!rep1 || !rep2) throw CampaignException.INVALID_REPRESENTATION(undefined, "Cannot compare to undefined representation");
         if (rep1 != "xml" && rep1 != "SimpleJson" && rep1 != "BadgerFish") throw CampaignException.INVALID_REPRESENTATION(rep1, "Cannot compare to invalid representation");
         if (rep2 != "xml" && rep2 != "SimpleJson" && rep2 != "BadgerFish") throw CampaignException.INVALID_REPRESENTATION(rep2, "Cannot compare to invalid representation");
@@ -575,6 +642,17 @@ class Client {
         if (credentialsType == "AnonymousUser")
             return true;
 
+        // When using bearer token authentication we are considered logged only after
+        // the bearer token has been converted into session token and security token
+        // by method xtk:session#BearerTokenLogon
+        if( credentialsType == "BearerToken")
+            return this._sessionToken != undefined &&
+                   this._sessionToken != null &&
+                   this._sessionToken != "" &&
+                   this._securityToken != undefined &&
+                   this._securityToken != null &&
+                   this._securityToken != "";
+
         // with session token authentication, we do not expect a security token
         // with security token authentication, we do not expect a session token
         const needsSecurityToken = credentialsType != "SessionToken";
@@ -594,44 +672,80 @@ 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) {
-        const soapCall = new SoapMethodCall(this._transport, urn, method, this._sessionToken, this._securityToken, this.getUserAgentString());
+    _prepareSoapCall(urn, method, internal) {
+        const soapCall = new SoapMethodCall(this._transport, urn, method, this._sessionToken, this._securityToken, this._getUserAgentString());
         soapCall.internal = !!internal;
         return soapCall;
     }
 
     /**
-     * After a SOAP method call has been prepared with 'prepareSoapCall', and parameters have been added,
+     * Retry a a SOAP call
+     *
+     * @private
+     * @return {SOAP.SoapMethodCall} a SoapMethodCall to retry
+     * parameters should be set
+     */
+    async _retrySoapCall(soapCall) {
+        soapCall.retry = false;
+        var newClient = await this._refreshClient(this); 
+        soapCall.finalize(newClient._soapEndPoint(), newClient);
+        if (this._traceAPICalls) {
+            const safeCallData = Util.trim(soapCall.request.data);
+            console.log(`RETRY SOAP//request ${safeCallData}`);
+        }
+        await soapCall.execute();
+        if (this._traceAPICalls) {
+            const safeCallResponse = Util.trim(soapCall.response);
+            console.log(`SOAP//response ${safeCallResponse}`);
+        }
+        return;
+    }
+
+    /**
+     *  SOAP Endpoint
+     *
+     * @private
+     * @return {string} soap call End point
+     */
+    _soapEndPoint() {
+        return this._connectionParameters._endpoint + "/nl/jsp/soaprouter.jsp";
+    }
+    /**
+     * After a SOAP method call has been prepared with '_prepareSoapCall', and parameters have been added,
      * this function actually executes the SOAP call
      * 
      * @private
      * @param {SOAP.SoapMethodCall} soapCall the SOAP method to call
      */
-    makeSoapCall(soapCall) {
+    _makeSoapCall(soapCall) {
         const that = this;
         if (soapCall.requiresLogon() && !that.isLogged())
             throw CampaignException.NOT_LOGGED_IN(soapCall, `Cannot execute SOAP call ${soapCall.urn}#${soapCall.methodName}: you are not logged in. Use the Logon function first`);
-        var soapEndpoint = that._connectionParameters._endpoint + "/nl/jsp/soaprouter.jsp";
-        soapCall.finalize(soapEndpoint);
+        soapCall.finalize(this._soapEndPoint());
         
         const safeCallData = Util.trim(soapCall.request.data);
         if (that._traceAPICalls)
             console.log(`SOAP//request ${safeCallData}`);
-        that._notifyObservers((observer) => { observer.onSOAPCall && observer.onSOAPCall(soapCall, safeCallData); });
+        that._notifyObservers((observer) => observer.onSOAPCall && observer.onSOAPCall(soapCall, safeCallData) );
         
         return soapCall.execute()
             .then(() => {
                 const safeCallResponse = Util.trim(soapCall.response);
                 if (that._traceAPICalls)
                     console.log(`SOAP//response ${safeCallResponse}`);
-                that._notifyObservers((observer) => { observer.onSOAPCallSuccess && observer.onSOAPCallSuccess(soapCall, safeCallResponse); });
+                that._notifyObservers((observer) => observer.onSOAPCallSuccess && observer.onSOAPCallSuccess(soapCall, safeCallResponse) );
                 return Promise.resolve();
             })
             .catch((ex) => {
                 if (that._traceAPICalls)
                     console.log(`SOAP//failure ${ex.toString()}`);
-                that._notifyObservers((observer) => { observer.onSOAPCallFailure && observer.onSOAPCallFailure(soapCall, ex); });
-                return Promise.reject(ex);
+                that._notifyObservers((observer) => observer.onSOAPCallFailure && observer.onSOAPCallFailure(soapCall, ex) );
+                // Call session expiration callback in case of 401
+                if (ex.statusCode == 401 && that._refreshClient && soapCall.retry) {
+                    return this._retrySoapCall(soapCall);
+                }
+                else
+                    return Promise.reject(ex);
             });
     }
 
@@ -649,7 +763,7 @@ class Client {
 
         // Clear session token cookie to ensure we're not inheriting an expired cookie. See NEO-26589
         if (credentials._type != "SecurityToken" && typeof document != "undefined") {
-            document.cookie = '__sessiontoken=;path=/;'
+            document.cookie = '__sessiontoken=;path=/;';
         }
         if (credentials._type == "SessionToken" || credentials._type == "AnonymousUser") {
             that._sessionInfo = undefined;
@@ -657,29 +771,37 @@ class Client {
             that._sessionToken = credentials._sessionToken;
             that._securityToken = "";
             that.application = new Application(that);
+            return Promise.resolve();
         }
-        else if (credentials._type == "SecurityToken") {
-            that._sessionInfo = undefined;
+        else if (credentials._type == "SecurityToken") { 
+           that._sessionInfo = undefined;
             that._installedPackages = {};
             that._sessionToken = "";
             that._securityToken = credentials._securityToken;
             that.application = new Application(that);
+            return Promise.resolve();
         }
-        else if (credentials._type == "UserPassword") {
-            const user = credentials._getUser();
-            const password = credentials._getPassword();
-
-            const soapCall = this.prepareSoapCall("xtk:session", "Logon");
-            soapCall.writeString("login", user);
-            soapCall.writeString("password", password);
-            var parameters = null;
-            if (this._connectionParameters._options.rememberMe) {
-                parameters = soapCall.createElement("parameters");
-                parameters.setAttribute("rememberMe", "true");
+        else if (credentials._type == "UserPassword" || credentials._type == "BearerToken") {
+            const soapCall = that._prepareSoapCall("xtk:session", credentials._type === "UserPassword" ? "Logon" : "BearerTokenLogon");
+            // No retry for logon SOAP methods
+            soapCall.retry = false;
+            if (credentials._type == "UserPassword") {
+                const user = credentials._getUser();
+                const password = credentials._getPassword();
+                soapCall.writeString("login", user);
+                soapCall.writeString("password", password);
+                var parameters = null;
+                if (this._connectionParameters._options.rememberMe) {
+                    parameters = soapCall.createElement("parameters");
+                    parameters.setAttribute("rememberMe", "true");
+                }
+                soapCall.writeElement("parameters", parameters);
             }
-            soapCall.writeElement("parameters", parameters);
-            
-            return this.makeSoapCall(soapCall).then(function() {
+            else {
+                const bearerToken = credentials._bearerToken;
+                soapCall.writeString("bearerToken", bearerToken);
+            } 
+            return this._makeSoapCall(soapCall).then(function() {
                 const sessionToken = soapCall.getNextString();
                 
                 that._sessionInfo = soapCall.getNextDocument();
@@ -722,7 +844,7 @@ class Client {
      */
     getSessionInfo(representation) {
         representation = representation || this._representation;
-        return this.toRepresentation(this._sessionInfo, representation);
+        return this._toRepresentation(this._sessionInfo, representation);
     }
 
     /**
@@ -731,11 +853,10 @@ class Client {
     logoff() {
         var that = this;
         if (!that.isLogged()) return;
-        
         const credentials = this._connectionParameters._credentials;
         if (credentials._type != "SessionToken" && credentials._type != "AnonymousUser") {
-            var soapCall = that.prepareSoapCall("xtk:session", "Logoff");
-                return this.makeSoapCall(soapCall).then(function() {
+            var soapCall = that._prepareSoapCall("xtk:session", "Logoff");
+                return this._makeSoapCall(soapCall).then(function() {
                 that._sessionToken = "";
                 that._securityToken = "";
                 that.application = null;
@@ -757,13 +878,13 @@ 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 = undefined;
+        var value;
         if (useCache)
             value = this._optionCache.get(name);
         if (value === undefined) {
             const option = await this.NLWS.xtkSession.getOption(name);
-            value = this._optionCache.cache(name, option);
-            this._optionCache.cache(name, option);
+            value = this._optionCache.put(name, option);
+            this._optionCache.put(name, option);
         }
         return value;
     }
@@ -797,7 +918,7 @@ class Client {
         doc[attName] = value;
         return this.NLWS.xtkSession.write(doc).then(() => {
             // Once set, cache the value
-            this._optionCache.cache(name, [value, type]);
+            this._optionCache.put(name, [value, type]);
         });
     }
 
@@ -863,34 +984,38 @@ class Client {
     }
 
     /**
-     * Fetches an entity (GetEntityIfMoreRecent)
+     * Gets an entity, such as a schema, a source schema, a form, a navtree, etc. Each Campaign entity has a MD5 which is used to determine
+     * if an entity has changed or not. The GetEntityIfMoreRecent SOAP call can use this MD5 to avoid returning entities that did not 
+     * actually changed. Currently, the SDK, however is not able to use the MD5 and will perform a SOAP call every time the function is
+     * called and return the whole entity
      * 
-     * @private
      * @param {string} entityType is the type of entity requested, such as "xtk:schema", "xtk:srcSchema", "xtk:navtree", "xtk:form", etc.
      * @param {string} fullName is the fully qualified name of the entity (i.e. <namespace>:<name>)
      * @param {string} representation the expected representation, or undefined to set the default
-     * @return A DOM representation of the entity, or null if the entity is not found
+     * @param {boolean} internal indicates an "internal" call, i.e. a call performed by the SDK itself rather than the user of the SDK. For instance, the SDK will dynamically load schemas to find method definitions
+     * @return {XML.XtkObject} A DOM or JSON representation of the entity, or null if the entity is not found
      */
      async getEntityIfMoreRecent(entityType, fullName, representation, internal) {
         const that = this;
-        const soapCall = this.prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", internal);
+        const soapCall = this._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", internal);
         soapCall.writeString("pk", entityType + "|" + fullName);
         soapCall.writeString("md5", "");
         soapCall.writeBoolean("mustExist", false);
-        return this.makeSoapCall(soapCall).then(function() {
+        return this._makeSoapCall(soapCall).then(function() {
             var doc = soapCall.getNextDocument();
             soapCall.checkNoMoreArgs();
-            doc = that.toRepresentation(doc, representation);
+            doc = that._toRepresentation(doc, representation);
             return doc;
         });
     }
 
     /**
-     * Get a schema definition.
+     * Get a compiled schema (not a source schema) definition as a DOM or JSON object depending on hte current representation
      * 
      * @param {string} schemaId the schema id, such as "xtk:session", or "nms:recipient"
      * @param {string} representation an optional representation of the schema: "BadgerFish", "SimpleJson" or "xml". If not set, we'll use the client default representation
-     * @returns {*} the schema definition, as either a DOM document or a JSON object
+     * @param {boolean} internal indicates an "internal" call, i.e. a call performed by the SDK itself rather than the user of the SDK. For instance, the SDK will dynamically load schemas to find method definitions
+     * @returns {XML.XtkObject}  the schema definition, as either a DOM document or a JSON object
      */
     async getSchema(schemaId, representation, internal) {
         var that = this;
@@ -901,7 +1026,7 @@ class Client {
         if (entity)
             that._entityCache.put("xtk:schema", schemaId, entity);
 
-        entity = that.toRepresentation(entity, representation);
+        entity = that._toRepresentation(entity, representation);
         return entity;
     }
 
@@ -910,7 +1035,7 @@ class Client {
      * 
      * @param {string} enumName
      * @param {string} optionalStartSchemaOrSchemaName
-     * @returns the enumeration definition in the current representation
+     * @returns {XML.XtkObject} the enumeration definition in the current representation
      */
     async getSysEnum(enumName, optionalStartSchemaOrSchemaName) {
 
@@ -967,7 +1092,7 @@ class Client {
         var schemaName = schema.getAttribute("name");
         var method = that._methodCache.get(schemaId, methodName);
         if (!method) {
-            this._methodCache.cache(schema);
+            this._methodCache.put(schema);
             method = that._methodCache.get(schemaId, methodName);
         }
         if (!method)
@@ -975,7 +1100,7 @@ class Client {
         // console.log(method.toXMLString());
 
         var urn = that._methodCache.getSoapUrn(schemaId, methodName);
-        var soapCall = that.prepareSoapCall(urn, methodName);
+        var soapCall = that._prepareSoapCall(urn, methodName);
 
         const isStatic = DomUtil.getAttributeAsBoolean(method, "static");
         var object = callContext.object;
@@ -984,7 +1109,7 @@ class Client {
                 throw CampaignException.SOAP_UNKNOWN_METHOD(schemaId, methodName, `Cannot call non-static method '${methodName}' of schema '${schemaId}' : no object was specified`);
 
             const rootName = schemaId.substr(schemaId.indexOf(':') + 1);
-            object = that.fromRepresentation(rootName, object);
+            object = that._fromRepresentation(rootName, object);
             soapCall.writeDocument("document", object);
         }
 
@@ -994,7 +1119,7 @@ class Client {
             var param = DomUtil.getFirstChildElement(params, "param");
             var paramIndex = 0;
             while (param) {
-                const inout = DomUtil.getAttributeAsString(param, "inout");
+                   const inout = DomUtil.getAttributeAsString(param, "inout");
                 if (!inout || inout=="in") {
                     const type = DomUtil.getAttributeAsString(param, "type");
                     const paramName = DomUtil.getAttributeAsString(param, "name");
@@ -1032,7 +1157,7 @@ class Client {
                             const index = xtkschema.indexOf(":");
                             docName = xtkschema.substr(index+1);
                         }
-                        var xmlValue = that.fromRepresentation(docName, paramValue);
+                        var xmlValue = that._fromRepresentation(docName, paramValue);
                         if (type == "DOMDocument")
                             soapCall.writeDocument(paramName, xmlValue);
                         else
@@ -1045,13 +1170,13 @@ class Client {
             }
         }
         
-        return that.makeSoapCall(soapCall).then(function() {
+        return that._makeSoapCall(soapCall).then(function() {
             if (!isStatic) {
                 // Non static methods, such as xtk:query#SelectAll return a element named "entity" which is the object itself on which
                 // the method is called. This is the new version of the object (in XML form)
                 const entity = soapCall.getEntity();
                 if (entity) {
-                    callContext.object = that.toRepresentation(entity);
+                    callContext.object = that._toRepresentation(entity);
                 }
             }
 
@@ -1082,7 +1207,7 @@ class Client {
                             returnValue = soapCall.getNextDate();
                         else if (type == "DOMDocument") {
                             returnValue = soapCall.getNextDocument();
-                            returnValue = that.toRepresentation(returnValue);
+                            returnValue = that._toRepresentation(returnValue);
                             if (schemaId === "xtk:queryDef" && methodName === "ExecuteQuery" && paramName === "output") {
                                 // https://github.com/adobe/acc-js-sdk/issues/3
                                 // Check if query operation is "getIfExists". The "object" variable at this point
@@ -1102,32 +1227,27 @@ class Client {
                         }
                         else if (type == "DOMElement") {
                             returnValue = soapCall.getNextElement();
-                            returnValue = that.toRepresentation(returnValue);
+                            returnValue = that._toRepresentation(returnValue);
                         }
                         else {
                             // type can reference a schema element. The naming convension is that the type name
                             // is {schemaName}{elementNameCamelCase}. For instance, the type "sessionUserInfo"
                             // matches the "userInfo" element of the "xtkSession" schema
+                            let element;
                             if (type.substr(0, schemaName.length) == schemaName) {
                                 const shortTypeName = type.substr(schemaName.length, 1).toLowerCase() + type.substr(schemaName.length + 1);
-                                var element = DomUtil.getFirstChildElement(schema, "element");
+                                element = DomUtil.getFirstChildElement(schema, "element");
                                 while (element) {
                                     if (element.getAttribute("name") == shortTypeName) {
                                         // Type found in schema: Process as a DOM element
                                         returnValue = soapCall.getNextElement();
-                                        returnValue = that.toRepresentation(returnValue);
+                                        returnValue = that._toRepresentation(returnValue);
                                         break;
                                     }
-                                    element = DomUtil.getNextSiblingElement(element, "element")
+                                    element = DomUtil.getNextSiblingElement(element, "element");
                                 }
 
                             }
-    /*                    else if (type == "sessionUserInfo") {
-                            returnValue = soapCall.getNextElement();
-                            if (that._representation == "BadgerFish")
-                                returnValue = DomUtil.toJSON(returnValue);
-                        }
-                        */
                             if (!element)
                                 throw CampaignException.UNEXPECTED_SOAP_RESPONSE(soapCall, `Unsupported return type '${type}' for parameter '${paramName}' of method '${methodName}' of schema '${schemaId}'`);
                         }
@@ -1147,23 +1267,23 @@ class Client {
         request.method = request.method || "GET";
         request.headers = request.headers || [];
         if (!request.headers['User-Agent'])
-            request.headers['User-Agent'] = this.getUserAgentString();
+            request.headers['User-Agent'] = this._getUserAgentString();
         try {
             const safeCallData = Util.trim(request.data);
             if (this._traceAPICalls)
                 console.log(`HTTP//request ${request.method} ${request.url}${safeCallData ? " " + safeCallData : ""}`);
-            this._notifyObservers((observer) => { observer.onHTTPCall && observer.onHTTPCall(request, safeCallData); });
+            this._notifyObservers((observer) => observer.onHTTPCall && observer.onHTTPCall(request, safeCallData) );
             const body = await this._transport(request);
 
             const safeCallResponse = Util.trim(body);
             if (this._traceAPICalls)
                 console.log(`HTTP//response${safeCallResponse ? " " + safeCallResponse : ""}`);
-            this._notifyObservers((observer) => { observer.onHTTPCallSuccess && observer.onHTTPCallSuccess(request, safeCallResponse); });
+            this._notifyObservers((observer) => observer.onHTTPCallSuccess && observer.onHTTPCallSuccess(request, safeCallResponse) );
             return body;
         } catch(err) {
             if (this._traceAPICalls)
                 console.log("HTTP//failure", err);
-            this._notifyObservers((observer) => { observer.onHTTPCallFailure && observer.onHTTPCallFailure(request, err); });
+            this._notifyObservers((observer) => observer.onHTTPCallFailure && observer.onHTTPCallFailure(request, err) );
             throw makeCampaignException({ request:request, reqponse:err.response }, err);
         }
     }
@@ -1180,7 +1300,7 @@ class Client {
         };
         const body = await this._makeHttpCall(request);
         const xml = DomUtil.parse(body);
-        const result = this.toRepresentation(xml);
+        const result = this._toRepresentation(xml);
         return result;
     }
 
@@ -1208,7 +1328,7 @@ class Client {
             const timestamp = lines[1].trim();
             if (timestamp != "") root.setAttribute("timestamp", timestamp);
         }
-        const result = this.toRepresentation(doc);
+        const result = this._toRepresentation(doc);
         return result;
     }
 
@@ -1233,8 +1353,8 @@ class Client {
         var status = lines[0].trim();
         if (status != "") root.setAttribute("status", status);
         
-        var rtCount = undefined;
-        var threshold = undefined;
+        var rtCount;
+        var threshold;
         if (status == "Error") {
             const error = lines.length > 1 ? lines[1] : "";
             root.setAttribute("error", error);
@@ -1263,10 +1383,9 @@ class Client {
         }
         if (rtCount !== undefined && rtCount.trim() != "") root.setAttribute("eventQueueSize", rtCount);
         if (threshold !== undefined && rtCount.trim() != "") root.setAttribute("eventQueueMaxSize", threshold);
-        const result = this.toRepresentation(doc);
+        const result = this._toRepresentation(doc);
         return result;
     }
-
 }
 
 
@@ -1275,3 +1394,5 @@ Client.CampaignException = CampaignException;
 exports.Client = Client;
 exports.Credentials = Credentials;
 exports.ConnectionParameters = ConnectionParameters;
+
+})();