@adobe/acc-js-sdk 1.1.58 → 1.1.60

package/docs/changeLog.html

@@ -3,8 +3,22 @@ layout: page
 title: Change Log
 ---
 
+<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>
+    In previous commit, computing the UUID was not working in a browser context
+  </li>
+</section>
+
 <section class="changelog"><h1>Version 1.1.58</h1>
-  <h2>2025/06/24</h2>
+  <h2>2025/08/20</h2>
   <li>
     Bumped dependencies version to fix vulnerabilities
   </li>

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.58",
+  "version": "1.1.60",
   "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

@@ -38,7 +38,7 @@ const EntityAccessor = require('./entityAccessor.js').EntityAccessor;
 const { Util } = require('./util.js');
 const { XtkJobInterface } = require('./xtkJob.js');
 const qsStringify = require('qs-stringify');
-const crypto = require('crypto');
+
 /**
  * @namespace Campaign
  *
@@ -636,9 +636,16 @@ const fileUploader = (client) => {
                                     // If a prefix is provided, we use it with a UUID (i.e. 'customPrefix-123e4567-e89b-12d3-a456-426614174000')
                                     const oldBehaviorPrefix = 'RES';
                                     const prefix = Util.validateFileResPrefix(fileResPrefix, oldBehaviorPrefix);
-
+                                    const getUUIDOrFallback = async() => {
+                                        try {
+                                            return Util.getUUID();
+                                        } catch (error) {
+                                            // In case getUUID throws, fall back to increasing the counter
+                                            return await client.NLWS.xtkCounter.increaseValue({ name: 'xtkResource' });
+                                        }
+                                    };
                                     const suffix = (prefix === oldBehaviorPrefix) ? 
-                                      await client.NLWS.xtkCounter.increaseValue({ name: 'xtkResource' }) : crypto.randomUUID();
+                                      await client.NLWS.xtkCounter.increaseValue({ name: 'xtkResource' }) : await getUUIDOrFallback();
 
                                     const internalName = (prefix === oldBehaviorPrefix) ? `${prefix}${suffix}` : `${prefix}_${suffix}`;
 
@@ -1936,9 +1943,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:") ) {
@@ -1948,7 +1956,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/src/util.js

@@ -143,7 +143,7 @@ class Util {
     return schemaId;
   }
 
-  static validateFileResPrefix(prefix, defaultPrefix = "RES") {
+  static validateFileResPrefix(prefix, defaultPrefix = 'RES') {
     const regex = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
     if (typeof prefix !== "string" || !regex.test(prefix)) {
@@ -153,6 +153,23 @@ class Util {
     return prefix;
   }
 
+  static getUUID() {
+    if (globalThis.crypto &&
+      globalThis.crypto.randomUUID &&
+      typeof globalThis.crypto.randomUUID === 'function') {
+      return globalThis.crypto.randomUUID(); // browser
+    }
+    const nodeCrypto = (() => {
+      return require("crypto");
+    })();
+    if (nodeCrypto && nodeCrypto.randomUUID) {
+      return nodeCrypto.randomUUID(); // Node
+    }
+
+    //Nothing worked
+    throw new Error('Unable to generate UUID');
+  }
+
   /**
    * Test if an object is a promise
    * @param {*} object the object to test

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);
@@ -3604,7 +3640,7 @@ describe('ACC Client', function () {
                 statusCode: 500,
                 });
             });
-            });
+            }); // "File uploader - on server"
 
             describe("File uploader - on browser", () => {
             beforeEach(() => {
@@ -4218,8 +4254,6 @@ describe('ACC Client', function () {
                 statusCode: 400,
                 });
             });
-            });
-
             it("Test uploads by specifying a file prefix", async () => {
                 // Create a mock client and logon
                 const client = await Mock.makeClient();
@@ -4261,13 +4295,69 @@ describe('ACC Client', function () {
                 ); // xtk:fileRes#GetURL
 
                 // Call upload
-                const result = await client.fileUploader.upload({
-                type: "text/html",
-                size: 12345,
-                }, undefined, 'PREFIX');
+                await client.fileUploader.upload({
+                    type: "text/html",
+                    size: 12345,
+                    }, undefined, 'PREFIX');
                 expect(Util.validateFileResPrefix).toHaveBeenLastCalledWith('PREFIX', 'RES');
             });
-        });
+
+            it("Test uploads by with a file prefix but getUUID throws", async () => {
+                // Create a mock client and logon
+                const client = await Mock.makeClient();
+                client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
+                await client.NLWS.xtkSession.logon();
+
+                // Mock the upload protocol
+                // - the upload.jsp (which returns the content of an iframe and JS to eval)
+                // - call to xtk:session#Write
+                // - call to xtk:fileRes#PublishIfNeeded
+                // - call to xtk:fileRes#GetURL
+
+                client._transport.mockReturnValueOnce(
+                Promise.resolve(`Ok 
+                <html xmlns="http://www.w3.org/1999/xhtml">
+                    <head>
+                    <script type="text/javascript">if(window.parent&&window.parent.document.controller&&"function"==typeof window.parent.document.controller.uploadFileCallBack){var aFilesInfo=new Array;aFilesInfo.push({paramName:"file",fileName:"test.txt",newFileName:"d8e8fca2dc0f896fd7cb4cb0031ba249.txt",md5:"d8e8fca2dc0f896fd7cb4cb0031ba249"}),window.parent.document.controller.uploadFileCallBack(aFilesInfo)}</script>
+                    </head>
+                <body></body>
+                </html>`)
+                ); // upload.jsp
+
+                client._transport.mockReturnValueOnce(
+                    Promise.resolve(Mock.GET_XTK_COUNTER_RESPONSE)
+                ); // GetEntityIfMoreRecentResponse - counter
+                client._transport.mockReturnValueOnce(
+                    Mock.INCREASE_VALUE_RESPONSE
+                ); // xtk:counter#IncreaseValue
+
+                client._transport.mockReturnValueOnce(
+                Mock.GET_XTK_SESSION_SCHEMA_RESPONSE
+                ); // GetEntityIfMoreRecentResponse - session
+                
+                client._transport.mockReturnValueOnce(Mock.FILE_RES_WRITE_RESPONSE); // xtk:session#Write
+                jest.spyOn(Util, 'getUUID').mockImplementation(() => { throw new Error('UUID error'); });
+
+                client._transport.mockReturnValueOnce(
+                Promise.resolve(Mock.GET_FILERES_QUERY_SCHEMA_RESPONSE)
+                ); // GetEntityIfMoreRecentResponse - fileRes
+                client._transport.mockReturnValueOnce(
+                Promise.resolve(Mock.PUBLISH_IF_NEEDED_RESPONSE)
+                ); // xtk:fileRes#PublishIfNeeded
+
+                client._transport.mockReturnValueOnce(
+                Promise.resolve(Mock.GET_URL_RESPONSE)
+                ); // xtk:fileRes#GetURL
+
+                // Call upload
+                await client.fileUploader.upload({
+                    type: "text/html",
+                    size: 12345,
+                    }, undefined, 'PREFIX');
+                expect(Util.getUUID).toHaveBeenCalledTimes(1);
+            });
+            }); // "File uploader - on browser"
+        }); // 'upload'
 
         describe('uploadAemAsset', () => {
           // write unit test for client.fileUploader.uploadAemAsset method

package/test/util.test.js

@@ -458,5 +458,104 @@ describe('Util', function() {
             expect(Util.validateFileResPrefix("132Invalid", "customDefault")).toBe("customDefault");
         });
     });
+
+    describe("GetUUID", () => {
+        describe("UUID - on server node", () => {
+            describe("node <= 16", () => {
+                describe('code coverage: getUUID', () => {
+                    let originalCrypto;
+                    // on old Node versions, crypto may not be available
+                    // deleting globalThis.crypto to simulate the environment on newer Node
+                    beforeEach(() => {
+                        // Save the original crypto
+                        originalCrypto = globalThis.crypto;
+                        delete globalThis.crypto;
+                    });
+
+                    afterEach(() => {
+                        // Restore it after the test
+                        globalThis.crypto = originalCrypto;
+                    });
+
+                    it('should handle require("crypto") throwing', () => {
+                        // Force require("crypto") to throw
+                        jest.mock('crypto', () => {
+                            throw new Error('mock require failure');
+                        });
+
+                        // Re-require the module AFTER mocking
+                        const UUIDHelper = require('../src/util.js').Util;
+
+                        let exceptionCaught = false;
+                        try{
+                            UUIDHelper.getUUID();
+                        } catch (e) {
+                            exceptionCaught = true;
+                        }
+                        expect(exceptionCaught).toBe(true);
+                    });
+
+                    it('should handle require("crypto") throwing', () => {
+                        // Force require("crypto") to not have randomUUID
+                        jest.mock('crypto', () => ({}));
+
+                        // Re-require the module AFTER mocking
+                        const UUIDHelper = require('../src/util.js').Util;
+
+                        let exceptionCaught = false;
+                        try{
+                            UUIDHelper.getUUID();
+                        } catch (e) {
+                            exceptionCaught = e.message === 'Unable to generate UUID';
+                        }
+                        expect(exceptionCaught).toBe(true);
+                    });
+
+                    it('should fallback to node crypto when globalThis.crypto is not available', () => {
+                        jest.unmock('crypto');
+                        // Spy on require
+                        const spy = jest.spyOn(require('crypto'), 'randomUUID').mockReturnValue('mock-uuid');
+
+                        // Re-import the module if your getUUID function is from a module
+                        const uuid = Util.getUUID(); // or just call getUUID() if it's in scope
+
+                        expect(uuid).toBe('mock-uuid');
+                        expect(spy).toHaveBeenCalled();
+                        spy.mockRestore();
+                    });
+                });
+            });
+        });
+        describe("node > 16", () => {
+            it('should return a correct UUID v4', () => {
+                // x is [0-9a-f], Y is 8, 9, a or b
+                // uuid format: xxxxxxxx-xxxx-4xxx-Yxxx-xxxxxxxxxxxx
+                const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+                expect(uuidV4Regex.test(Util.getUUID())).toBe(true);
+            });
+        });
+
+        describe("UUID - on browser", () => {
+            // code coverage test as we mock the browser return values
+            it('should return a correct UUID v4', () => {
+                if (!globalThis.crypto || !globalThis.crypto.randomUUID){
+                    globalThis.crypto = {
+                        ...globalThis.crypto,
+                        randomUUID: jest.fn(),
+                    };
+                }
+
+                // x is [0-9a-f], Y is 8, 9, a or b
+                // uuid v4 format: xxxxxxxx-xxxx-4xxx-Yxxx-xxxxxxxxxxxx
+                // Mocking crypto.randomUUID to return a specific valid v4 UUID
+                jest.spyOn(globalThis.crypto, 'randomUUID').mockReturnValue('123e4567-e89b-42d3-a456-426614174000');
+                const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+                expect(uuidV4Regex.test(Util.getUUID())).toBe(true);
+                // Mocking crypto.randomUUID to return a specific an invalid v4 UUID
+                jest.spyOn(globalThis.crypto, 'randomUUID').mockReturnValue('12345678-1234-0234-0567-426614174000');
+                expect(uuidV4Regex.test(Util.getUUID())).toBe(false);
+            });
+        });
+    });
 });