@adobe/acc-js-sdk 1.1.59 → 1.1.60

package/docs/changeLog.html

@@ -3,6 +3,13 @@ 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>

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.59",
+  "version": "1.1.60",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@adobe/acc-js-sdk",
-      "version": "1.1.59",
+      "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.59",
+  "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

@@ -1943,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:") ) {
@@ -1955,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/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);