@adobe/acc-js-sdk 1.0.9 → 1.1.2

package/src/client.js

@@ -96,65 +96,77 @@ const xtkObjectHandler = {
  * <code>
  * result = await client.NLWS.xtkSession.getServerTime();
  * </code>
+ * 
+ * To get a handler, call the `clientHandler` function and optionally pass a representation.
+ * If no representation is passed (undefined), the representation set at the client level
+ * will be used, which is the default behavior.
+ * To get a proxy with a specific representation, use NLWS.xml or NMWS.json
  *
  * @private
  * @memberof Campaign
  */
-const clientHandler = {
-    get: function(client, namespace) {
-        return new Proxy({ client:client, namespace:namespace}, {
-            get: function(callContext, methodName) {
-                if (methodName == ".") return callContext;
-
-                // get Schema id from namespace (find first upper case letter)
-                var schemaId = "";
-                for (var i=0; i<namespace.length; i++) {
-                    const c = namespace[i];
-                    if (c >='A' && c<='Z') {
-                        schemaId = schemaId + ":" + c.toLowerCase() + namespace.substr(i+1);
-                        break;
-                    }
-                    schemaId = schemaId + c;
-                }
-                callContext.schemaId = schemaId;
-
-                const caller = function(thisArg, argumentsList) {
-                    const callContext = thisArg["."];
-                    const namespace = callContext.namespace;
-                    const methodNameLC = methodName.toLowerCase();
-                    methodName = methodName.substr(0, 1).toUpperCase() + methodName.substr(1);
-                    if (namespace == "xtkSession" && methodNameLC == "logon")
-                        return callContext.client.logon(argumentsList[0]);
-                    else if (namespace == "xtkSession" && methodNameLC == "logoff")
-                        return callContext.client.logoff();
-                    else if (namespace == "xtkSession" && methodNameLC == "getoption") {
-                        var promise = callContext.client._callMethod(methodName, callContext, argumentsList);
-                        return promise.then(function(optionAndValue) {
-                            const optionName = argumentsList[0];
-                            client._optionCache.put(optionName, optionAndValue);
-                            return optionAndValue;
-                        });
+const clientHandler = (representation) => {
+    return {
+        get: function(client, namespace) {
+            // Force XML or JSON representation (NLWS.xml or NLWS.json)
+            if (namespace == "xml") return new Proxy(client, clientHandler("xml"));
+            if (namespace == "json") return new Proxy(client, clientHandler("SimpleJson"));
+
+            return new Proxy({ client:client, namespace:namespace}, {
+                get: function(callContext, methodName) {
+                    callContext.representation = representation;
+                    if (methodName == ".") return callContext;
+
+                    // get Schema id from namespace (find first upper case letter)
+                    var schemaId = "";
+                    for (var i=0; i<namespace.length; i++) {
+                        const c = namespace[i];
+                        if (c >='A' && c<='Z') {
+                            schemaId = schemaId + ":" + c.toLowerCase() + namespace.substr(i+1);
+                            break;
+                        }
+                        schemaId = schemaId + c;
                     }
-                    // static method
-                    var result = callContext.client._callMethod(methodName, callContext, argumentsList);
-                    return result;
-                };
-
-                if (methodName == "create") {
-                    return function(body) {
-                        callContext.object = body;
-                        return new Proxy(callContext, xtkObjectHandler);
+                    callContext.schemaId = schemaId;
+
+                    const caller = function(thisArg, argumentsList) {
+                        const callContext = thisArg["."];
+                        const namespace = callContext.namespace;
+                        const methodNameLC = methodName.toLowerCase();
+                        methodName = methodName.substr(0, 1).toUpperCase() + methodName.substr(1);
+                        if (namespace == "xtkSession" && methodNameLC == "logon")
+                            return callContext.client.logon(argumentsList[0]);
+                        else if (namespace == "xtkSession" && methodNameLC == "logoff")
+                            return callContext.client.logoff();
+                        else if (namespace == "xtkSession" && methodNameLC == "getoption") {
+                            var promise = callContext.client._callMethod(methodName, callContext, argumentsList);
+                            return promise.then(function(optionAndValue) {
+                                const optionName = argumentsList[0];
+                                client._optionCache.put(optionName, optionAndValue);
+                                return optionAndValue;
+                            });
+                        }
+                        // static method
+                        var result = callContext.client._callMethod(methodName, callContext, argumentsList);
+                        return result;
                     };
-                }
 
-                return new Proxy(caller, {
-                    apply: function(target, thisArg, argumentsList) {
-                        return target(thisArg, argumentsList);
-                    }                
-                });
-            }
-        });
-    }
+                    if (methodName == "create") {
+                        return function(body) {
+                            callContext.object = body;
+                            return new Proxy(callContext, xtkObjectHandler);
+                        };
+                    }
+
+                    return new Proxy(caller, {
+                        apply: function(target, thisArg, argumentsList) {
+                            return target(thisArg, argumentsList);
+                        }                
+                    });
+                }
+            });
+        }
+    };
 };
 
 // ========================================================================================
@@ -234,6 +246,8 @@ class Credentials {
     * @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)
+    * @property {function} refreshClient - An async callback function with the SDK client as parameter, which will be called when the ACC session is expired
+    * @property {string} charset - The charset encoding used for http requests. Defaults to UTF-8 since SDK version 1.1.1
     * @memberOf Campaign
  */
  
@@ -297,6 +311,7 @@ class ConnectionParameters {
         }
         this._options._storage = storage;
         this._options.refreshClient = options.refreshClient;
+        this._options.charset = options.charset === undefined ? "UTF-8": options.charset;
     }
 
     /**
@@ -474,7 +489,7 @@ class Client {
         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.NLWS = new Proxy(this, clientHandler());
 
         this._transport = connectionParameters._options.transport;
         this._traceAPICalls = connectionParameters._options.traceAPICalls;
@@ -673,7 +688,9 @@ class Client {
      * parameters should be set
      */
     _prepareSoapCall(urn, method, internal) {
-        const soapCall = new SoapMethodCall(this._transport, urn, method, this._sessionToken, this._securityToken, this._getUserAgentString());
+        const soapCall = new SoapMethodCall(this._transport, urn, method, 
+                                            this._sessionToken, this._securityToken, 
+                                            this._getUserAgentString(), this._connectionParameters._options.charset);
         soapCall.internal = !!internal;
         return soapCall;
     }
@@ -1117,7 +1134,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, callContext.representation);
             soapCall.writeDocument("document", object);
         }
 
@@ -1165,7 +1182,7 @@ class Client {
                             const index = xtkschema.indexOf(":");
                             docName = xtkschema.substr(index+1);
                         }
-                        var xmlValue = that._fromRepresentation(docName, paramValue);
+                        var xmlValue = that._fromRepresentation(docName, paramValue, callContext.representation);
                         if (type == "DOMDocument")
                             soapCall.writeDocument(paramName, xmlValue);
                         else
@@ -1184,7 +1201,7 @@ class Client {
                 // 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, callContext.representation);
                 }
             }
 
@@ -1215,7 +1232,7 @@ class Client {
                             returnValue = soapCall.getNextDate();
                         else if (type == "DOMDocument") {
                             returnValue = soapCall.getNextDocument();
-                            returnValue = that._toRepresentation(returnValue);
+                            returnValue = that._toRepresentation(returnValue, callContext.representation);
                             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
@@ -1235,7 +1252,7 @@ class Client {
                         }
                         else if (type == "DOMElement") {
                             returnValue = soapCall.getNextElement();
-                            returnValue = that._toRepresentation(returnValue);
+                            returnValue = that._toRepresentation(returnValue, callContext.representation);
                         }
                         else {
                             // type can reference a schema element. The naming convension is that the type name
@@ -1249,7 +1266,7 @@ class Client {
                                     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, callContext.representation);
                                         break;
                                     }
                                     element = DomUtil.getNextSiblingElement(element, "element");

package/src/index.js

@@ -191,7 +191,7 @@ class SDK {
      * Convert a javascript value into an xtk constant with proper quoting
      * @param {any} value the value to convert
      * @param {string} type the xtk type
-     * @returns 
+     * @returns {string} the text literal which can be used in a Xtk expression or condition
      */
     xtkConstText(value, type) {
         if (!type || type === 'string' || type === 'memo') {

package/src/soap.js

@@ -78,11 +78,12 @@ const NS_XSD = "http://www.w3.org/2001/XMLSchema";
  * @param {string} sessionToken Campaign session token
  * @param {string} securityToken  Campaign security token
  * @param {string} userAgentString The user agent string to use for HTTP requests
+ * @param {string} charset The charset encoding used for http requests, usually UTF-8
  * @memberof SOAP
  */
 class SoapMethodCall {
     
-    constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString) {
+    constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString, charset) {
         this.request = undefined;       // The HTTP request (object litteral passed to the transport layer)
         this.response = undefined;      // The HTTP response object (in case of success)
 
@@ -99,6 +100,7 @@ class SoapMethodCall {
         this._sessionToken = sessionToken || "";
         this._securityToken = securityToken || "";
         this._userAgentString = userAgentString;
+        this._charset = charset || "";
 
         // THe SOAP call being built
         this._doc = undefined;           // XML document for SOAP call
@@ -512,11 +514,12 @@ class SoapMethodCall {
      * @returns {Object} an options object describing the HTTP request, with cookies, headers and body
      */
     _createHTTPRequest(url) {
+
         const options = {
             url: url,
             method: 'POST',
             headers: {
-                'Content-type': 'application/soap+xml',
+                'Content-type': `application/soap+xml${this._charset ? ";charset=" + this._charset : ""}`,
                 'SoapAction': `${this.urn}#${this.methodName}`,
                 'X-Security-Token': this._securityToken
             },

package/src/util.js

@@ -135,7 +135,151 @@ class Util {
   }
 }
 
+/**
+ * The ArrayMap object is used to access elements as either an array or a map
+ * 
+ * @class
+ * @constructor
+ * @memberof Utils
+ */
+
+class ArrayMap {
+  constructor() {
+      // List of items, as an ordered array. Use defineProperty to make it non-enumerable
+      // and support for for ... in loop to iterate by item key
+      Object.defineProperty(this, "_items", {
+        value: [],
+        writable: false,
+        enumerable: false,
+      });
+
+      Object.defineProperty(this, "_map", {
+        value: [],
+        writable: false,
+        enumerable: false,
+      });
+      
+      // Number of items. Use defineProperty to make it non-enumerable
+      // and support for for ... in loop to iterate by item key
+      Object.defineProperty(this, "length", {
+        value: 0,
+        writable: true,
+        enumerable: false,
+      });
+  }
+
+  _push(key, value) {
+      let isNumKey = false;
+      if (key) {
+        // reserved keyworkds
+        const isReserved = key === "_items" || key === "length" || key === "_push" || key === "forEach" || key === "map" || key === "_map" || key === "get" || key === "find" || key === "flatMap" || key === "filter";
+
+        // already a child with the name => there's a problem with the schema
+        if (!isReserved && this[key]) throw new Error(`Failed to add element '${key}' to ArrayMap. There's already an item with the same name`);
+
+        // Set key as a enumerable property, so that elements can be accessed by key, 
+        // but also iterated on with a for ... in loop
+        // For compatibility 
+        if (!isReserved) this[key] = value;
+        this._map[key] = value;
+
+        // Special case where keys are numbers or strings convertible with numbers
+        const numKey = +key;
+        if (numKey === numKey) {
+          // keys is a number. If it matches the current index, then we are good,
+          // and we can add the property as an enumerable property
+          isNumKey = true;
+        }
+      }
+
+      if (!isNumKey) {
+        // Set the index property so that items can be accessed by array index.
+        // However, make it non-enumerable to make sure indexes do not show up in a for .. in loop
+        Object.defineProperty(this, this._items.length, {
+          value: value,
+          writable: false,
+          enumerable: false,
+        });
+      }
+      // Add to array and set length
+      this._items.push(value);
+      this.length = this._items.length;
+  }
+
+  /**
+   * Executes a provided function once for each array element.
+   * @param {*} callback Function that is called for every element of the array
+   * @param {*} thisArg Optional value to use as this when executing the callback function.
+   * @returns a new array
+   */
+  forEach(callback, thisArg) {
+      return this._items.forEach(callback, thisArg);
+  }
+
+  /**
+   * Returns the first element that satisfies the provided testing function. If no values satisfy the testing function, undefined is returned.
+   * @param {*} callback Function that is called for every element of the array
+   * @param {*} thisArg Optional value to use as this when executing the callback function.
+   * @returns the first element matching the testing function
+   */
+  find(callback, thisArg) {
+    return this._items.find(callback, thisArg);
+  }
+
+  /**
+   * creates a new array with all elements that pass the test implemented by the provided function.
+   * @param {*} callback Function that is called for every element of the array
+   * @param {*} thisArg Optional value to use as this when executing the callback function.
+   * @returns an array containing elements passing the test function
+   */
+   filter(callback, thisArg) {
+    return this._items.filter(callback, thisArg);
+  }
+
+  /**
+   * Get a element by either name (access as a map) or index (access as an array). Returns undefined if the element does not exist or
+   * if the array index is out of range.
+   * @param {string|number} indexOrKey the name or index of the element
+   * @returns the element matching the name or index
+   */
+  get(indexOrKey) {
+    if (typeof indexOrKey === 'number') return this._items[indexOrKey];
+    return this._map[indexOrKey];
+  }
+
+  /**
+   * Creates a new array populated with the results of calling a provided function on every element in the calling array.
+   * @param {*} callback Function that is called for every element of the array
+   * @param {*} thisArg Optional value to use as this when executing the callback function.
+   * @returns a new array
+   */
+  map(callback, thisArg) {
+    return this._items.map(callback, thisArg);
+  }
+
+  /**
+   * Returns a new array formed by applying a given callback function to each element of the array, and then flattening the result by one level. 
+   * @param {*} callback Function that is called for every element of the array
+   * @param {*} thisArg Optional value to use as this when executing the callback function.
+   * @returns a new array
+   */
+  flatMap(callback, thisArg) {
+    return this._items.flatMap(callback, thisArg);
+  }
+
+  /**
+   * Iterates over all the elements using the for ... of syntax.
+   * @returns returns each element one after the other
+   */
+  *[Symbol.iterator] () {
+      for (const item of this._items) {
+          yield item;
+      }
+  }
+}
+
 // Public expots
 exports.Util = Util;
+exports.ArrayMap = ArrayMap;
 
 })();

package/src/xtkCaster.js

@@ -431,15 +431,30 @@ class XtkCaster {
         return timespan;
     }
 
+    /**
+     * Tests if a given type is a date or time type
+     * @param {string|number} type the type name
+     * @returns {boolean} true if the type is a date and/or time type
+     */
     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) {
+    /**
+     * Tests if a given type is a string type
+     * @param {string|number} type the type name
+     * @returns {boolean} true if the type is a string type
+     */
+     static isStringType(type) {
         return type === "string" || type === "memo" || type === 6 || type === 12 || type === 13 || type === "blob" || type === "html" || type === "CDATA";
     }
 
-    static isNumericType(type) {
+    /**
+     * Tests if a given type is a numeric type
+     * @param {string|number} type the type name
+     * @returns {boolean} true if the type is a numeric type
+     */
+     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;
     }
 }