@adobe/acc-js-sdk 1.1.19 → 1.1.20

package/docs/caches.html

@@ -43,10 +43,35 @@ client.clearAllCaches();
 <p>It's possible to disable persistent caches using the <b>noStorage</b> connection option.</p>
 
 <p>It is also possible to setup one's own persistent cache, by passing a <b>storage</b> object as a connection option.
-  This object should implement 3 methods: <b>getItem</b>, <b>setItem</b>, and <b>removeItem</b> (synchronous)</p>
+   See the "Custom Storage" section below for more details.</p>
 
 <p>Additionally, since version 1.1.18, the <b>storage</b> object should also support the for...in operator to iterate through its keys</p>
 
+
+<h1>Cache root key</h1>
+
+<p>
+  By default, the SDK will prefix all cache entity by a root key, which is made of the SDK version and the instance URL. 
+  It is possible to change this using the `cacheRootKey` connection parameter.
+</p>
+<ul>
+  <li>* `default` or undefined: default prefix</li>
+  <li>* `none`: no prefix</li>
+</ul>
+
+<h1>Custom storage</h1>
+
+A custom storage is a JavaScript object with the following functions:
+* `getItem` is given a cache key and should return the corresponding value
+* `setItem` is given a cache key and value and should cache the corresponding key/value pair
+
+Optionally, the storage object can contain the following
+* `removeItem` is given a cache key and should remove the corresponding key/value pair from the cache
+* The storage object should also be iterable using the for..in construct
+
+The get/set/remove item function can be either synchronous or asynchronous, i.e. can optionally return a promise.
+
+
 <h1>Auto-refresh caches</h1>
 
 <p>The SDK includes a mechnism to maintain the schemas and options caches up-to-date by polling the Campaign server on a

package/docs/changeLog.html

@@ -3,6 +3,26 @@ layout: page
 title: Change Log
 ---
 
+<section class="changelog"><h1>Version 1.1.20</h1>
+  <h2>2023/01/11</h2>
+  
+  <li>
+    Upgrade json5 dependency from 2.2.1 to 2.2.3 to fix a vulnerability
+  </li>
+
+  <li>
+    Add support for asynchronous caches. The signature of cache objects (Cache, MethodCache,
+    OptionCache, XtkEntityCache, SafeStorage) have changed to asynchronous functions.
+    However, the delegate object used to configure custom caches now support either synchronous
+    or async results. See the <a href="https://opensource.adobe.com/acc-js-sdk/caches.html">Cache documentation for more details</a>
+  </li>
+  <li>
+    Ability to configure the prefix to use for the cached objects. Default to a string containing
+    the SDK version and instance domain.
+  </li>
+</section>
+
+
 <section class="changelog"><h1>Version 1.1.19</h1>
   <h2>2022/12/21</h2>
   

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -2876,9 +2876,9 @@
       "dev": true
     },
     "json5": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.1.tgz",
-      "integrity": "sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA==",
+      "version": "2.2.3",
+      "resolved": "https://artifactory.corp.adobe.com/artifactory/api/npm/npm-adobe-release/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
       "dev": true
     },
     "klaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "description": "ACC Javascript SDK",
   "main": "src/index.js",
   "homepage": "https://github.com/adobe/acc-js-sdk#readme",

package/src/cache.js

@@ -12,6 +12,8 @@ governing permissions and limitations under the License.
 (function() {
 "use strict";    
   
+const { Util } = require("./util");
+
 
 /**********************************************************************************
  * 
@@ -78,11 +80,11 @@ class SafeStorage {
    * @returns {Utils.CachedObject} the cached object, or undefined if not found. 
    *                               The storage serDeser fucntion will be used to deserialize the cached value
    */
-  getItem(key) {
+  async getItem(key) {
     if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
       return;
     const itemKey = `${this._rootKey}${key}`;
-    const raw = this._delegate.getItem(itemKey);
+    const raw = await Util.asPromise(this._delegate.getItem(itemKey));
     if (!raw)
       return undefined;
     try {
@@ -98,28 +100,28 @@ class SafeStorage {
    * @param {Utils.CachedObject} json the object to cache
    *                               The storage serDeser fucntion will be used to serialize the cached value
    */
-   setItem(key, json) {
+  async setItem(key, json) {
     if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
       return;
     try {
       //if (json && typeof json === "object") {
       const raw = this._serDeser(json, true);
-      this._delegate.setItem(`${this._rootKey}${key}`, raw);
+      await Util.asPromise(this._delegate.setItem(`${this._rootKey}${key}`, raw));
       return;
     } catch(ex) { /* Ignore errors in safe class */
+      await this.removeItem(key);
     }
-    this.removeItem(key);
   }
 
   /**
    * Removes an item from the storage
    * @param {string} key the item key (relative to the root key)
    */
-  removeItem(key) {
+  async removeItem(key) {
     if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
       return;
     try {
-      this._delegate.removeItem(`${this._rootKey}${key}`);
+      await this._delegate.removeItem(`${this._rootKey}${key}`);
     } catch(ex) { /* Ignore errors in safe class */
     }
   }
@@ -178,7 +180,12 @@ class Cache {
       this._makeKeyFn = makeKeyFn || ((x) => x);
       this._cache = {};
       // timestamp at which the cache was last cleared
-      this._lastCleared = this._loadLastCleared();
+      // The variable is set with special "null" value to indicate that the
+      // timestamp at which the cache was clear is not known, and therefore
+      // needs to be fetched. It will be fetched dynamically when needed, 
+      // resulting in either an undefined value (cache was never cleared)
+      // or a actual timestamp.
+      this._lastCleared = null;
       this._stats = {
         reads: 0,
         writes: 0,
@@ -192,53 +199,57 @@ class Cache {
   }
 
   // Load timestamp at which the cache was last cleared
-  _loadLastCleared() {
-    const json = this._storage.getItem("lastCleared");
+  async _loadLastCleared() {
+    const json = await this._storage.getItem("lastCleared");
     return json ? json.timestamp : undefined;
   }
 
-  _saveLastCleared() {
+  async _saveLastCleared() {
     const now = Date.now();
     this._lastCleared = now;
-    this._storage.setItem("lastCleared", { timestamp: now});
+    await this._storage.setItem("lastCleared", { timestamp: now});
   }
 
   // Load from local storage
-  _load(key) {
+  async _load(key) {
     this._stats.loads = this._stats.loads + 1;
-    const json = this._storage.getItem(key);
+    // A null value here indicates that we have not yet loaded the
+    // timestamp at which the cache was cleared last
+    if (this._lastCleared === null) 
+      this._lastCleared = await this._loadLastCleared();
+    const json = await this._storage.getItem(key);
     if (!json || !json.cachedAt || json.cachedAt <= this._lastCleared) {
-      this._storage.removeItem(key);
+      await this._storage.removeItem(key);
       return;
     }
     return json;
   }
 
   // Save to local storage
-  _save(key, cached) {
+  async _save(key, cached) {
     this._stats.saves = this._stats.saves + 1;
-    this._storage.setItem(key, cached);
+    await this._storage.setItem(key, cached);
   }
 
   // Remove from local storage
-  _remove(key) {
-    this._storage.removeItem(key);
+  async _remove(key) {
+    await this._storage.removeItem(key);
   }
 
-  _getIfActive(key) {
+  async _getIfActive(key) {
     // In memory cache?
     var cached = this._cache[key];
     var memoryHit = !!cached;
     // Local storage ?
     if (!cached) {
-      cached = this._load(key);
+      cached = await this._load(key);
       this._cache[key] = cached;
     }
     if (!cached) 
       return undefined;
     if (cached.expiresAt <= Date.now()) {
       delete this._cache[key];
-      this._remove(key);
+      await this._remove(key);
       return undefined;
     }
     this._stats.memoryHits = this._stats.memoryHits + 1;
@@ -251,10 +262,10 @@ class Cache {
    * @param {*} key the key or keys of the value to retreive
    * @returns {*} the cached value, or undefined if not found
    */
-  get() {
+  async get() {
       this._stats.reads = this._stats.reads + 1;
       const key = this._makeKeyFn.apply(this, arguments);
-      const cached = this._getIfActive(key);
+      const cached = await this._getIfActive(key);
       return cached;
   }
 
@@ -264,7 +275,7 @@ class Cache {
    * @param {*} value the value to cache
    * @returns {CachedObject} a cached object containing the cached value
    */
-   put() {
+   async put() {
       this._stats.writes = this._stats.writes + 1;
       const value = arguments[arguments.length -1];
       const key = this._makeKeyFn.apply(this, arguments);
@@ -272,7 +283,7 @@ class Cache {
       const expiresAt = now + this._ttl;
       const cached = new CachedObject(value, now, expiresAt);
       this._cache[key] = cached;
-      this._save(key, cached);
+      await this._save(key, cached);
       return cached;
   }
   
@@ -280,20 +291,20 @@ class Cache {
    * Removes everything from the cache. It does not directly removes data from persistent storage if there is, but it marks the cache
    * as cleared so that subsequent get operation will not actually return any data cached in persistent storage
    */
-  clear() {
+  async clear() {
       this._stats.clears = this._stats.clears + 1;
       this._cache = {};
-      this._saveLastCleared();
+      await this._saveLastCleared();
   }
 
   /**
    * Remove a key from the cache
    * @param {string} key the key to remove
    */
-  remove(key) {
+  async remove(key) {
       this._stats.removals = this._stats.removals + 1;
       delete this._cache[key];
-      this._remove(key);
+      await this._remove(key);
   }
 }
 

package/src/cacheRefresher.js

@@ -47,7 +47,7 @@ governing permissions and limitations under the License.
          * @param {string} name is the propertie name
          * @param {string} rawValue string value
          */
-        put(name, rawValue) {
+        async put(name, rawValue) {
             return super.put(name, { value: rawValue });
         }
 
@@ -57,8 +57,8 @@ governing permissions and limitations under the License.
          * @param {string} name the propertie name
          * @returns {*} the value
          */
-        get(name) {
-            const option = super.get(name);
+        async get(name) {
+            const option = await super.get(name);
             return option ? option.value : undefined;
         }
     }
@@ -149,13 +149,13 @@ governing permissions and limitations under the License.
             const soapCall = this._client._prepareSoapCall("xtk:session", "GetModifiedEntities", true, true, this._connectionParameters._options.extraHttpHeaders);
 
             if (this._lastTime === undefined) {
-                const storedTime = this._refresherStateCache.get("time");
+                const storedTime = await this._refresherStateCache.get("time");
                 if (storedTime != undefined) {
                     this._lastTime = storedTime;
                 }
             }
             if (this._buildNumber === undefined) {
-                const storedBuildNumber = this._refresherStateCache.get("buildNumber");
+                const storedBuildNumber = await this._refresherStateCache.get("buildNumber");
                 if (storedBuildNumber != undefined) {
                     this._buildNumber = storedBuildNumber;
                 }
@@ -192,37 +192,37 @@ governing permissions and limitations under the License.
             // 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 
             // This is an internal SOAP call that cannot be intercepted by observers onBeforeCall / onAfterCall
-            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, event);
-                    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._client._trackEvent('CACHE_REFRESHER//abort', undefined, {
-                            cacheSchemaId: this._cacheSchemaId,
-                            error: ex,
-                        });
-                        this.stopAutoRefresh();
-                    } else {
-                        throw ex;
-                    }
-                });
+            try {
+                await this._client._makeSoapCall(soapCall);
+                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");
+                await that._refresh(doc, event);
+                await that._refresherStateCache.put("time", that._lastTime);
+                await 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._client._trackEvent('CACHE_REFRESHER//abort', undefined, {
+                        cacheSchemaId: this._cacheSchemaId,
+                        error: ex,
+                    });
+                    this.stopAutoRefresh();
+                } else {
+                    throw ex;
+                }
+            };
         }
 
         // Refresh Cache : remove entities modified recently listed in xmlDoc
-        _refresh(xmlDoc, event) {
+        async _refresh(xmlDoc, event) {
             const clearCache = XtkCaster.asBoolean(DomUtil.getAttributeAsString(xmlDoc, "emptyCache"));
             const evicted = [];
             if (clearCache == true) {
-                this._cache.clear();
+                await this._cache.clear();
             } else {
                 var child = DomUtil.getFirstChildElement(xmlDoc, "entityCache");
                 while (child) {
@@ -230,7 +230,7 @@ governing permissions and limitations under the License.
                     const schemaId = DomUtil.getAttributeAsString(child, "schema");
                     if (schemaId === this._cacheSchemaId) {
                         evicted.push(schemaId);
-                        this._cache.remove(pkSchemaId);
+                        await this._cache.remove(pkSchemaId);
                         // Notify listeners to refresh in SchemaCache
                         if (schemaId === "xtk:schema") {
                             const schemaIds = pkSchemaId.split("|");

package/src/client.js

@@ -196,8 +196,7 @@ const clientHandler = (representation, headers, pushDownOptions) => {
                             var promise = callContext.client._callMethod(methodName, callContext, argumentsList);
                             return promise.then(function(optionAndValue) {
                                 const optionName = argumentsList[0];
-                                client._optionCache.put(optionName, optionAndValue);
-                                return optionAndValue;
+                                return client._optionCache.put(optionName, optionAndValue).then(() => optionAndValue);
                             });
                         }
                         // static method
@@ -308,6 +307,7 @@ class Credentials {
     * @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.
+    * @property {string} cacheRootKey - "default" or "none" - determine the prefix to use for the keys in the caches of schemas, options, etc.
     * @memberOf Campaign
  */
 
@@ -379,6 +379,7 @@ class ConnectionParameters {
         this._options.clientApp = options.clientApp;
         this._options.noSDKHeaders = !!options.noSDKHeaders;
         this._options.noMethodInURL = !!options.noMethodInURL;
+        this._options.cacheRootKey = options.cacheRootKey === undefined ? "default": options.cacheRootKey;
     }
 
     /**
@@ -645,7 +646,14 @@ class Client {
         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`;
+
+        // Determine the cache root key. There are 3 possible values:
+        // * no value or "default" is the default behavior, i.e. all cache keys are prefixed with "acc.js.sdk.${sdk.getSDKVersion().version}.${instanceKey}.cache."
+        // * "none" (or actually anything else for now), where cache keys are not prefixed by anything
+        const rootKeyType = connectionParameters._options.cacheRootKey;
+        let rootKey = "";
+        if (!rootKeyType || rootKeyType === "default")
+            rootKey = `acc.js.sdk.${sdk.getSDKVersion().version}.${instanceKey}.cache.`;
 
         // Clear storage cache if the sdk versions or the instances are different
         if (this._storage && typeof this._storage.removeItem === 'function') {
@@ -656,11 +664,11 @@ class Client {
           }
         }
 
-        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._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;
@@ -1447,11 +1455,11 @@ class Client {
     async getOption(name, useCache = true) {
       var value;
       if (useCache) {
-        value = this._optionCache.get(name);
+        value = await this._optionCache.get(name);
       }
       if (value === undefined) {
         const option = await this.NLWS.xtkSession.getOption(name);
-        value = this._optionCache.put(name, option);
+        value = await this._optionCache.put(name, option);
       }
       return value;
     }
@@ -1467,7 +1475,7 @@ class Client {
     async setOption(name, rawValue, description) {
         // First, read the current option value to make sure we have the right type
         await this.getOption(name, true);
-        const option = this._optionCache.getOption(name);
+        const option = await this._optionCache.getOption(name);
         // Note: option is never null or undefined there: Campaign will return a value of type 0 and value ""
         var type = option.type;
         var value = XtkCaster.as(rawValue, type);
@@ -1483,40 +1491,41 @@ class Client {
         if (description != null && description != undefined)
             doc.description = description;
         doc[attName] = value;
-        return this.NLWS.xtkSession.write(doc).then(() => {
-            // Once set, cache the value
-            this._optionCache.put(name, [value, type]);
-        });
+        await this.NLWS.xtkSession.write(doc);
+        // Once set, cache the value
+        await this._optionCache.put(name, [value, type]);
     }
 
     /**
      * Clears the options cache
      */
-    clearOptionCache() {
-        this._optionCache.clear();
+    async clearOptionCache() {
+        await this._optionCache.clear();
     }
 
     /**
      * Clears the method cache
      */
-    clearMethodCache() {
-        this._methodCache.clear();
+    async clearMethodCache() {
+        await this._methodCache.clear();
     }
 
     /**
      * Clears the entity cache
      */
-    clearEntityCache() {
-        this._entityCache.clear();
+    async clearEntityCache() {
+        await this._entityCache.clear();
     }
 
     /**
      * Clears all caches (options, methods, entities)
      */
-    clearAllCaches() {
-        this.clearEntityCache();
-        this.clearMethodCache();
-        this.clearOptionCache();
+    async clearAllCaches() {
+        return Promise.all([
+            this.clearEntityCache(),
+            this.clearMethodCache(),
+            this.clearOptionCache(),
+        ]);
     }
 
     /**
@@ -1629,7 +1638,7 @@ class Client {
      * @returns {XML.XtkObject}  the schema definition, as either a DOM document or a JSON object
      */
     async getSchema(schemaId, representation, internal) {
-        var entity = this._entityCache.get("xtk:schema", schemaId);
+        var entity = await this._entityCache.get("xtk:schema", schemaId);
         if (!entity) {
           entity = await this.getEntityIfMoreRecent("xtk:schema", schemaId, "xml", internal);
           if (entity) {
@@ -1638,8 +1647,8 @@ class Client {
                 // Ensure xtk:persist is present by loading the xtk:session schema
                 await this.getSchema("xtk:session", "xml", true);
             }
-            this._entityCache.put("xtk:schema", schemaId, entity);
-            this._methodCache.put(entity);
+            await this._entityCache.put("xtk:schema", schemaId, entity);
+            await this._methodCache.put(entity);
           }
         }
         entity = this._toRepresentation(entity, representation);
@@ -1714,24 +1723,24 @@ class Client {
             throw CampaignException.SOAP_UNKNOWN_METHOD(schemaId, methodName, `Schema '${schemaId}' not found`);
 
         // Lookup the method to call
-        var method = that._methodCache.get(methodSchemaId, methodName);
+        var method = await that._methodCache.get(methodSchemaId, methodName);
         if (!method) {
             // first char of the method name may be lower case (ex: nms:seedMember.getAsModel) but the methodName 
             // variable has been capitalized. Make an attempt to lookup method name without capitalisation
             const methodNameLC = methodName.substring(0, 1).toLowerCase() + methodName.substring(1);
-            method = that._methodCache.get(schemaId, methodNameLC);
+            method = await that._methodCache.get(schemaId, methodNameLC);
             if (method) methodName = methodNameLC;
         }
         if (!method) {
-            this._methodCache.put(schema);
-            method = that._methodCache.get(methodSchemaId, methodName);
+            await this._methodCache.put(schema);
+            method = await that._methodCache.get(methodSchemaId, methodName);
         }
         if (!method)
             throw CampaignException.SOAP_UNKNOWN_METHOD(schemaId, methodName, `Method '${methodName}' of schema '${schemaId}' not found`);
 
         // Compute the SOAP URN. Again, specically handle xtk:jobInterface as it's not a real schema. The actual entity schema
         // would be available as the entitySchemaId property of the callContext
-        var urn = schemaId !== 'xtk:jobInterface' ? that._methodCache.getSoapUrn(schemaId, methodName)
+        var urn = schemaId !== 'xtk:jobInterface' ? await that._methodCache.getSoapUrn(schemaId, methodName)
             : `xtk:jobInterface|${entitySchemaId}`;
 
         const isStatic = DomUtil.getAttributeAsBoolean(method, "static");

package/src/methodCache.js

@@ -75,8 +75,8 @@ class MethodCache extends Cache {
      * @deprecated
      * @param {Element} schema DOM document node represening the schema 
      */
-    cache(schema) {
-        return this.put(schema);
+    async cache(schema) {
+        return await this.put(schema);
     }
     
     /**
@@ -84,7 +84,7 @@ class MethodCache extends Cache {
      * 
      * @param {Element} schema DOM document node represening the schema 
      */
-    put(schema) {
+    async put(schema) {
         var namespace = DomUtil.getAttributeAsString(schema, "namespace");
         var name = DomUtil.getAttributeAsString(schema, "name");
         var impls = DomUtil.getAttributeAsString(schema, "implements");
@@ -103,7 +103,7 @@ class MethodCache extends Cache {
                 while (child) {
                     const methodName = DomUtil.getAttributeAsString(child, "name");
                     const cached = { method: child, urn: schemaId };
-                    super.put(schemaId, methodName, cached);
+                    await super.put(schemaId, methodName, cached);
                     child = DomUtil.getNextSiblingElement(child, "method");
                 }
             }
@@ -124,7 +124,7 @@ class MethodCache extends Cache {
                     let cached = this._cache[key].value;
                     cached = { method: cached.method, urn: urn };
                     const methodName = DomUtil.getAttributeAsString(cached.method, "name");
-                    super.put(schemaId, methodName, cached);
+                    await super.put(schemaId, methodName, cached);
                 }
             }
         }
@@ -137,8 +137,8 @@ class MethodCache extends Cache {
      * @param {string} methodName the method name
      * @returns {Campaign.SoapMethodDefinition} the method definition, or undefined if the schema or the method is not found
      */
-    get(schemaId, methodName) {
-        const cached = super.get(schemaId, methodName);
+    async get(schemaId, methodName) {
+        const cached = await super.get(schemaId, methodName);
         return cached ? cached.method : undefined;
     }
 
@@ -149,8 +149,8 @@ class MethodCache extends Cache {
      * @param {string} methodName the method name
      * @returns {string} the URN (or Soap action header), or undefined if the schema or the method is not found
      */
-    getSoapUrn(schemaId, methodName) {
-        const cached = super.get(schemaId, methodName);
+    async getSoapUrn(schemaId, methodName) {
+        const cached = await super.get(schemaId, methodName);
         return cached ? cached.urn : undefined;
     }
 }