@adobe/acc-js-sdk 1.1.37 → 1.1.38

package/docs/_data/navigation.yml

@@ -107,6 +107,8 @@
       link: passwords.html
     - name: Differences between the SDK and Campaign
       link: differences.html
+    - name: Anonymous SOAP calls
+      link: anonymous.html
 - name: --
 - name: Contributing
   children:

package/docs/anonymous.html

@@ -0,0 +1,41 @@
+---
+layout: page
+title: Anonymous SOAP calls
+---
+
+<p>
+    The ACC JS SDK uses schemas to dynamically discover available methods and their signature. 
+    But fetching schemas requires an authenticated user.
+    This means it's not directly possible to call anonymous SOAP methods from the SDK.
+</p>
+
+<p>
+    Anonymous SOAP methods are declared with the <b>access</b> attribute set to <b>anonymous</b>
+</p>
+
+<pre class="code">
+&lt;method name="GetServerTime" static="true" access="anonymous">
+    &lt;help>Returns the server date and time&lt;/help>
+    &lt;parameters>
+        &lt;param name="serverTime"  type="datetime"  inout="out"/>
+    &lt;/parameters>
+&lt;/method>
+</pre>
+
+<p>
+    In order to call anonymous SOAP methods, one therefore needs a different mechanism and the <b>makeSoapCall</b> method can be used
+</p>
+
+<pre class="code">
+const sdk = require('@adobe/acc-js-sdk');
+const connectionParameters = sdk.ConnectionParameters.ofAnonymousUser("https://myInstance.campaign.adobe.com");
+var client = await sdk.init(connectionParameters);
+
+client.traceAPICalls(true);
+
+
+var inputParams = [];
+var outputParams = [{ name: "serverTime", type: "datetime" }];
+var result = await client.makeSoapCall("xtk:session", "GetServerTime", true, inputParams, outputParams);
+console.log(result);
+</pre>

package/docs/changeLog.html

@@ -3,6 +3,14 @@ layout: page
 title: Change Log
 ---
 
+<section class="changelog"><h1>Version 1.1.38</h1>
+  <h2>2023/09/06</h2>
+  <li>
+    Add support for anonymous SOAP calls. See <a href="https://opensource.adobe.com/acc-js-sdk/anonymous.html"></a> for more information.
+  </li>
+</section>
+
+
 <section class="changelog"><h1>Version 1.1.37</h1>
   <h2>2023/08/07</h2>
   <li>

package/package-lock.json

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

package/package.json

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

package/src/client.js

@@ -243,7 +243,7 @@ class Credentials {
      * @param {string} securityToken the security token. Will use an empty token if not specified
      */
     constructor(type, sessionToken, securityToken) {
-        if (type != "UserPassword" && type != "ImsServiceToken" && type != "SessionToken" &&
+        if (type != "UserPassword" && type != "ImsServiceToken" && type != "SessionToken" && type != "SessionAndSecurityToken" &&
             type != "AnonymousUser" && type != "SecurityToken" && type != "BearerToken" && type != "ImsBearerToken")
             throw CampaignException.INVALID_CREDENTIALS_TYPE(type);
         this._type = type;
@@ -458,6 +458,21 @@ class ConnectionParameters {
         return new ConnectionParameters(endpoint, credentials, options);
     }
 
+    /**
+     * Creates connection parameters for a Campaign instance, using a session token and a security token
+     *
+     * @static
+     * @param {string} endpoint The campaign endpoint (URL)
+     * @param {string} sessionToken The session token
+     * @param {string} securityToken The security token
+     * @param {Campaign.ConnectionOptions} options connection options
+     * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
+     */
+    static ofSessionAndSecurityToken(endpoint, sessionToken, securityToken, options) {
+        const credentials = new Credentials("SessionAndSecurityToken", sessionToken, securityToken);
+        return new ConnectionParameters(endpoint, credentials, options);
+    }
+    
     /**
      * Creates connection parameters for a Campaign instance, using a security token.
      * Typically, called when embedding the SDK in Campaign: the session token will be
@@ -466,7 +481,7 @@ class ConnectionParameters {
      *
      * @static
      * @param {string} endpoint The campaign endpoint (URL)
-     * @param {string} securityToken The session token
+     * @param {string} securityToken The security token
      * @param {Campaign.ConnectionOptions} options connection options
      * @returns {ConnectionParameters} a ConnectionParameters object which can be used to create a Client
      */
@@ -1497,11 +1512,11 @@ class Client {
         if (credentials._type != "SecurityToken" && typeof document != "undefined") {
             document.cookie = '__sessiontoken=;path=/;';
         }
-        if (credentials._type == "SessionToken" || credentials._type == "AnonymousUser") {
+        if (credentials._type == "SessionToken" || credentials._type == "AnonymousUser" || credentials._type == "SessionAndSecurityToken") {
             that._sessionInfo = undefined;
             that._installedPackages = {};
             that._sessionToken = credentials._sessionToken;
-            that._securityToken = "";
+            that._securityToken = credentials._type == "SessionAndSecurityToken" ? credentials._securityToken : "";
             that._bearerToken = undefined;
             that._onLogon();
             return Promise.resolve();
@@ -2059,7 +2074,30 @@ class Client {
             result.push(outputParams[i].value);
         }
         return result;
+    }
 
+    /**
+     * Public API to dynamically invoke SOAP calls. This API allows to call any SOAP calls, including anonyous
+     * SOAP calls such as xtk:session#GetServerTime
+     * 
+     * @param {string} urn is the schema id, such as "xtk:session"
+     * @param {string} methodName is the name of the method to call, for example "GetServerTime"
+     * @param {boolean} isStatic indicates if the method is static or not
+     * @param {array} inputParams is an array of input parameters. Each element of the array is an object with the following properties: name, type, value
+     * @param {array} outputParams is an array of output parameters. Each element of the array is an object with the following properties: name, type
+     * @param {string} representation the expected representation ('xml', 'BadgerFish', or 'SimpleJson'). If not set, will use the current representation
+     * 
+     * @returns {array} the method return values in the same order as was described in the outputParams array.
+     * In addition, the outputParams array will be modified, and the "value" property of each output param will be set
+     */
+    async makeSoapCall(urn, methodName, isStatic, inputParams, outputParams, representation) {
+        const soapCall = this._prepareSoapCall(urn, methodName, isStatic, false, 
+          this._connectionParameters._options.extraHttpHeaders);
+        // To support anonymous SOAP calls, we need to disable the logon check
+        soapCall.requiresLogon = () => false;
+        await this._makeInterceptableSoapCall(urn, null, soapCall, inputParams, outputParams, representation);
+        const results = outputParams.map((o)=> o.value);
+        return results;
     }
 
     async _makeHttpCall(request) {

package/test/client.test.js

@@ -2203,8 +2203,24 @@ describe('ACC Client', function () {
             expect(client.isLogged()).toBeFalsy();
             // Ensure logoff has been called
             expect(logoff.mock.calls.length).toBe(1);
-        })
-     })
+        });
+     });
+
+     describe("Session and security tokens authentication", () => {
+        it("Should create logged client", async() => {
+            const connectionParameters = sdk.ConnectionParameters.ofSessionAndSecurityToken("http://acc-sdk:8080", "$session_token$", "$security_token$");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            expect(client.isLogged()).toBeFalsy();
+            await client.logon();
+            expect(client.isLogged()).toBeTruthy();
+            const logoff = client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.logoff();
+            expect(client.isLogged()).toBeFalsy();
+            // Ensure logoff has been called
+            expect(logoff.mock.calls.length).toBe(1);
+        });
+     });
 
     describe("Bearer token authentication", () => {
         // Bearer token authentication is used when embedding IMS for authentication
@@ -4142,4 +4158,55 @@ describe('ACC Client', function () {
             await expect(jobs.linkTarget()).rejects.toThrow(/Cannot read (.*getSchema.*of null)|(.*of null.*getSchema)/);
         });
     });
+
+    describe("Anonymous SOAP calls", () => {
+        it("Should call xtk:session#GetServerTime", async () => {
+            const connectionParameters = sdk.ConnectionParameters.ofAnonymousUser("http://acc-sdk:8080");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            
+            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:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
+                <SOAP-ENV:Body>
+                <GetServerTimeResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
+                    <ptmServerTime xsi:type='xsd:dateTime'>2023-08-25T13:58:11.477Z</ptmServerTime>
+                </GetServerTimeResponse>
+                </SOAP-ENV:Body>
+                </SOAP-ENV:Envelope>`));
+
+            const inputParams = [];
+            const outputParams = [{ name: "serverTime", type: "datetime" }];
+            const result = await client.makeSoapCall("xtk:session", "GetServerTime", true, inputParams, outputParams);
+            expect(result.length).toBe(1);
+            expect(result[0]).toEqual(new Date("2023-08-25T13:58:11.477Z"));
+            expect(outputParams[0].value).toEqual(new Date("2023-08-25T13:58:11.477Z"));
+        });
+
+        it("Should call xtk:session#Logon", async () => {
+            const connectionParameters = sdk.ConnectionParameters.ofAnonymousUser("http://acc-sdk:8080");
+            const client = await sdk.init(connectionParameters);
+            client._transport = jest.fn();
+            
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+
+            inputParams = [
+                { name: "login", type: "string", value: "admin" },
+                { name: "password", type: "string", value: "admin" },
+                { name: "parameters", type: "DOMElement", value: { rememberMe: true } },
+                
+              ];
+              outputParams = [
+                { name: "sessionToken", type: "string" },
+                { name: "session", type: "DOMElement" },
+                { name: "securityToken", type: "string" },
+              ];
+            const result = await client.makeSoapCall("xtk:session", "Logon", true, inputParams, outputParams);
+            expect(result.length).toBe(3);
+            expect(result[0]).toEqual("___$session_token$");
+            expect(outputParams[0].value).toEqual("___$session_token$");
+            expect(result[2]).toEqual("@$security_token$==");
+            expect(outputParams[2].value).toEqual("@$security_token$==");
+            expect(result[1].serverInfo.buildNumber).toBe("9219");
+        });
+    });
 });