@adobe/acc-js-sdk 1.0.5 → 1.0.8

package/src/methodCache.js

@@ -20,7 +20,7 @@ governing permissions and limitations under the License.
  *********************************************************************************/
 
 const DomUtil = require('./domUtil.js').DomUtil;
-const { Cache } = require('./util.js');
+const { Cache } = require('./cache.js');
 
 /**
  * @namespace Campaign
@@ -41,12 +41,31 @@ class MethodCache extends Cache {
      * A in-memory cache for SOAP call method definitions. Not intended to be used directly,
      * but an internal cache for the Campaign.Client object
      * 
+     * Cached object are made of
+     * - the key is a string in the form <schemaId>#<methodName>, such as "xtk:session#GetServerTime"
+     * - the value is a JSON object made of two attributes:
+     *          - the "urn" attribute, such as "xtk:persist", which is the URN to use to make the SOAP call
+     *          - the "method" attribute, a DOM element corresponding to the method XML element
+     * 
      * @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, ((schemaId, methodName) => schemaId + "#" + methodName ));
+        super(storage, rootKey, ttl, ((schemaId, methodName) => schemaId + "#" + methodName ), (item, serDeser) => {
+            if (serDeser) {
+                if (!item || !item.value || !item.value.method) throw Error(`Cannot serialize falsy cached item`);
+                const value = Object.assign({}, item);          // shallow copy
+                value.value = Object.assign({}, value.value);   // dummy deep copy
+                value.value.method = DomUtil.toXMLString(item.value.method);
+                return JSON.stringify(value);
+            }
+            else {
+                const json = JSON.parse(item);
+                json.value.method = DomUtil.parse(json.value.method).documentElement;
+                return json;
+            }
+        });
     }
 
     /**

package/src/optionCache.js

@@ -18,7 +18,7 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
 const XtkCaster = require('./xtkCaster.js').XtkCaster;
-const { Cache } = require('./util.js');
+const { Cache } = require('./cache.js');
 
 
 /**
@@ -44,6 +44,10 @@ class OptionCache extends Cache {
      * A in-memory cache for xtk option values. Not intended to be used directly,
      * but an internal cache for the Campaign.Client object
      * 
+     * Cached object are made of
+     * - the key is the option name
+     * - the value is the option, a JSON object made of value, type, and rawValue properties
+     * 
      * @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

package/src/soap.js

@@ -93,6 +93,8 @@ class SoapMethodCall {
         // Soap calls marked as internal are calls performed by the framework internally
         // (such as GetEntityIfMoreRecent calls needed to lookup schemas)
         this.internal = false;
+        // Enable soap retry
+        this.retry = true;
 
         this._sessionToken = sessionToken || "";
         this._securityToken = securityToken || "";
@@ -119,7 +121,8 @@ class SoapMethodCall {
      * @returns {boolean} indicates if the call requires a Logon first
      */
     requiresLogon() {
-        const requiresLogon = !(this.urn === "xtk:session" && this.methodName === "Logon");
+        const requiresLogon = !(this.urn === "xtk:session" && 
+                               (this.methodName === "Logon" || this.methodName === "BearerTokenLogon") ) ;
         return requiresLogon;
     }
 
@@ -150,22 +153,6 @@ class SoapMethodCall {
         this._method.setAttribute(`xmlns:m`, urnPath);
         this._method.setAttribute(`SOAP-ENV:encodingStyle`, encoding);
         this._data.appendChild(this._method);
-
-        if (this._sessionToken) {
-            const cookieHeader = this._doc.createElement("Cookie");
-            cookieHeader.textContent = `__sessiontoken=${this._sessionToken}`;
-            this._header.appendChild(cookieHeader);
-        }
-
-        const securityTokenHeader = this._doc.createElement("X-Security-Token");
-        securityTokenHeader.textContent = this._securityToken;
-        this._header.appendChild(securityTokenHeader);
-
-        // Always write a sessiontoken element as the first parameter. Even when using SecurityToken authentication
-        // and when the session token is actually passed implicitely as a cookie, one must write a sessiontoken
-        // element. If not, authentication will fail because the first parameter is interpreted as the "authentication mode"
-        // and eventually passed as the first parameter of CXtkLocalSessionPart::GetXtkSecurity
-        this.writeString("sessiontoken", this._sessionToken);
     }
 
     /**
@@ -541,12 +528,50 @@ class SoapMethodCall {
             options.headers['User-Agent'] = this._userAgentString;
         return options;
     }
-
+    
     /**
      * Finalize a SOAP call just before sending
      * @param {string} url the endpoint (/nl/jsp/soaprouter.jsp)
+     * @param {client.Client} sdk client (optional)
      */
-    finalize(url) {
+    finalize(url, client) {
+        if (client) {
+            this._sessionToken = client._sessionToken;
+            this._securityToken = client._securityToken;
+        }
+
+        var cookieHeader = DomUtil.findElement(this._header, "Cookie");
+        if (this._sessionToken) {
+            if (!cookieHeader) {
+                cookieHeader = this._doc.createElement("Cookie");
+                this._header.appendChild(cookieHeader);
+            }
+            cookieHeader.textContent = `__sessiontoken=${this._sessionToken}`;
+        } else if (cookieHeader) {
+            cookieHeader.remove();
+        }
+
+        var securityTokenHeader = DomUtil.findElement(this._header, "X-Security-Token");
+        if (!securityTokenHeader) {
+            securityTokenHeader = this._doc.createElement("X-Security-Token");
+            this._header.appendChild(securityTokenHeader);
+        }
+        securityTokenHeader.textContent = this._securityToken;
+
+        // Always write a sessiontoken element as the first parameter. Even when using SecurityToken authentication
+        // and when the session token is actually passed implicitely as a cookie, one must write a sessiontoken
+        // element. If not, authentication will fail because the first parameter is interpreted as the "authentication mode"
+        // and eventually passed as the first parameter of CXtkLocalSessionPart::GetXtkSecurity
+        var sessionTokenElem = DomUtil.findElement(this._method, "sessiontoken");
+        if (sessionTokenElem) {
+            sessionTokenElem.textContent = this._sessionToken;
+        } else {
+            sessionTokenElem = this._doc.createElement("sessiontoken");
+            sessionTokenElem.setAttribute("xsi:type", "xsd:string");
+            // sessionTokenElem.setAttribute("SOAP-ENV:encodingStyle", SOAP_ENCODING_NATIVE);
+            sessionTokenElem.textContent = this._sessionToken;
+            this._method.prepend(sessionTokenElem);
+        }
         const options = this._createHTTPRequest(url);
         // Prepare request and empty response objects
         this.request = options;
@@ -564,6 +589,8 @@ class SoapMethodCall {
         const that = this;
         const promise = this._transport(this.request);
         return promise.then(function(body) {
+            if (body.indexOf(`XSV-350008`) != -1)
+                throw CampaignException.SESSION_EXPIRED();
             that.response = body;
             // Response is a serialized XML document with the following structure
             //

package/src/testUtil.js

@@ -0,0 +1,47 @@
+const { DomUtil } = require("./domUtil");
+
+/*
+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 { newSchema } = require("./application");
+
+/**********************************************************************************
+ * 
+ * Utilities for testing
+ * 
+ *********************************************************************************/
+
+/**
+ * @namespace Utils
+ */
+
+/**
+ * @memberof Utils
+ * @class
+ * @constructor
+ */
+class TestUtil {
+
+  static newSchema(xml) {
+    if (typeof xml === "string") 
+      xml = DomUtil.parse(xml);
+    return newSchema(xml);
+  }
+}
+
+
+// Public expots
+exports.TestUtil = TestUtil;
+
+})();

package/src/util.js

@@ -135,236 +135,7 @@ class Util {
   }
 }
 
-
-/**********************************************************************************
- * 
- * A simple cache for XtkEntities, options, etc.
- * 
- *********************************************************************************/
-
-/**
- * @private
- * @class
- * @constructor
- * @memberof Utils
- */
-class SafeStorage {
-
-  /**
-   * A wrapper to the Storage interface (LocalStorage, etc.) which is "safe", i.e.
-   * 
-   * - it will never throw / support local stroage to be undefined or not accessible
-   * - Handle the notion of "root key", i.e. prefix 
-   * - Set/get values as JSON only and not as strings
-   * - Silently caches all exceptions
-   * - Automatically remove from storage cached values which are not valid, expired, or cannot be parsed
-   * 
-   * SafeStorage objects are created automatically by Caches
-   * 
-   * @param {Storage} delegate an optional delegate options, confomring to the Storage interface (getItem, setItem, removeItem)
-   * @param {string} rootKey an optional prefix which will be prepend to all keys
-   */
-  constructor(delegate, rootKey) {
-    this._delegate = delegate;
-    this._rootKey = rootKey ? `${rootKey}$` : "";
-  }
-
-  /**
-   * Get an item from storage
-   * @param {string} key the item key (relative to the root key)
-   * @returns {Object} the cached JSON object, or undefined if not found 
-   */
-  getItem(key) {
-    if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
-      return;
-    const itemKey = `${this._rootKey}${key}`;
-    const raw = this._delegate.getItem(itemKey);
-    if (!raw)
-      return undefined;
-    try {
-      return JSON.parse(raw);
-    } catch(ex) {
-      this.removeItem(key);
-    }
-  }
-
-  /**
-   * Put an item into storage
-   * @param {string} key the item key (relative to the root key)
-   * @param {Object} json the value to cache
-   */
-   setItem(key, json) {
-    if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
-      return;
-    try {
-      if (json && typeof json === "object") {
-        const raw = JSON.stringify(json);
-        this._delegate.setItem(`${this._rootKey}${key}`, raw);
-        return;
-      }
-    } catch(ex) { /* Ignore errors in safe class */
-    }
-    this.removeItem(key);
-  }
-
-  /**
-   * Removes an item from the storage
-   * @param {string} key the item key (relative to the root key)
-   */
-  removeItem(key) {
-    if (!this._delegate || this._rootKey === undefined || this._rootKey === null)
-      return;
-    try {
-      this._delegate.removeItem(`${this._rootKey}${key}`);
-    } catch(ex) { /* Ignore errors in safe class */
-    }
-  }
-}
-
-/**
- * @private
- * @class
- * @constructor
- * @memberof Utils
- */
-class CachedObject {
-
-  /**
-   * An object in the cache, i.e. a wrapped to a cached value and additional metadata to manage the cache.
-   * Do not create such objects directly, they are 100% managed by the Cache object
-   * 
-   * @param {*} value the cached value
-   * @param {number} cachedAt the timestamp at which the value was cached
-   * @param {number} expiresAt the timestamp at which the cached value expires
-   */
-  constructor(value, cachedAt, expiresAt) {
-      this.value = value;
-      this.cachedAt = cachedAt;
-      this.expiresAt = expiresAt;
-  }
-}
-
-/** 
- * @private
- * @class
- * @constructor
- * @memberof Utils
- */
-class Cache {
-
-  /**
-   * A general purpose in-memory cache with TTL. In addition to caching in memory, the cache has the ability to delegate the caching
-   * to a persistent cache, such as the browser localStorage. The interface is 100% synchronous.
-   * 
-   * By default, caches take a single parameter for the key. It is possible however to use a more complex scenario by setting a makeKeyFn.
-   * When set, such a function will take 1 or more arguments and will be responsible to create a primitive key (a string) from the arguments.
-   * The cache public APIs : get and put therefore can take a variable number of key arguments, which will be combined into the actual primitive key.
-   * 
-   * @param {Storage} storage is an optional Storage object, such as localStorage or sessionStorage. This object will be wrapped into a SafeStorage object to ensure access is safe and will not throw any exceptions
-   * @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
-   * @param {function} makeKeyFn is an optional function which will generate a key for objects in the cache. It's passed the arguments of the cache 'get' function
-   */
-  constructor(storage, rootKey, ttl, makeKeyFn) {
-      this._storage = new SafeStorage(storage, rootKey);
-      this._ttl = ttl || 1000*300;
-      this._makeKeyFn = makeKeyFn || ((x) => x);
-      this._cache = {};
-      // timestamp at which the cache was last cleared
-      this._lastCleared = this._loadLastCleared();
-  }
-
-  // Load timestamp at which the cache was last cleared
-  _loadLastCleared() {
-    const json = this._storage.getItem("lastCleared");
-    return json ? json.timestamp : undefined;
-  }
-
-  _saveLastCleared() {
-    const now = Date.now();
-    this._lastCleared = now;
-    this._storage.setItem("lastCleared", { timestamp: now});
-  }
-
-  // Load from local storage
-  _load(key) {
-    const json = this._storage.getItem(key);
-    if (!json || !json.cachedAt || json.cachedAt <= this._lastCleared) {
-      this._storage.removeItem(key);
-      return;
-    }
-    return json;
-  }
-
-  // Save to local storage
-  _save(key, cached) {
-    this._storage.setItem(key, cached);
-  }
-
-  // Remove from local storage
-  _remove(key) {
-    this._storage.removeItem(key);
-  }
-
-  _getIfActive(key) {
-    // In memory cache?
-    var cached = this._cache[key];
-    // Local storage ?
-    if (!cached) {
-      cached = this._load(key);
-      this._cache[key] = cached;
-    }
-    if (!cached) 
-      return undefined;
-    if (cached.expiresAt <= Date.now()) {
-      delete this._cache[key];
-      this._remove(key);
-      return undefined;
-    }
-    return cached.value;
-  }
-
-  /**
-   * Get a value from the cache
-   * @param {*} key the key or keys of the value to retreive
-   * @returns {*} the cached value, or undefined if not found
-   */
-  get() {
-      const key = this._makeKeyFn.apply(this, arguments);
-      const cached = this._getIfActive(key);
-      return cached;
-  }
-
-  /**
-   * Put a value from the cache
-   * @param {*} key the key or keys of the value to retreive
-   * @param {*} value the value to cache
-   * @returns {CachedObject} a cached object containing the cached value
-   */
-   put() {
-      const value = arguments[arguments.length -1];
-      const key = this._makeKeyFn.apply(this, arguments);
-      const now = Date.now();
-      const expiresAt = now + this._ttl;
-      const cached = new CachedObject(value, now, expiresAt);
-      this._cache[key] = cached;
-      this._save(key, cached);
-      return cached;
-  }
-  
-  /**
-   * 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() {
-      this._cache = {};
-      this._saveLastCleared();
-  }
-}
-
 // Public expots
 exports.Util = Util;
-exports.SafeStorage = SafeStorage;
-exports.Cache = Cache;
 
 })();

package/src/xtkCaster.js

@@ -12,6 +12,8 @@ governing permissions and limitations under the License.
 (function() {
 "use strict";    
 
+const { Util } = require('./util.js');
+
 /**********************************************************************************
  * 
  * Helper class to cast values to and from their Xtk versions
@@ -37,11 +39,15 @@ governing permissions and limitations under the License.
 |     Xtk type |    | JS type | Comment |
 | ------------ |----|-------- | --- |
 |       string |  6 |  string | never null, defaults to "" |
-|         memo | 12 |  string |
-|        CDATA | 13 |  string |
+|         memo | 12 |  string | large strings. Never null, defaults to ""
+|        CDATA | 13 |  string | string in the CDATA section of an XML document. Never null, defaults to ""
+|         uuid |    |  string |
+|         blob |    |  string | 
+|         html |    |  string | 
 |         byte |  1 |  number | signed integer in the [-128, 128[ range. Never null, defaults to 0 |
 |        short |  2 |  number | signed 16 bits integer in the [-32768, 32768[ range. Never null, defaults to 0 |
 |         long |  3 |  number | signed 32 bits integer. Never null, defaults to 0 |
+|          int |    |  number | signed 32 bits integer. Never null, defaults to 0 |
 |        int64 |    | string  | signed 64 bits integer. As JavaScript handles all numbers as doubles, it's not possible to properly represent an int64 as a number, and it's therefore represented as a string.
 |        float |  4 |  number | single-percision numeric value. Never null, defaults to 0 |
 |       double |  5 |  number | single-percision numeric value. Never null, defaults to 0 |
@@ -49,10 +55,11 @@ governing permissions and limitations under the License.
 |   datetimetz |    |         | |
 | datetimenotz |    |         | |
 |         date | 10 |    Date | UTC timestamp with day precision. Can be null |
+|     timespan | 14 |  number | A timespan, in seconds
 |      boolean | 15 | boolean | boolean value, defaultint to false. Cannot be null |
-|     timespan |    |         | |
+|        array |    |   Array | a array or a collection
 
- * @typedef {(0|''|6|'string'|'int64'|12|13|'memo'|'CDATA'|1|'byte'|2|'short'|3|'long'|15|'boolean'|4|5|'float'|'double'|7|'datetime'|'datetimetz'|'datetimenotz'|10|'date')} XtkType
+ * @typedef {(0|''|6|'string'|'int64'|12|13|'memo'|'CDATA'|1|'byte'|2|'short'|3|'long'|15|'boolean'|4|5|'float'|'double'|7|'datetime'|'datetimetz'|'datetimenotz'|10|'date'|14|'timespan'|'array')} XtkType
  * @memberof Campaign
  */
 
@@ -85,10 +92,13 @@ class XtkCaster {
                 return null;
             case 6:             // FIELD_SZ
             case "string":
+            case "uuid":
             case "int64":
                 return "stringValue";
             case 12:            // FIELD_MEMO
             case 13:            // FIELD_MEMOSHORT
+            case "blob":
+            case "html":
             case "memo":
             case "CDATA": 
                     return "memoValue";
@@ -97,8 +107,10 @@ class XtkCaster {
             case 2:             // FIELD_SHORT
             case "short": 
             case 3:             // FIELD_LONG
+            case "int":
             case "long":
-            case 15:            // FIELD_BOOLEAN
+            case "timespan":
+                case 15:            // FIELD_BOOLEAN
             case "boolean":
                     return "longValue";
             case 4:             // FIELD_FLOAT
@@ -137,6 +149,9 @@ class XtkCaster {
             case 13:            // FIELD_MEMOSHORT
             case "string":
             case "memo":
+            case "uuid":
+            case "blob":
+            case "html":
             case "CDATA": {
                 return this.asString(value);
             }
@@ -149,6 +164,7 @@ class XtkCaster {
                 return this.asShort(value);
             }
             case 3:             // FIELD_LONG
+            case "int":
             case "long": {
                 return this.asLong(value);
             }
@@ -175,6 +191,13 @@ class XtkCaster {
             case "date": {
                 return this.asDate(value);
             }
+            case "array": {
+                return this.asArray(value);
+            }
+            case 14:            // FIELD_TIMESPAN
+            case "timespan": {
+                return this.asTimespan(value);
+            }
             default: {
                 throw CampaignException.BAD_PARAMETER("type", type, `Cannot convert value type='${type}', value='${value}'`);
             }
@@ -318,6 +341,16 @@ class XtkCaster {
         return number;
     }
 
+    /**
+     * Convert a raw value into a timestamp (alias to the "asTimestamp" function)
+     * 
+     * @param {*} value is the raw value to convert
+     * @return {Date} the timestamp, possibly null
+     */
+     static asDatetime(value) {
+        return this.asTimestamp(value);
+    }
+
     /**
      * Convert a raw value into a timestamp
      * 
@@ -354,7 +387,7 @@ class XtkCaster {
     }
 
     /**
-     * Convert a raw value into a  date. This is a UTC timestamp where time fields are 0
+     * Convert a raw value into a date. This is a UTC timestamp where time fields are 0
      *
      * @param {*} value is the raw value to convert
      * @return {Date} a date
@@ -369,8 +402,49 @@ class XtkCaster {
         }
         return timestamp;
     }
+
+    /**
+     * Convert a raw value into an array (if it is not an array yet). Null and undefined will be
+     * converted into an empty array
+     *
+     * @param {*} value is the raw value to convert
+     * @return {Array} a array
+     */
+     static asArray(value) {
+        if (value === null || value === undefined) return [];
+        if (Util.isArray(value)) return value;
+        return [value];
+    }
+
+    /**
+     * Convert a raw value into a timespan, in seconds
+     * @param {*} value is the raw value to convert
+     * @returns is the time span, in seconds
+     */
+    static asTimespan(value) {
+        if (value === null || value === undefined) return 0;
+        if ((typeof value) == "string") value = value.trim();
+        if (value === "" || value === true || value === false) return 0;
+        if (value !== value || value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) return 0;
+        // Number to timespan -> Consider as number of seconds
+        var timespan = XtkCaster.asLong(value);
+        return timespan;
+    }
+
+    static isTimeType(type) {
+        return type === "datetime" || type === "datetimetz" || type === "datetimenotz" || type === "timestamp" || type === "date" || type === "time" || type === "timespan" || type === 7 || type === 10 || type === 14;
+    }
+
+    static isStringType(type) {
+        return type === "string" || type === "memo" || type === 6 || type === 12 || type === 13 || type === "blob" || type === "html" || type === "CDATA";
+    }
+
+    static isNumericType(type) {
+        return type === "byte" || type === 1 || type === "short" || type === 2 || type === "int" || type === "long" || type === 3 || type === "float" || type === 4 || type === "double" || type === 5 || type === "timespan" || type === 14;
+    }
 }
 
+
 exports.XtkCaster = XtkCaster;
 
 })();

package/src/xtkEntityCache.js

@@ -13,7 +13,7 @@ governing permissions and limitations under the License.
 "use strict";
 
 const DomUtil = require('./domUtil.js').DomUtil;
-const { Cache } = require('./util.js');
+const { Cache } = require('./cache.js');
 
 
 /**********************************************************************************
@@ -32,14 +32,30 @@ class XtkEntityCache extends Cache {
     
     /**
      * A in-memory cache for xtk entities. Not intended to be used directly,
-     * but an internal cache for the Campaign.Client object
+     * but an internal cache for the Campaign.Client object.
+     * 
+     * Cached object are made of
+     * - the key is a string in the form <entityType>|<entityName>, such as "xtk:schema|nms:recipient"
+     * - the value is a DOM element corresponding to the entity. It's always a DOM element, regardless of the client representation
      * 
      * @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, (entityType, entityFullName) => entityType + "|" + entityFullName);
+        super(storage, rootKey, ttl, (entityType, entityFullName) => entityType + "|" + entityFullName, (item, serDeser) => {
+            if (serDeser) {
+                if (!item || !item.value) throw Error(`Cannot serialize falsy cached item`);
+                const value = Object.assign({}, item);
+                value.value = DomUtil.toXMLString(item.value);
+                return JSON.stringify(value);
+            }
+            else {
+                const json = JSON.parse(item);
+                json.value = DomUtil.parse(json.value).documentElement;
+                return json;
+            }
+        });
     }
 
     /**