@adobe/acc-js-sdk 1.1.58 → 1.1.59

package/docs/changeLog.html

@@ -3,8 +3,15 @@ layout: page
 title: Change Log
 ---
 
+<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.59",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@adobe/acc-js-sdk",
-      "version": "1.1.58",
+      "version": "1.1.59",
       "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.59",
   "description": "ACC Javascript SDK",
   "main": "src/index.js",
   "homepage": "https://github.com/adobe/acc-js-sdk#readme",

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}`;
 

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/client.test.js

@@ -3604,7 +3604,7 @@ describe('ACC Client', function () {
                 statusCode: 500,
                 });
             });
-            });
+            }); // "File uploader - on server"
 
             describe("File uploader - on browser", () => {
             beforeEach(() => {
@@ -4218,8 +4218,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 +4259,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);
+            });
+        });
+    });
 });