@adobe/acc-js-sdk 1.1.59 → 1.1.61

package/docs/changeLog.html

@@ -3,6 +3,23 @@ layout: page
 title: Change Log
 ---
 
+<section class="changelog"><h1>Version 1.1.61</h1>
+  <h2>2025/09/16</h2>
+  <li>
+    Add request id to SOAP calls
+  </li>
+  <li>
+    Bumped dependencies version to fix vulnerabilities
+  </li>
+</section>
+
+<section class="changelog"><h1>Version 1.1.60</h1>
+  <h2>2025/09/04</h2>
+  <li>
+    Ability to bypass the cache to get a schema
+  </li>
+</section>
+
 <section class="changelog"><h1>Version 1.1.59</h1>
   <h2>2025/08/22</h2>
   <li>

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.59",
+  "version": "1.1.61",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@adobe/acc-js-sdk",
-      "version": "1.1.59",
+      "version": "1.1.61",
       "license": "ISC",
       "dependencies": {
         "axios": "^1.7.8",
@@ -1169,12 +1169,12 @@
       "license": "MIT"
     },
     "node_modules/axios": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.9.0.tgz",
-      "integrity": "sha512-re4CqKTJaURpzbLHtIi6XpDv20/CnpXOtjRY5/CU32L8gU8ek9UIivcfvSWvmKEngmVbrUtPpdDwWDWL7DNHvg==",
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
+      "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
       "dependencies": {
         "follow-redirects": "^1.15.6",
-        "form-data": "^4.0.0",
+        "form-data": "^4.0.4",
         "proxy-from-env": "^1.1.0"
       }
     },
@@ -5488,12 +5488,12 @@
       "version": "0.4.0"
     },
     "axios": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.9.0.tgz",
-      "integrity": "sha512-re4CqKTJaURpzbLHtIi6XpDv20/CnpXOtjRY5/CU32L8gU8ek9UIivcfvSWvmKEngmVbrUtPpdDwWDWL7DNHvg==",
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
+      "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
       "requires": {
         "follow-redirects": "^1.15.6",
-        "form-data": "^4.0.0",
+        "form-data": "^4.0.4",
         "proxy-from-env": "^1.1.0"
       }
     },

package/package.json

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

package/src/application.js

@@ -1419,15 +1419,19 @@ class Application {
      * Using the `XtkSchema` API makes it easier to navigate schemas than using a plain XML or JSON object
      * 
      * @param {string} schemaId 
+     * @param {boolean} withoutCache if true, the schema will be fetched from the server without using the cache, defaults to false
      * @returns {Campaign.XtkSchema} the schema, or null if the schema was not found
      */
-     async getSchema(schemaId) {
+     async getSchema(schemaId, withoutCache = false) {
+        if (withoutCache) {
+            return this._getSchema(schemaId, withoutCache);
+        }
         return this._schemaCache.getSchema(schemaId);
     }
 
     // Private function: get a schema without using the SchemaCache
-    async _getSchema(schemaId) {
-        const xml = await this.client.getSchema(schemaId, "xml");
+    async _getSchema(schemaId, withoutCache = false) {
+        const xml = await this.client.getSchema(schemaId, "xml", undefined, withoutCache);
         if (!xml)
             return null;
         return newSchema(xml, this);

package/src/client.js

@@ -1178,11 +1178,22 @@ class Client {
      * parameters should be set
      */
     _prepareSoapCall(urn, method, isStatic, internal, extraHttpHeaders, pushDownOptions) {
+        // Generate unique request ID for every SOAP call
+        let requestId;
+        try {
+          requestId = Util.getUUID();
+        } catch (error) {
+          console.error("Failed to generate request ID", error);
+        }
+        const updatedExtraHttpHeaders = requestId ? Object.assign({}, extraHttpHeaders, {
+              "x-request-id": requestId,
+            })
+          : extraHttpHeaders;
         const soapCall = new SoapMethodCall(this._transport, urn, method,
                                             this._sessionToken, this._securityToken,
                                             this._getUserAgentString(),
                                             Object.assign({}, this._connectionParameters._options, pushDownOptions),
-                                            extraHttpHeaders,
+                                            updatedExtraHttpHeaders,
                                             this._bearerToken);
         soapCall.internal = !!internal;
         soapCall.isStatic = isStatic;
@@ -1943,9 +1954,10 @@ class Client {
      * @param {string} schemaId the schema id, such as "xtk:session", or "nms:recipient"
      * @param {string} representation an optional representation of the schema: "BadgerFish", "SimpleJson" or "xml". If not set, we'll use the client default representation
      * @param {boolean} internal indicates an "internal" call, i.e. a call performed by the SDK itself rather than the user of the SDK. For instance, the SDK will dynamically load schemas to find method definitions
+     * @param {boolean} withoutCache if true, the schema will be fetched from the server without using the cache, defaults to false
      * @returns {XML.XtkObject}  the schema definition, as either a DOM document or a JSON object
      */
-    async getSchema(schemaId, representation, internal) {
+    async getSchema(schemaId, representation, internal, withoutCache = false) {
         // Support for Orchestrated Campaign XDM schemas (do not use cache)
         const pipeIndex = schemaId.indexOf("|");
         if( pipeIndex != -1 && schemaId.startsWith("xdm:") ) {
@@ -1955,7 +1967,7 @@ class Client {
             return entity;
         }
         var entity = await this._entityCache.get("xtk:schema", schemaId);
-        if (!entity) {
+        if (!entity || withoutCache) {
               // special case of "temp:group:*" schemas for nms:group
               // Schema "temp:group:*" is not cached because life cycle of this kind of schema is not the same as the others schemas
               if (schemaId.startsWith("temp:group:")) {

package/test/application.test.js

@@ -2543,7 +2543,36 @@ describe('Application', () => {
                 client._transport.mockReturnValueOnce(Mock.GET_MISSING_SCHEMA_RESPONSE);
                 const schema = await client.application.getSchema("xtk:dummy")
                 expect(schema).toBeNull();
-            })
+            });
+
+            it("Should respect withoutCache parameter", async () => {
+                const client = await Mock.makeClient();
+                client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+                await client.NLWS.xtkSession.logon();
+
+                // First call - should use cache
+                client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+                const schema = await client.application.getSchema("xtk:session");
+                expect(schema.namespace).toBe("xtk");
+                expect(schema.name).toBe("session");
+                expect(client._transport).toHaveBeenCalledTimes(2); // Logon + getSchema
+
+                // Second call - should use cache (no transport call)
+                const schema2 = await client.application.getSchema("xtk:session");
+                expect(schema2.namespace).toBe("xtk");
+                expect(schema2.name).toBe("session");
+                expect(client._transport).toHaveBeenCalledTimes(2); // Still only 2 calls (no new transport call)
+
+                // Third call with withoutCache=true - should bypass cache and make transport call
+                client._transport.mockReturnValueOnce(Mock.GET_XTK_SESSION_SCHEMA_RESPONSE);
+                const schema3 = await client.application.getSchema("xtk:session", true);
+                expect(schema3.namespace).toBe("xtk");
+                expect(schema3.name).toBe("session");
+                expect(client._transport).toHaveBeenCalledTimes(3); // Now 3 calls (bypassed cache)
+
+                client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+                await client.NLWS.xtkSession.logoff();
+            });
         });
 
         describe("application.hasPackage", () => {

package/test/client.test.js

@@ -436,6 +436,42 @@ describe('ACC Client', function () {
             await client.NLWS.xtkSession.logoff();
         });
 
+        it("Should respect withoutCache parameter", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            // First call - should cache the schema
+            client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
+            var schema = await client.getSchema("nms:extAccount");
+            expect(schema["namespace"]).toBe("nms");
+            expect(schema["name"]).toBe("extAccount");
+            expect(client._transport).toHaveBeenCalledTimes(2); // Logon + getSchema
+
+            // Second call - should use cache (no transport call)
+            schema = await client.getSchema("nms:extAccount");
+            expect(schema["namespace"]).toBe("nms");
+            expect(schema["name"]).toBe("extAccount");
+            expect(client._transport).toHaveBeenCalledTimes(2); // Still only 2 calls (no new transport call)
+
+            // Third call with withoutCache=true - should bypass cache and make transport call
+            client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
+            schema = await client.getSchema("nms:extAccount", undefined, undefined, true);
+            expect(schema["namespace"]).toBe("nms");
+            expect(schema["name"]).toBe("extAccount");
+            expect(client._transport).toHaveBeenCalledTimes(3); // Now 3 calls (bypassed cache)
+
+            // Fourth call with withoutCache=true and custom representation - should bypass cache
+            client._transport.mockReturnValueOnce(Mock.GET_NMS_EXTACCOUNT_SCHEMA_RESPONSE);
+            schema = await client.getSchema("nms:extAccount", "xml", undefined, true);
+            expect(schema.getAttribute("namespace")).toBe("nms");
+            expect(schema.getAttribute("name")).toBe("extAccount");
+            expect(client._transport).toHaveBeenCalledTimes(4); // Now 4 calls (bypassed cache again)
+
+            client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
+            await client.NLWS.xtkSession.logoff();
+        });
+
         it("Should return XDM schema definition", async () => {
             const client = await Mock.makeClient();
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
@@ -3410,6 +3446,67 @@ describe('ACC Client', function () {
                 "X-Query-Source": `${sdk.getSDKVersion().name} ${sdk.getSDKVersion().version},Test client app`,
             });
         });
+
+        it("Should add x-request-id header to every SOAP call", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+
+            const mockGetUUID = jest.spyOn(Util, 'getUUID').mockImplementation(() => { return 'test-uuid'; });
+
+            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["x-request-id"]).toBe('test-uuid');
+            
+            // Restore the mock
+            mockGetUUID.mockRestore();
+        });
+
+        it("Should call SOAP call on request ID generation failure", async () => {
+            const client = await Mock.makeClient();
+            client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+            await client.NLWS.xtkSession.logon();
+            
+            const mockGetUUID = jest.spyOn(Util, 'getUUID').mockImplementation(() => { throw new Error('UUID error'); });
+            
+            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" }]
+                }
+            };
+            
+            const query = client.NLWS.xtkQueryDef.create(queryDef);
+
+            const headers = await collectHeaders(client, async() => {
+                await query.executeQuery();
+            });
+
+            expect(headers["x-request-id"]).toBeUndefined();
+            
+            // Restore the mock
+            mockGetUUID.mockRestore();
+        });
     });
 
     describe("Pushdown parameters", () => {
@@ -4318,7 +4415,7 @@ describe('ACC Client', function () {
                     type: "text/html",
                     size: 12345,
                     }, undefined, 'PREFIX');
-                expect(Util.getUUID).toHaveBeenCalledTimes(1);
+                expect(Util.getUUID).toHaveBeenCalledTimes(8);
             });
             }); // "File uploader - on browser"
         }); // 'upload'