@adobe/acc-js-sdk 1.1.4 → 1.1.7

package/.eslintrc.js

@@ -4,12 +4,14 @@ module.exports = {
         "commonjs": true,
         "es2021": true,
         "node": true,
-        "jest": true
+        "jest": true,
+        circus: true
     },
     "extends": "eslint:recommended",
     "parserOptions": {
         "ecmaVersion": 12
     },
     "rules": {
+        "indent": ["error", 2],
     }
 };

package/CHANGELOG.md

@@ -5,8 +5,25 @@ This is a node.js SDK for Campaign API. It exposes the Campaign API exactly like
 
 # Changelog 
 
+## Version 1.1.7
+_2022_08_30_
+
+* New listener interface to be notified of internal events from the SDK. Can be used to integrate with observability frameworks. See the "Observers" section of the README file.
+* Experimental file upload feature. Will require server-side changes to work, and is currently limited to be used with browsers only.
+
+
+## Version 1.1.6
+_2022_08_19_
+
+* New auto-refresh mechanism to keep schemas and option caches up-to-date. See `client.startRefreshCaches` and `client.stopRefreshCaches` functions.
+
+## Version 1.1.5
+_2022/07/07__
+
+* The SOAP method name was not showing up properly in the Chrome console
+
 ## Version 1.1.4
-_2022/06/xx_
+_2022/07/07__
 
 * Added `application.version` which returns the server version in the format major.minor.servicePack (ex: 8.2.10)
 * Added the ability to push down parameters to the SOAP and transport layers. See the pushDown section of the readme file.

package/README.md

@@ -693,6 +693,30 @@ It's possible to disable persistent caches using the `noStorage` connection opti
 It is also possible to setup one's own persistent cache, by passing a `storage` object as a connection option. This object should implement 3 methods: `getItem`, `setItem`, and `removeItem` (synchronous)
 
 
+## Auto-refresh caches
+
+The SDK includes a mechnism to maintain the schemas and options caches up-to-date by polling the Campaign server on a regular basis (10 seconds by default). The server returns the list of entities (schemas or options) which have changed since they were cached, and the client removes them from the cache. When a schema changes, the corresponding methods are also removed from the method cache.
+
+This mechanism is not activate by default but can be activated or deactivated by the following functions
+
+```js
+client.startRefreshCaches(30000);   // activate cache auto-refresh mechanism every 30s
+client.stopRefreshCaches();         // de-activate cache auto-refresh
+```
+
+This mechanism is based on the `xtk:session#GetModifiedEntities` SOAP method which is only available in Campaign 8.4 and above only. For other builds of Campaign, the auto-refresh mechanism will not do anything. 
+
+The following changes are handled:
+* If the build number has changed, the whole cache is cleared
+* If more than 10 schemas or options have changed, the whole cache is cleared
+* if less than 10 schemas or options have changed, only those entities are removed from the cache
+
+
+The refresh mechanism includes the following guardrails
+* Both xtk:option and xtk:schema caches are refreshed every n seconds. To avoid issuing two API calls at the same time to the server, the schema cache refresh call is delayed by a few seconds. In the future this delay may change.
+* If the xtk:session#GetModifiedEntities API is not available, the auto refresh mechanism will silently stop automatically
+* If an error occurs while trying to refresh, a warning will be logged to the JavaScript console but the auto refresh will not be stopped. 
+
 ## Passwords
 
 External account passwords can be decrypted using a Cipher. This function is deprecated since version 1.0.0 since it's not guaranteed to work in future versions of Campaign (V8 and above)
@@ -794,10 +818,10 @@ NLWS.xml.pushDown({ timeout: 60000, foo: 'bar' }).xtkBuilder.installPackage(dom)
 ```
 
 ## Troubleshooting
-In the version 1.1.4 of the SDK, we are automatically adding the SOAP method name in the URL in order to simplify troubleshooting. Normally, all SOAP method calls are make to the soaprouter.jsp endpoint, which makes it difficult to understand which actual API call is being made.
+In the version 1.1.5 of the SDK, we are automatically adding the SOAP method name in the URL in order to simplify troubleshooting. Normally, all SOAP method calls are make to the soaprouter.jsp endpoint, which makes it difficult to understand which actual API call is being made.
 In fact the SOAP call name is available via the SOAPAction HTTP header, but it's usually not immediatelly visible.
 
-The SOAP calls URLs are now formed like this: `http://acc-sdk:8080/nl/jsp/soaprouter.jsp?xtk:queryDef#ExecuteQuery` where the SOAP method name is added as a query parameter. Campaign server ignores this parameter.
+The SOAP calls URLs are now formed like this: `http://acc-sdk:8080/nl/jsp/soaprouter.jsp?xtk:queryDef:ExecuteQuery` where the SOAP method name is added as a query parameter. Campaign server ignores this parameter.
 
 This can be disabled using the `noMethodInURL` connection parameter
 
@@ -1087,6 +1111,34 @@ The `soapCall` parameter is a `SoapMethodCall` object which describes the SOAP c
 * `response` is a string containing the XML result of the SOAP call if the call was successful. It may be undefined if the call was not executed yet or if the call failed
 
 
+In version 1.1.7, the observer interface is extended to listen for internal events of the SDK. The `event` function of the observer, if it exist will be call for each SDK event with 2 parameters: the event itself, and for some events, a parent event. For instance a SOAP response event will have the SOAP request for a parent event.
+```js
+client.registerObserver({
+    event: (event, parentEvent) => { ... },
+});
+```
+
+The following events are available
+
+| event name | comment / description |
+|----|----|
+| SDK//logon | A client logs on |
+| SDK//logoff | A client logs off |
+| CACHE//stats | Regularly sends stats about internal caches |
+| SOAP//request | The SDK executes a SOAP request |
+| SOAP//response | The SDK processes the successful response of a SOAP request |
+| SOAP//failure | A SOAP request failed |
+| HTTP//request | The SDK executes an HTTP request |
+| HTTP//response | The SDK processes the successful response of an HTTP request |
+| HTTP//failure | An HTTP request failed |
+| CACHE_REFRESHER//start | A cache auto-refresher starts |
+| CACHE_REFRESHER//stop | A cache auto-refresher stops |
+| CACHE_REFRESHER//tick | A cache auto-refresh occurs |
+| CACHE_REFRESHER//loggedOff | The cache auto-refresh was triggered whereas the client was logged off |
+| CACHE_REFRESHER//error | The cache auto-refresh failed. Auto-refresh will continue. |
+| CACHE_REFRESHER//abort | The cache auto-refresh failed because the server does not support it. Auto-refresh will stop. |
+| CACHE_REFRESHER//response | The server responded to an auto-refresh request |
+
 # Configuration
 
 ## Tracking all SOAP calls
@@ -1504,8 +1556,6 @@ var event = await query.executeQuery();
 console.log(`>> Event: ${JSON.stringify(event)}`);
 ```
 
-
-
 # Application
 
 The `application` object can be obtained from a client, and will mimmic the Campaing `application` object (https://docs.adobe.com/content/help/en/campaign-classic/technicalresources/api/c-Application.html)

package/compile.js

@@ -36,6 +36,7 @@ var resources = [
     { name: "./xtkEntityCache.js" },
     { name: "./methodCache.js" },
     { name: "./optionCache.js" },
+    { name: "./cacheRefresher.js" },
     { name: "./soap.js" },
     { name: "./crypto.js" },
     { name: "./application.js" },

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.4",
+  "version": "1.1.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@adobe/acc-js-sdk",
-      "version": "1.1.4",
+      "version": "1.1.7",
       "license": "ISC",
       "dependencies": {
         "axios": "^0.25.0",
@@ -1402,14 +1402,21 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001301",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001301.tgz",
-      "integrity": "sha512-csfD/GpHMqgEL3V3uIgosvh+SVIQvCh43SNu9HRbP1lnxkKm1kjDG4f32PP571JplkLjfS+mg2p1gxR7MYrrIA==",
+      "version": "1.0.30001378",
+      "resolved": "https://artifactory.corp.adobe.com/artifactory/api/npm/npm-adobe-release/caniuse-lite/-/caniuse-lite-1.0.30001378.tgz",
+      "integrity": "sha512-JVQnfoO7FK7WvU4ZkBRbPjaot4+YqxogSDosHv0Hv5mWpUESmN+UubMU6L/hGz8QlQ2aY5U0vR6MOs6j/CXpNA==",
       "dev": true,
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/browserslist"
-      }
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        }
+      ],
+      "license": "CC-BY-4.0"
     },
     "node_modules/catharsis": {
       "version": "0.9.0",
@@ -4802,9 +4809,10 @@
     },
     "node_modules/uuid": {
       "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "resolved": "https://artifactory.corp.adobe.com/artifactory/api/npm/npm-adobe-release/uuid/-/uuid-8.3.2.tgz",
       "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
       "dev": true,
+      "license": "MIT",
       "bin": {
         "uuid": "dist/bin/uuid"
       }
@@ -6147,9 +6155,9 @@
       "dev": true
     },
     "caniuse-lite": {
-      "version": "1.0.30001301",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001301.tgz",
-      "integrity": "sha512-csfD/GpHMqgEL3V3uIgosvh+SVIQvCh43SNu9HRbP1lnxkKm1kjDG4f32PP571JplkLjfS+mg2p1gxR7MYrrIA==",
+      "version": "1.0.30001378",
+      "resolved": "https://artifactory.corp.adobe.com/artifactory/api/npm/npm-adobe-release/caniuse-lite/-/caniuse-lite-1.0.30001378.tgz",
+      "integrity": "sha512-JVQnfoO7FK7WvU4ZkBRbPjaot4+YqxogSDosHv0Hv5mWpUESmN+UubMU6L/hGz8QlQ2aY5U0vR6MOs6j/CXpNA==",
       "dev": true
     },
     "catharsis": {
@@ -8744,7 +8752,7 @@
     },
     "uuid": {
       "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "resolved": "https://artifactory.corp.adobe.com/artifactory/api/npm/npm-adobe-release/uuid/-/uuid-8.3.2.tgz",
       "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
       "dev": true
     },

package/package.json

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

package/src/application.js

@@ -65,20 +65,46 @@ function propagateImplicitValues(xtkDesc, labelOnly) {
 // ========================================================================================
 // Schema Cache
 // ========================================================================================
+
+/**
+ * A cache of schemas of type `XtkSchema` instead of plain XML or JSON objects
+ * 
+ * @private
+ * @class
+ * @constructor
+ * @memberof Campaign
+ */
+
 class SchemaCache {
     constructor(client) {
         this._client = client;
         this._schemas = {};
     }
+
+    /**
+      * Get a schema by id from schema cache of type `XtkSchema` 
+     * 
+     * @param {string} schemaId 
+     * @returns {Campaign.XtkSchema} the schema, or null if the schema was not found
+     */
     async getSchema(schemaId) {
         let schema = this._schemas[schemaId];
         if (schema === undefined) {
             schema = await this._client.application._getSchema(schemaId);
             if (!schema) schema = null; // null = not found
-        this._schemas[schemaId] = schema;
+            this._schemas[schemaId] = schema;
         }
         return schema;
     }
+
+    /**
+      * Remove a schema from schema cache. The callback function when refreshing cache in cacheRefresher 
+     * 
+     * @param {string} schemaId 
+     */
+    invalidateCacheItem(schemaId) {
+        this._schemas[schemaId] = undefined;
+    }
 }
 
 // ========================================================================================
@@ -1237,6 +1263,13 @@ class Application {
         }
     }
 
+    _registerCacheChangeListener() {
+        this.client._registerCacheChangeListener(this._schemaCache);
+    }
+
+    _unregisterCacheChangeListener() {
+        this.client._unregisterCacheChangeListener(this._schemaCache);
+    }
     /**
      * Get a schema by id. This function returns an XtkSchema object or null if the schema is not found.
      * Using the `XtkSchema` API makes it easier to navigate schemas than using a plain XML or JSON object
@@ -1248,7 +1281,7 @@ class Application {
         return this._schemaCache.getSchema(schemaId);
     }
 
-    // Private function: get a schema without using the cache
+    // Private function: get a schema without using the SchemaCache
     async _getSchema(schemaId) {
         const xml = await this.client.getSchema(schemaId, "xml");
         if (!xml)

package/src/cache.js

@@ -123,6 +123,7 @@ class SafeStorage {
     } catch(ex) { /* Ignore errors in safe class */
     }
   }
+
 }
 
 /**
@@ -178,6 +179,16 @@ class Cache {
       this._cache = {};
       // timestamp at which the cache was last cleared
       this._lastCleared = this._loadLastCleared();
+      this._stats = {
+        reads: 0,
+        writes: 0,
+        removals: 0,
+        clears: 0,
+        memoryHits: 0,
+        storageHits: 0,
+        loads: 0,
+        saves: 0,
+      };
   }
 
   // Load timestamp at which the cache was last cleared
@@ -194,6 +205,7 @@ class Cache {
 
   // Load from local storage
   _load(key) {
+    this._stats.loads = this._stats.loads + 1;
     const json = this._storage.getItem(key);
     if (!json || !json.cachedAt || json.cachedAt <= this._lastCleared) {
       this._storage.removeItem(key);
@@ -204,6 +216,7 @@ class Cache {
 
   // Save to local storage
   _save(key, cached) {
+    this._stats.saves = this._stats.saves + 1;
     this._storage.setItem(key, cached);
   }
 
@@ -215,6 +228,7 @@ class Cache {
   _getIfActive(key) {
     // In memory cache?
     var cached = this._cache[key];
+    var memoryHit = !!cached;
     // Local storage ?
     if (!cached) {
       cached = this._load(key);
@@ -227,6 +241,8 @@ class Cache {
       this._remove(key);
       return undefined;
     }
+    this._stats.memoryHits = this._stats.memoryHits + 1;
+    if (!memoryHit) this._stats.storageHits = this._stats.storageHits + 1;
     return cached.value;
   }
 
@@ -236,6 +252,7 @@ class Cache {
    * @returns {*} the cached value, or undefined if not found
    */
   get() {
+      this._stats.reads = this._stats.reads + 1;
       const key = this._makeKeyFn.apply(this, arguments);
       const cached = this._getIfActive(key);
       return cached;
@@ -243,11 +260,12 @@ class Cache {
 
   /**
    * Put a value from the cache
-   * @param {*} key the key or keys of the value to retreive
+   * @param {*} key the key or keys of the value to retrieve
    * @param {*} value the value to cache
    * @returns {CachedObject} a cached object containing the cached value
    */
    put() {
+      this._stats.writes = this._stats.writes + 1;
       const value = arguments[arguments.length -1];
       const key = this._makeKeyFn.apply(this, arguments);
       const now = Date.now();
@@ -263,9 +281,20 @@ class Cache {
    * as cleared so that subsequent get operation will not actually return any data cached in persistent storage
    */
   clear() {
+      this._stats.clears = this._stats.clears + 1;
       this._cache = {};
       this._saveLastCleared();
   }
+
+  /**
+   * Remove a key from the cache
+   * @param {string} key the key to remove
+   */
+  remove(key) {
+      this._stats.removals = this._stats.removals + 1;
+      delete this._cache[key];
+      this._remove(key);
+  }
 }
 
 // Public expots

package/src/cacheRefresher.js

@@ -0,0 +1,267 @@
+/*
+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;
+        }
+    }
+
+    /**
+    * 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.
+    *
+    * @class
+    * @constructor
+    * @memberof Campaign
+    * @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
+    */
+    class CacheRefresher {
+
+        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) {
+            this._client._trackEvent('CACHE_REFRESHER//start', undefined, {
+                cacheSchemaId: this._cacheSchemaId,
+                refreshFrequency: 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
+                this._client._trackEvent('CACHE_REFRESHER//skip', undefined, {
+                    cacheSchemaId: this._cacheSchemaId,
+                });
+                return;
+            }
+            this._running = true;
+            try {
+                await this._callAndRefresh();
+            } catch(ex) {
+                if (ex.errorCode === "SDK-000010") {
+                    // client is not logged, this is not an error.
+                    this._client._trackEvent('CACHE_REFRESHER//loggedOff', undefined, {
+                        cacheSchemaId: this._cacheSchemaId,
+                    });
+                    return;
+                }
+                this._client._trackEvent('CACHE_REFRESHER//error', undefined, {
+                    cacheSchemaId: this._cacheSchemaId,
+                    error: ex,
+                });
+            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`);
+
+            const event = this._client._trackEvent('CACHE_REFRESHER//tick', undefined, {
+                cacheSchemaId: this._cacheSchemaId,
+                lastTime: this._lastTime,
+                buildNumber: this._buildNumber
+            });
+
+            // 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, 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;
+                    }
+                });
+        }
+
+        // Refresh Cache : remove entities modified recently listed in xmlDoc
+        _refresh(xmlDoc, event) {
+            const clearCache = XtkCaster.asBoolean(DomUtil.getAttributeAsString(xmlDoc, "emptyCache"));
+            const evicted = [];
+            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) {
+                        evicted.push(schemaId);
+                        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);
+                }
+            }
+
+            this._client._trackEvent('CACHE_REFRESHER//response', event, {
+                cacheSchemaId: this._cacheSchemaId,
+                clearCache: clearCache,
+                evicted: evicted
+            });
+        }
+
+        /**
+         * Stop auto refreshing the cache
+         */
+        stopAutoRefresh() {
+            if (this._intervalId) {
+                this._client._trackEvent('CACHE_REFRESHER//stop', undefined, {
+                    cacheSchemaId: this._cacheSchemaId,
+                });
+            }
+            clearInterval(this._intervalId);
+            this._intervalId = null;
+        }
+    }
+
+    // Public exports
+    exports.CacheRefresher = CacheRefresher;
+
+})();