@adobe/acc-js-sdk 1.1.2 → 1.1.3

package/.github/workflows/npm-publish.yml

@@ -16,7 +16,7 @@ jobs:
         node-version: 10.0.0
     - name: Publish if version has been updated
       #uses: pascalgn/npm-publish-action@06e0830ea83eea10ed4a62654eeaedafb8bf50fc
-      uses: mkiki/npm-publish-action@c4315ef5790b7bcec2cbb75b34e37681a409d78d
+      uses: mkiki/npm-publish-action@52879298d00c0a02781e1f02c9e917e01cff1bc7
       with: # All of theses inputs are optional
         tag_name: "v%s"
         tag_message: "v%s"

package/CHANGELOG.md

@@ -5,6 +5,17 @@ This is a node.js SDK for Campaign API. It exposes the Campaign API exactly like
 
 # Changelog 
 
+## Version 1.1.3
+_2022/05/30_
+
+* Fix a bug in client.hasPackage which was returning an incorrect result when passed a single parameter (it would always return false). Fixed the corresponding unit test too.
+* Fix a bug causing API calls having a input parameter of type "int" to fail. Usually the type is described as "long", but sometimes "int" is used instead, such as, for instance, in the nms:extAccount#UpdateMCSynchWkf method.
+* When using XML representations and DOMDocument method parameter type, the SDK expects to be passed an actual DOM document. Now it supports being passed a DOM element too. This is a common case when using the nms:delivery#createFromModel API followed by a xtk:session#Write API call.
+* Avoid the error 'Cannot transform entity to xml because no XML root name was given' by using SOAP method parameter name as the default for XML document root when no other root is available
+* Document how to set the password of an external account
+* By default, SDK will send additional HTTP headers to help troubleshooting and usage tracking
+* Add the ability to pass extra HTTP headers to API calls, either globally (to all HTTP headers), or locally, i.e. for a specific method
+
 ## Version 1.1.2
 _2022/03/22_
 

package/README.md

@@ -130,7 +130,9 @@ noStorage|false|De-activate using of local storage
 storage|localStorage|Overrides the local storage for caches
 refreshClient|undefined|Async callback to run when the session token is expired
 charset|UTF-8|The charset encoding used for http requests. In version 1.1.1 and above, the default will be UTF-8. It's possible to override (including setting an empty character set) with this option.
-
+extraHttpHeaders|[string]:string|An optional dictionary (key/value pairs) of extra HTTP headers to pass to all API calls.
+clientApp|string|An optional string describing the name and version of the SDK client application. It will be passed to the server in the ACC-SDK-Client-App HTTP header
+noSDKHeaders|boolean|Can be set to disable passing ACC-SDK-* HTTP headers to the server
 ```js
 const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword(
                                     "https://myInstance.campaign.adobe.com", 
@@ -576,6 +578,49 @@ const document = DomUtil.fromJSON(json, "BadgerFish");
 const json = DomUtil.toJSON(documentOrElement, "BadgerFish");
 ```
 
+## Passing XML parameters
+Many Campaign APIs take arguments which are DOM documents or DOM elements. For example, the nms:delivery#DeployTriggerMessages first argument is a DOMElement which is supposed to be a `<where>` clause used as a condition to select Message Center deliveries to publish.
+
+```xml
+    <method name="DeployTriggerMessages" static="true">
+      <parameters>
+        <param inout="in" name="deliveries" type="DOMElement"/>
+        <param inout="in" name="localPublish" type="boolean"/>
+      </parameters>
+    </method>
+```
+
+For example, one would want to use the following condition to republish a particular delivery
+
+```js
+    await client.NLWS.nmsDelivery.DeployTriggerMessages({
+      condition: [ {
+        expr: "@internalName='DM23'"
+      }]
+    }, false);
+```
+
+The JSON object corresponds to the following XML
+```xml
+<where>
+    <condition expr="@internalName='DM23'"/>
+</where>
+```
+
+Note that in XML, unlike JSON, the root element `<where>` is explicitely named "where". When converting JSON to XML, there is no way for the SDK to know which tag name to used for the root XML element. The SDK contains some code to set it for the most common situation, but will rely on the user to specify, when necessary, the name of the root elment. This can be done using the `xtkschema` (all case insensitive) attribute as follows:
+```js
+    await client.NLWS.nmsDelivery.DeployTriggerMessages({
+      xtkschema: 'xtk:where',
+      condition: [ {
+        expr: "@internalName='DM23'"
+      }]
+    }, false);
+```
+
+When the `xtkschema` attribute is set, the part after the colon (i.e. "where" in this example) will be used as the root element, effectively generating the right XML.
+
+In our example, the `DeployTriggerMessages` will work properly regardless of the XML root of its `deliveries` parameter, so it's not needed to actually set the `xtkschema` attribute, but it's a best practice to do so, because some APIs will actually depend on receiving the right tag name.
+
 ## Error Management
 
 If an API call fails (SOAP fault or HTTP error), a `CampaignException` object is thrown. This object contains the following attributes
@@ -654,6 +699,64 @@ const password = cipher.decryptPassword(encryptedPassword);
 
 > **warning** This function is deprecated in version 1.0.0 of the SDK because it may break as we deploy Vault.
 
+In order to set the password of an external account, you can use the `encryptPassword` API as follow
+
+```js
+const password = await this._client.NLWS.xtkSession.encryptPassword('password');
+const account = {
+    xtkschema: "nms:extAccount",
+    name: name,
+    account: 'admin',
+    server: server,
+    password: password,
+};
+await this._client.NLWS.xtkSession.Write(account);
+```
+
+
+## HTTP Headers
+
+### Out-of-the-box headers
+In version 1.1.3 and above, the SDK will pass additional HTTP headers automatically
+
+Header | Description
+-------|------------
+SOAPAction| name of the schema and SOAP method (ex: xtk:query#ExecuteQuery)
+ACC-SDK-Version| Version of the SDK making the scores
+ACC-SDK-Auth| Authentification type and ACC user
+ACC-SDK-Client-App| Name of the application calling the client SDK
+ACC-SDK-Call-RetryCount| In case an API call is retried, indicates the number of retries
+ACC-SDK-Call-Internal| Indicates that an API call is performed byt the SDK for its own purpose
+
+The `ACC-SDK` headers can be removed using the connection parameter `noSDKHeaders`.
+
+### Custom HTTP headers
+In version 1.1.3 and above, it is possible to pass additional HTTP headers or override HTTP headers set by the SDK. This can be done globally (i.e. for all API calls), or locally, i.e. just for a particular call, or both.
+
+Http headers are passed through an object whose keys represent the header name and values the corresponding header value. Nothing particular is done in term of case sensitivity, headers will be passed as passed.
+
+To set global HTTP headers for all API calls of a client, pass an http headers array in the connection parameters
+```js
+const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword(
+                                    "https://myInstance.campaign.adobe.com", 
+                                    "admin", "admin",
+                                    { extraHttpHeaders: {
+                                        "X-ACC-JS-SDK-LBSAFE": "1",
+                                        "X-ACC-WEBUI-VERSION: "1.2"
+                                    } });
+```
+
+Subsequent API calls will have the corresponding headers set.
+
+To set more HTTP headers for a particular API call, use the "headers" method of the NLWS object.
+
+```js
+const query = client.NLWS
+    .headers({'X-Test': 'hello'})
+    .xtkQueryDef.create(queryDef);
+await query.executeQuery();
+```
+
 
 
 # Samples
@@ -1144,6 +1247,17 @@ const folder = {
 await NLWS.xtkSession.write(folder);
 ````
 
+Some objects, such as deliveries are created from templates. The `createFromModel` API is preferred in this case. Given a template name, and a patch object, it will return an object created from the template and the patch, applying all sort of business rules and default values. This object can be inserted using a writer.
+
+In this example, an email delivery is created from the "mail" delivery template and it's label is set to "Hello".
+
+Note the xtkschema attribute in the second parameter of the `createFromModel` API call which is needed for the SDK to perform the proper JSON to XML transformation.
+
+```js
+const mail = await client.NLWS.nmsDelivery.createFromModel('mail', { xtkschema:'nms:delivery', label:'Hello'});
+await client.NLWS.xtkSession.write(mail);
+````
+
 # Workflow API
 
 Start and stop wotkflows, passing either an id or workflow internal name

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@adobe/acc-js-sdk",
-      "version": "1.1.2",
+      "version": "1.1.3",
       "license": "ISC",
       "dependencies": {
         "axios": "^0.25.0",

package/package.json

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

package/samples/utils.js

@@ -47,7 +47,9 @@ async function run(main) {
  */
 async function logon(callback) {
   var main = async () => {
-    const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword(url, user, password);
+    const connectionParameters = sdk.ConnectionParameters.ofUserAndPassword(url, user, password, {
+      clientApp: 'acc-js-sdk sample'
+    });
     const client = await sdk.init(connectionParameters);
     const NLWS = client.NLWS;
   

package/src/client.js

@@ -105,16 +105,35 @@ const xtkObjectHandler = {
  * @private
  * @memberof Campaign
  */
-const clientHandler = (representation) => {
+const clientHandler = (representation, headers) => {
     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"));
+            if (namespace == "xml") return new Proxy(client, clientHandler("xml", headers));
+            if (namespace == "json") return new Proxy(client, clientHandler("SimpleJson", headers));
+
+            // Override HTTP headers (NLWS.headers({...}))
+            // Unlike NLWS.xml or NLWS.json, NLWS.headers returns a function. This function takes key/value
+            // pairs of headers, and, when called, returns a proxy object which will remember the headers
+            // and be able to pass them to subsequent SOAP call context
+            if (namespace == "headers") return (methodHeaders) => {
+                // Build of copy of the http headers and append new headers in order to accomodate
+                // chained calls, such as NLWS.headers(...).headers(...)
+                const newHeaders = {};
+                if (headers) for (let h in headers) newHeaders[h] = headers[h];
+                if (methodHeaders) for (let h in methodHeaders) newHeaders[h] = methodHeaders[h];
+                return new Proxy(client, clientHandler(representation, newHeaders));
+            };
 
             return new Proxy({ client:client, namespace:namespace}, {
                 get: function(callContext, methodName) {
                     callContext.representation = representation;
+                    callContext.headers = callContext.headers || client._connectionParameters._options.extraHttpHeaders;
+                    if (headers) {
+                        for (let h in headers) callContext.headers[h] = headers[h];
+                    }
+
                     if (methodName == ".") return callContext;
 
                     // get Schema id from namespace (find first upper case letter)
@@ -248,6 +267,9 @@ class Credentials {
     * @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
+    * @property {{ name:string, value:string}} extraHttpHeaders - optional key/value pair of HTTP header (will override any other headers)
+    * @property {string} clientApp - optional name/version of the application client of the SDK. This will be passed in HTTP headers for troubleshooting
+    * @property {boolean} noSDKHeaders - set to disable "ACC-SDK" HTTP headers
     * @memberOf Campaign
  */
  
@@ -312,6 +334,12 @@ class ConnectionParameters {
         this._options._storage = storage;
         this._options.refreshClient = options.refreshClient;
         this._options.charset = options.charset === undefined ? "UTF-8": options.charset;
+        this._options.extraHttpHeaders = {};
+        if (options.extraHttpHeaders) {
+            for (let h in options.extraHttpHeaders) this._options.extraHttpHeaders[h] = options.extraHttpHeaders[h];
+        }
+        this._options.clientApp = options.clientApp;
+        this._options.noSDKHeaders = !!options.noSDKHeaders;
     }
 
     /**
@@ -684,13 +712,15 @@ class Client {
      * @private
      * @param {string} urn is the API name space, usually the schema. For instance xtk:session
      * @param {string} method is the method to call, for instance Logon
+     * @param {boolean} internal is a boolean indicating whether the SOAP call is performed by the SDK (internal = true) or on behalf of a user
      * @return {SOAP.SoapMethodCall} a SoapMethodCall which have been initialized with security tokens... and to which the method
      * parameters should be set
      */
-    _prepareSoapCall(urn, method, internal) {
+    _prepareSoapCall(urn, method, internal, extraHttpHeaders) {
         const soapCall = new SoapMethodCall(this._transport, urn, method, 
                                             this._sessionToken, this._securityToken, 
-                                            this._getUserAgentString(), this._connectionParameters._options.charset);
+                                            this._getUserAgentString(), this._connectionParameters._options.charset,
+                                            extraHttpHeaders);
         soapCall.internal = !!internal;
         return soapCall;
     }
@@ -704,6 +734,7 @@ class Client {
      */
     async _retrySoapCall(soapCall) {
         soapCall.retry = false;
+        soapCall._retryCount = soapCall._retryCount + 1;
         var newClient = await this._refreshClient(this); 
         soapCall.finalize(newClient._soapEndPoint(), newClient);
         if (this._traceAPICalls) {
@@ -778,6 +809,18 @@ class Client {
         this._securityToken = "";
         const credentials = this._connectionParameters._credentials;
 
+        const sdkVersion = this.sdk.getSDKVersion();
+        const version = `${sdkVersion.name} ${sdkVersion.version}`;
+        const clientApp = this._connectionParameters._options.clientApp;
+        if (!this._connectionParameters._options.noSDKHeaders) {
+            this._connectionParameters._options.extraHttpHeaders["ACC-SDK-Version"] = version;
+            this._connectionParameters._options.extraHttpHeaders["ACC-SDK-Auth"] = `${credentials._type}`;
+            if (clientApp)
+                this._connectionParameters._options.extraHttpHeaders["ACC-SDK-Client-App"] = clientApp;
+        }
+        // See NEO-35259
+        this._connectionParameters._options.extraHttpHeaders['X-Query-Source'] = `${version}${clientApp? "," + clientApp : ""}`;
+
         // Clear session token cookie to ensure we're not inheriting an expired cookie. See NEO-26589
         if (credentials._type != "SecurityToken" && typeof document != "undefined") {
             document.cookie = '__sessiontoken=;path=/;';
@@ -790,8 +833,8 @@ class Client {
             that.application = new Application(that);
             return Promise.resolve();
         }
-        else if (credentials._type == "SecurityToken") { 
-           that._sessionInfo = undefined;
+        else if (credentials._type == "SecurityToken") {
+            that._sessionInfo = undefined;
             that._installedPackages = {};
             that._sessionToken = "";
             that._securityToken = credentials._securityToken;
@@ -799,12 +842,14 @@ class Client {
             return Promise.resolve();
         }
         else if (credentials._type == "UserPassword" || credentials._type == "BearerToken") {
-            const soapCall = that._prepareSoapCall("xtk:session", credentials._type === "UserPassword" ? "Logon" : "BearerTokenLogon");
+            const soapCall = that._prepareSoapCall("xtk:session", credentials._type === "UserPassword" ? "Logon" : "BearerTokenLogon", false, this._connectionParameters._options.extraHttpHeaders);
             // No retry for logon SOAP methods
             soapCall.retry = false;
             if (credentials._type == "UserPassword") {
                 const user = credentials._getUser();
                 const password = credentials._getPassword();
+                if (!this._connectionParameters._options.noSDKHeaders)
+                    this._connectionParameters._options.extraHttpHeaders["ACC-SDK-Auth"] = `${credentials._type} ${user}`;
                 soapCall.writeString("login", user);
                 soapCall.writeString("password", password);
                 var parameters = null;
@@ -872,7 +917,7 @@ class Client {
         if (!that.isLogged()) return;
         const credentials = this._connectionParameters._credentials;
         if (credentials._type != "SessionToken" && credentials._type != "AnonymousUser") {
-            var soapCall = that._prepareSoapCall("xtk:session", "Logoff");
+            var soapCall = that._prepareSoapCall("xtk:session", "Logoff", false, this._connectionParameters._options.extraHttpHeaders);
                 return this._makeSoapCall(soapCall).then(function() {
                 that._sessionToken = "";
                 that._securityToken = "";
@@ -977,7 +1022,7 @@ class Client {
      * @returns {boolean} a boolean indicating if the package is installed or not
      */
     hasPackage(packageId, optionalName) {
-    if (optionalName === undefined)
+    if (optionalName !== undefined)
         packageId = `${packageId}:${optionalName}`;
     if (!this.isLogged())
         throw CampaignException.NOT_LOGGED_IN(undefined, `Cannot call hasPackage: session not connected`);
@@ -991,7 +1036,7 @@ class Client {
      * @private
      * @deprecated since version 1.0.0
      */
-    async _getSecretKeyCipher() {
+     async _getSecretKeyCipher() {
         var that = this;
         if (this._secretKeyCipher) return this._secretKeyCipher;
         return that.getOption("XtkSecretKey").then(function(secretKey) {
@@ -1014,7 +1059,7 @@ class Client {
      */
      async getEntityIfMoreRecent(entityType, fullName, representation, internal) {
         const that = this;
-        const soapCall = this._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", internal);
+        const soapCall = this._prepareSoapCall("xtk:persist", "GetEntityIfMoreRecent", internal, this._connectionParameters._options.extraHttpHeaders);
         soapCall.writeString("pk", entityType + "|" + fullName);
         soapCall.writeString("md5", "");
         soapCall.writeBoolean("mustExist", false);
@@ -1117,7 +1162,7 @@ class Client {
         // console.log(method.toXMLString());
 
         var urn = that._methodCache.getSoapUrn(schemaId, methodName);
-        var soapCall = that._prepareSoapCall(urn, methodName);
+        var soapCall = that._prepareSoapCall(urn, methodName, false, callContext.headers);
 
         // If method is called with one parameter which is a function, then we assume it's a hook: the function will return
         // the actual list of parameters
@@ -1158,6 +1203,8 @@ class Client {
                         soapCall.writeByte(paramName, XtkCaster.asByte(paramValue));
                     else if (type == "short")
                         soapCall.writeShort(paramName, XtkCaster.asShort(paramValue));
+                    else if (type == "int")
+                        soapCall.writeLong(paramName, XtkCaster.asLong(paramValue));
                     else if (type == "long")
                         soapCall.writeLong(paramName, XtkCaster.asLong(paramValue));
                     else if (type == "int64")
@@ -1182,6 +1229,7 @@ class Client {
                             const index = xtkschema.indexOf(":");
                             docName = xtkschema.substr(index+1);
                         }
+                        if (!docName) docName = paramName; // Use te parameter name as the XML root element
                         var xmlValue = that._fromRepresentation(docName, paramValue, callContext.representation);
                         if (type == "DOMDocument")
                             soapCall.writeDocument(paramName, xmlValue);
@@ -1321,8 +1369,11 @@ class Client {
      */
     async test() {
         const request = {
-            url: `${this._connectionParameters._endpoint}/r/test`
+            url: `${this._connectionParameters._endpoint}/r/test`,
+            headers: {}
         };
+        for (let h in this._connectionParameters._options.extraHttpHeaders)
+            request.headers[h] = this._connectionParameters._options.extraHttpHeaders[h];
         const body = await this._makeHttpCall(request);
         const xml = DomUtil.parse(body);
         const result = this._toRepresentation(xml);
@@ -1342,6 +1393,8 @@ class Client {
                 'Cookie': '__sessiontoken=' + this._sessionToken
             }
         };
+        for (let h in this._connectionParameters._options.extraHttpHeaders)
+            request.headers[h] = this._connectionParameters._options.extraHttpHeaders[h];
         const body = await this._makeHttpCall(request);
         const lines = body.split('\n');
         const doc = DomUtil.newDocument("ping");
@@ -1371,6 +1424,8 @@ class Client {
                 'Cookie': '__sessiontoken=' + this._sessionToken
             }
         };
+        for (let h in this._connectionParameters._options.extraHttpHeaders)
+            request.headers[h] = this._connectionParameters._options.extraHttpHeaders[h];
         const body = await this._makeHttpCall(request);
         const lines = body.split('\n');
         const doc = DomUtil.newDocument("ping");

package/src/soap.js

@@ -79,11 +79,12 @@ const NS_XSD = "http://www.w3.org/2001/XMLSchema";
  * @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
+ * @param {{ name:string, value:string}} extraHttpHeaders key/value pair of HTTP header (will override any other headers)
  * @memberof SOAP
  */
 class SoapMethodCall {
     
-    constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString, charset) {
+    constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString, charset, extraHttpHeaders) {
         this.request = undefined;       // The HTTP request (object litteral passed to the transport layer)
         this.response = undefined;      // The HTTP response object (in case of success)
 
@@ -96,11 +97,13 @@ class SoapMethodCall {
         this.internal = false;
         // Enable soap retry
         this.retry = true;
+        this._retryCount = 0;
 
         this._sessionToken = sessionToken || "";
         this._securityToken = securityToken || "";
         this._userAgentString = userAgentString;
         this._charset = charset || "";
+        this._extraHttpHeaders = extraHttpHeaders || {};
 
         // THe SOAP call being built
         this._doc = undefined;           // XML document for SOAP call
@@ -213,7 +216,7 @@ class SoapMethodCall {
      * @param {string} tag the parameter name
      * @param {*} value the parameter value, which will be casted to a int32 according to xtk rules
      */
-    writeLong(tag, value) {
+     writeLong(tag, value) {
         value = XtkCaster.asLong(value);
         this._addNode(tag, "xsd:int", XtkCaster.asString(value), SOAP_ENCODING_NATIVE);
     }
@@ -299,7 +302,8 @@ class SoapMethodCall {
     writeDocument(tag, document) {
         const node = this._addNode(tag, "", null, SOAP_ENCODING_XML);
         if (document !== null && document !== undefined) {
-            const child = this._doc.importNode(document.documentElement, true);
+            const element = document.nodeType === 1 ? document : document.documentElement;
+            const child = this._doc.importNode(element, true);
             node.appendChild(child);
         }
     }
@@ -515,20 +519,36 @@ class SoapMethodCall {
      */
     _createHTTPRequest(url) {
 
+        const headers = {
+            'Content-type': `application/soap+xml${this._charset ? ";charset=" + this._charset : ""}`,
+            'SoapAction': `${this.urn}#${this.methodName}`,
+            'X-Security-Token': this._securityToken
+        };
+
+        // Add HTTP headers specific to the SOAP call for better tracing/troubleshooting
+        if (this._extraHttpHeaders && this._extraHttpHeaders['ACC-SDK-Version']) {
+            // "this.retry" means that the call can be retried, not that it is being retried. The HTTP header howerver, indicates that this
+            // is actually a retry of a previously failed call (expired token)
+            if (this._retryCount > 0) headers["ACC-SDK-Call-RetryCount"] = `${this._retryCount}`;
+            if (this.internal) headers["ACC-SDK-Call-Internal"] = "1";
+        }
+
         const options = {
             url: url,
             method: 'POST',
-            headers: {
-                'Content-type': `application/soap+xml${this._charset ? ";charset=" + this._charset : ""}`,
-                'SoapAction': `${this.urn}#${this.methodName}`,
-                'X-Security-Token': this._securityToken
-            },
+            headers: headers,
             data: DomUtil.toXMLString(this._doc)
         };
         if (this._sessionToken)
             options.headers.Cookie = '__sessiontoken=' + this._sessionToken;
         if (this._userAgentString)
             options.headers['User-Agent'] = this._userAgentString;
+
+        // Override http headers with custom headers
+        for (let h in this._extraHttpHeaders) {
+            options.headers[h] = this._extraHttpHeaders[h];
+        }
+
         return options;
     }
     

package/test/client.hasPackage.test.js

@@ -56,12 +56,12 @@ describe('ACC Client (has package)', () => {
     client._transport.mockReturnValueOnce(LOGON_RESPONSE);
     await client.NLWS.xtkSession.logon();
 
-    expect(client.hasPackage("nms:campaign"));
-    expect(client.hasPackage("nms", "campaign"));
-    expect(!client.hasPackage("nms:mrm"));
-    expect(!client.hasPackage("nms", "mrm"));
-    expect(client.hasPackage("nms:core"));
-    expect(client.hasPackage("nms", "core"));
+    expect(client.hasPackage("nms:campaign")).toBeTruthy();
+    expect(client.hasPackage("nms", "campaign")).toBeTruthy();
+    expect(client.hasPackage("nms:mrm")).toBeFalsy();
+    expect(client.hasPackage("nms", "mrm")).toBeFalsy();
+    expect(client.hasPackage("nms:core")).toBeTruthy();
+    expect(client.hasPackage("nms", "core")).toBeTruthy();
   });
 
   it('should fail when unlogged', async () => {

package/test/client.test.js

@@ -2283,15 +2283,15 @@ describe('ACC Client', function () {
         it("Should ignore protocol for local storage root key", async () => {
             var connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", {});
             var client = await sdk.init(connectionParameters);
-            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.2.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.3.acc-sdk:8080.cache.OptionCache$");
 
             connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("https://acc-sdk:8080", "admin", "admin", {});
             client = await sdk.init(connectionParameters);
-            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.2.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.3.acc-sdk:8080.cache.OptionCache$");
 
             connectionParameters = sdk.ConnectionParameters.ofUserAndPassword("acc-sdk:8080", "admin", "admin", {});
             client = await sdk.init(connectionParameters);
-            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.2.acc-sdk:8080.cache.OptionCache$");
+            expect(client._optionCache._storage._rootKey).toBe("acc.js.sdk.1.1.3.acc-sdk:8080.cache.OptionCache$");
         })
 
         it("Should support no storage", async () => {
@@ -2474,4 +2474,333 @@ describe('ACC Client', function () {
             expect(json).toBe('{"#text":[],"extAccount":[{"id":"1816","name":"defaultPopAccount"},{"id":"1818","name":"defaultOther"},{"id":"1849","name":"billingReport"},{"id":"12070","name":"TST_EXT_ACCOUNT_POSTGRESQL"},{"id":"1817","name":"defaultEmailBulk"},{"id":"2087","name":"ffda"},{"id":"2088","name":"defaultEmailMid"}]}');
         });
     });
+
+    describe('Support for int type parameters such as nms:extAccount#UpdateMCSynchWkf', () => {
+        it("Should call nms:extAccount#UpdateMCSynchWkf", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            client._transport.mockReturnValueOnce(Promise.resolve(`<?xml version='1.0'?>
+            <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:wpp:default' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
+            <SOAP-ENV:Body>
+                <GetEntityIfMoreRecentResponse xmlns='urn:wpp:default' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+                    <pdomDoc xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
+                        <schema name="extAccount" namespace="nms" xtkschema="xtk:schema">
+                            <element name="extAccount"></element>
+                            <methods>
+                                <method library="nms:messageCenter.js" name="UpdateMCSynchWkf" static="true" hidden="true">
+                                <parameters>
+                                    <param name="extAccountId" type="int" desc="Message Center external account identifier"/>
+                                </parameters>
+                            </method>
+                            </methods>
+                        </schema>
+                    </pdomDoc>
+                </GetEntityIfMoreRecentResponse>
+            </SOAP-ENV:Body>
+            </SOAP-ENV:Envelope>`));
+
+            client._transport.mockReturnValueOnce(Promise.resolve(`<?xml version='1.0'?>
+            <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:nms:extAccount' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
+            <SOAP-ENV:Body>
+            <UpdateMCSynchWkfResponse xmlns='urn:nms:extAccount' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+            </UpdateMCSynchWkfResponse>
+            </SOAP-ENV:Body>
+            </SOAP-ENV:Envelope>`));
+
+            await client.NLWS.nmsExtAccount.updateMCSynchWkf(1);
+        })
+    });
+
+    describe("Method-level HTTP headers", () => {
+        it("Should set header", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.headers({'X-Test': 'hello'}).xtkQueryDef.create(queryDef);
+
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                }
+            });
+            await query.executeQuery();
+            expect(headers).toMatchObject({
+                "SoapAction": "xtk:queryDef#ExecuteQuery",
+                "X-Test": "hello"
+            });
+        });
+
+        it("Should support global and method-level http headers", async () => {
+            const client = await Mock.makeClient({
+                extraHttpHeaders: {
+                    "X-Test": "world",
+                    "X-Test-Global": "global"
+                }
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.headers({'X-Test': 'hello'}).xtkQueryDef.create(queryDef);
+
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                }
+            });
+            await query.executeQuery();
+            expect(headers).toMatchObject({
+                "SoapAction": "xtk:queryDef#ExecuteQuery",
+                "X-Test": "hello",
+                "X-Test-Global": "global"
+            });
+        })
+
+        it("Should support undefined method headers", async () => {
+            const client = await Mock.makeClient({
+                extraHttpHeaders: {
+                    "X-Test": "world",
+                    "X-Test-Global": "global"
+                }
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            // missing headers
+            const query = client.NLWS.headers().xtkQueryDef.create(queryDef);
+
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                }
+            });
+            await query.executeQuery();
+            expect(headers).toMatchObject({
+                "SoapAction": "xtk:queryDef#ExecuteQuery",
+                "X-Test": "world",
+                "X-Test-Global": "global"
+            });
+        })
+
+        it("Should set http headers with an xml representation", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = DomUtil.parse(`
+                <queryDef schema="nms:extAccount" operation="select">
+                    <select>
+                        <node expr="@id"/>
+                        <node expr="@name"/>
+                    </select>
+                </queryDef>
+            `);
+            const query = client.NLWS
+                .headers({'X-Test': 'hello', 'X-Test-Before': 'before'})
+                .xml
+                .headers({'X-Test': 'world', 'X-Test-After': 'after'})
+                .xtkQueryDef.create(queryDef);
+                let headers = {};
+                client.registerObserver({
+                    onSOAPCall: (soapCall) => {
+                        const request = soapCall.request;
+                        headers = request.headers;
+                    }
+                });
+                await query.executeQuery();
+                console.log(headers);
+                expect(headers).toMatchObject({
+                    "SoapAction": "xtk:queryDef#ExecuteQuery",
+                    "X-Test": "world",
+                    "X-Test-Before": "before",
+                    "X-Test-After": "after"
+                });
+        });
+    });
+
+    describe("ACC-SDK HTTP headers", () => {
+
+        const collectHeaders = async (client, callback) => {
+            let headers = {};
+            client.registerObserver({
+                onSOAPCall: (soapCall) => {
+                    const request = soapCall.request;
+                    headers = request.headers;
+                },
+                onHTTPCall: (request) => {
+                    headers = request.headers;
+                }
+            });
+            await callback();
+            return headers;
+        };
+
+        it("Should set headers by default", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.xtkQueryDef.create(queryDef);
+
+            const headers = await collectHeaders(client, async() => {
+                await query.executeQuery();
+            });
+
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+            });
+            // This header is only set if "clientApp" connection parameter is set
+            expect(headers["ACC-SDK-Client-App"]).toBeUndefined();
+        });
+
+        it("Should disable ACC-SDK headers", async () => {
+            const client = await Mock.makeClient({
+                noSDKHeaders: true
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.xtkQueryDef.create(queryDef);
+
+            const headers = await collectHeaders(client, async() => {
+                await query.executeQuery();
+            });
+            expect(headers["ACC-SDK-Version"]).toBeUndefined();
+            expect(headers["ACC-SDK-Auth"]).toBeUndefined();
+            expect(headers["X-Query-Source"]).toBe(`${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`);
+        });
+
+        it("Should support ACC-SDK-Client-App header", async () => {
+            const client = await Mock.makeClient({
+                clientApp: 'Test client app'
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            client._transport.mockReturnValueOnce(Mock.GET_XTK_QUERY_SCHEMA_RESPONSE);
+            client._transport.mockReturnValueOnce(Mock.GET_QUERY_EXECUTE_RESPONSE);
+            const queryDef = {
+                "schema": "nms:extAccount",
+                "operation": "select",
+                "select": {
+                    "node": [
+                        { "expr": "@id" },
+                        { "expr": "@name" }
+                    ]
+                }
+            };
+            const query = client.NLWS.xtkQueryDef.create(queryDef);
+
+            const headers = await collectHeaders(client, async() => {
+                await query.executeQuery();
+            });
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "ACC-SDK-Client-App": "Test client app",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version},Test client app`,
+            });
+        });
+
+        it("Should set ACC-SDK headers on ping JSP", async () => {
+            const client = await Mock.makeClient({
+                clientApp: 'Test client app'
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            const headers = await collectHeaders(client, async() => {
+                client._transport.mockReturnValueOnce(Mock.PING);
+                await client.ping();
+            });
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "ACC-SDK-Client-App": "Test client app",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version},Test client app`,
+            });
+        });
+
+        it("Should set ACC-SDK headers on mcping JSP", async () => {
+            const client = await Mock.makeClient({
+                clientApp: 'Test client app'
+            });
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            const headers = await collectHeaders(client, async() => {
+                client._transport.mockReturnValueOnce(Mock.MC_PING);
+                await client.mcPing();
+            });
+            expect(headers).toMatchObject({
+                "ACC-SDK-Version": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version}`,
+                "ACC-SDK-Auth": "UserPassword admin",
+                "ACC-SDK-Client-App": "Test client app",
+                "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version},Test client app`,
+            });
+        });
+    });
 });

package/test/soap.test.js

@@ -25,8 +25,8 @@ const sdk = require('../src/index.js');
 
 const URL = "https://soap-test/nl/jsp/soaprouter.jsp";
 
-function makeSoapMethodCall(transport, urn, methodName, sessionToken, securityToken, userAgentString, optionalCharset) {
-    const call = new SoapMethodCall(transport, urn, methodName, sessionToken, securityToken, userAgentString, optionalCharset);
+function makeSoapMethodCall(transport, urn, methodName, sessionToken, securityToken, userAgentString, optionalCharset, charset, extraHttpHeaders) {
+    const call = new SoapMethodCall(transport, urn, methodName, sessionToken, securityToken, userAgentString, optionalCharset, charset, extraHttpHeaders);
     return call;
 }
 
@@ -388,6 +388,22 @@ describe('SOAP', function() {
             expect(actualElement.getAttribute("att")).toBe("Hello");
         });
 
+        it('Should support passing DOM elements instead of document parameters', function() {
+            const xml = '<root att="Hello"><child/></root>';
+            const doc = DomUtil.parse(xml);
+
+            const call = makeSoapMethodCall(undefined, "xtk:session", "Document", "$session$", "$security$");
+            call.writeDocument("p", doc.documentElement);
+            const request = call._createHTTPRequest(URL);
+            const env = DomUtil.parse(request.data).documentElement;
+            const body = hasChildElement(env, "SOAP-ENV:Body");
+            const method = hasChildElement(body, "m:Document");
+            const param = hasChildElement(method, "p");
+            const actualElement = hasChildElement(param, "root");
+            expect(actualElement).toBeTruthy();
+            expect(actualElement.getAttribute("att")).toBe("Hello");
+        });
+
         it('Should write null document', function() {
             const call = makeSoapMethodCall(undefined, "xtk:session", "Document", "$session$", "$security$");
             call.writeDocument("p", null);
@@ -850,5 +866,23 @@ describe("Campaign exception", () => {
         expect(req.headers["X-Security-Token"].indexOf("$security$")).toBe(-1);
     })
 
+    describe('Extra Http headers', () => {
+        it("Should take additional headers", () => {
+            const call = makeSoapMethodCall(undefined, "xtk:session", "Date", "$session$", "$security$", "My User Agent", undefined, { 'X-ACC-UI-Version': '1.0' });
+            const request = call._createHTTPRequest(URL);
+            expect(request.headers['User-Agent']).toBe("My User Agent");
+            expect(request.headers['X-ACC-UI-Version']).toBe("1.0");
+            expect(request.headers['SoapAction']).toBe("xtk:session#Date");
+        });
+
+        it("Should override default headers headers", () => {
+            const call = makeSoapMethodCall(undefined, "xtk:session", "Date", "$session$", "$security$", "My User Agent", undefined, { 'X-ACC-UI-Version': '1.0', 'SoapAction': 'My soap action' });
+            const request = call._createHTTPRequest(URL);
+            expect(request.headers['User-Agent']).toBe("My User Agent");
+            expect(request.headers['X-ACC-UI-Version']).toBe("1.0");
+            expect(request.headers['SoapAction']).toBe("My soap action");
+        });
+    });
+
 });