@adobe/acc-js-sdk 1.1.19 → 1.1.21

package/src/methodCache.js

@@ -75,8 +75,8 @@ class MethodCache extends Cache {
      * @deprecated
      * @param {Element} schema DOM document node represening the schema 
      */
-    cache(schema) {
-        return this.put(schema);
+    async cache(schema) {
+        return await this.put(schema);
     }
     
     /**
@@ -84,7 +84,7 @@ class MethodCache extends Cache {
      * 
      * @param {Element} schema DOM document node represening the schema 
      */
-    put(schema) {
+    async put(schema) {
         var namespace = DomUtil.getAttributeAsString(schema, "namespace");
         var name = DomUtil.getAttributeAsString(schema, "name");
         var impls = DomUtil.getAttributeAsString(schema, "implements");
@@ -103,7 +103,7 @@ class MethodCache extends Cache {
                 while (child) {
                     const methodName = DomUtil.getAttributeAsString(child, "name");
                     const cached = { method: child, urn: schemaId };
-                    super.put(schemaId, methodName, cached);
+                    await super.put(schemaId, methodName, cached);
                     child = DomUtil.getNextSiblingElement(child, "method");
                 }
             }
@@ -124,7 +124,7 @@ class MethodCache extends Cache {
                     let cached = this._cache[key].value;
                     cached = { method: cached.method, urn: urn };
                     const methodName = DomUtil.getAttributeAsString(cached.method, "name");
-                    super.put(schemaId, methodName, cached);
+                    await super.put(schemaId, methodName, cached);
                 }
             }
         }
@@ -137,8 +137,8 @@ class MethodCache extends Cache {
      * @param {string} methodName the method name
      * @returns {Campaign.SoapMethodDefinition} the method definition, or undefined if the schema or the method is not found
      */
-    get(schemaId, methodName) {
-        const cached = super.get(schemaId, methodName);
+    async get(schemaId, methodName) {
+        const cached = await super.get(schemaId, methodName);
         return cached ? cached.method : undefined;
     }
 
@@ -149,8 +149,8 @@ class MethodCache extends Cache {
      * @param {string} methodName the method name
      * @returns {string} the URN (or Soap action header), or undefined if the schema or the method is not found
      */
-    getSoapUrn(schemaId, methodName) {
-        const cached = super.get(schemaId, methodName);
+    async getSoapUrn(schemaId, methodName) {
+        const cached = await super.get(schemaId, methodName);
         return cached ? cached.urn : undefined;
     }
 }

package/src/optionCache.js

@@ -65,7 +65,7 @@ class OptionCache extends Cache {
      * @param {Array} rawValueAndtype a 2 elements array, whose first element is the raw option value (text serialized) and the second element 
      * is the data type of the option. Such an array is returned by the xtk:session#GetOption method
      */
-     cache(schemaId, methodName) {
+    async cache(schemaId, methodName) {
         return this.put(schemaId, methodName);
     }
 
@@ -76,7 +76,7 @@ class OptionCache extends Cache {
      * @param {Array} rawValueAndtype a 2 elements array, whose first element is the raw option value (text serialized) and the second element 
      * is the data type of the option. Such an array is returned by the xtk:session#GetOption method
      */
-    put(name, rawValueAndtype) {
+    async put(name, rawValueAndtype) {
         var value = null;
         var type = 0;
         var rawValue;
@@ -85,7 +85,7 @@ class OptionCache extends Cache {
             type = rawValueAndtype[1];
             value = XtkCaster.as(rawValue, type);
         }
-        super.put(name, { value:value, type:type, rawValue:rawValue });
+        await super.put(name, { value:value, type:type, rawValue:rawValue });
         return value;
     }
 
@@ -95,8 +95,8 @@ class OptionCache extends Cache {
      * @param {string} name the option name
      * @returns {*} the option value
      */
-    get(name) {
-        const option = super.get(name);
+    async get(name) {
+        const option = await super.get(name);
         return option ? option.value : undefined;
     }
 
@@ -106,8 +106,8 @@ class OptionCache extends Cache {
      * @param {string} name the option name
      * @returns {Campaign.XtkOption} the option
      */
-    getOption(name) {
-        return super.get(name);
+    async getOption(name) {
+        return await super.get(name);
     }
 }
 

package/src/util.js

@@ -153,6 +153,23 @@ class Util {
     }
     return schemaId;
   }
+
+  /**
+   * Test if an object is a promise
+   * @param {*} object the object to test
+   * @returns {boolean} if the object is a promise
+   */
+  static isPromise(object) {
+    if (object === null || object === undefined) return false;
+    if (object.then && (typeof object.then === "function")) return true;
+    return false;
+  }
+
+  static asPromise(object) {
+    if (this.isPromise(object)) 
+      return object;
+    return Promise.resolve(object);
+  }
 }
 
 /**

package/src/xtkEntityCache.js

@@ -64,8 +64,8 @@ class XtkEntityCache extends Cache {
      * @param {string} entityFullName is the entity name, such as "nms:recipient"
      * @returns {*} the cached entity, or undefined if not found
      */
-    get(entityType, entityFullName) {
-        return super.get(entityType, entityFullName);
+    async get(entityType, entityFullName) {
+        return await super.get(entityType, entityFullName);
     }
 
     /**
@@ -74,15 +74,15 @@ class XtkEntityCache extends Cache {
      * @param {string} entityFullName is the entity name, such as "nms:recipient"
      * @param {*} entity is the entity
      */
-    put(entityType, entityFullName, entity) {
-        super.put(entityType, entityFullName, entity);
+    async put(entityType, entityFullName, entity) {
+        await super.put(entityType, entityFullName, entity);
         // For schemas, cache interfaces
         if (entityType == "xtk:schema") {
             const namespace = entity.getAttribute("namespace");
             var interfaceElement = DomUtil.getFirstChildElement(entity, "interface");
             while (interfaceElement) {
                 const name = `${namespace}:${interfaceElement.getAttribute("name")}`;
-                super.put(entityType, name, interfaceElement);
+                await super.put(entityType, name, interfaceElement);
                 interfaceElement = DomUtil.getNextSiblingElement(interfaceElement, "interface");
             }
         }

package/test/application.test.js

@@ -141,6 +141,25 @@ describe('Application', () => {
             });
         });
 
+        describe('dbEnum', () => {
+            it("Should find dbEnum attribute", () => {
+                var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
+                                            <element name='recipient' label='Recipients'>
+                                                <attribute dbEnum="operationNature" desc="Nature of the campaign" label="Nature"
+               length="64" name="nature" type="string"/>
+                                            </element>
+                                        </schema>`);
+                var schema = newSchema(xml);
+                var root = schema.root;
+                expect(!!root.children.get("@nature")).toBe(true);
+                var attribute = root.children["@nature"];
+                expect(attribute).not.toBeNull();
+                expect(attribute.dbEnum).toBe("operationNature");
+                expect(attribute.type).toBe("string");
+                expect(attribute.length).toBe(64);
+            });
+        });
+
         describe("Children", () => {
             it("Should browse root children", () => {
                 var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>

package/test/cacheRefresher.test.js

@@ -36,13 +36,13 @@ describe("CacheRefresher cache", function () {
 
         client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE);
         await cacheRefresher._callAndRefresh();
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
-        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBe("9469");
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBe("2022-07-28T14:38:55.766Z");
 
         client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE);
         await cacheRefresher._callAndRefresh();
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
-        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBe("9469");
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBe("2022-07-28T14:38:55.766Z");
 
         client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
         await client.NLWS.xtkSession.logoff();
@@ -61,8 +61,8 @@ describe("CacheRefresher cache", function () {
 
         const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
 
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBeUndefined();
-        expect(cacheRefresher._refresherStateCache.get("time")).toBeUndefined();
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBeUndefined();
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBeUndefined();
         client._transport.mockReturnValue(Promise.resolve(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE));
         jest.useFakeTimers();
         cacheRefresher.startAutoRefresh(5000);
@@ -72,8 +72,8 @@ describe("CacheRefresher cache", function () {
         // to allow soap call to finish
         await new Promise(process.nextTick);
 
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
-        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBe("9469");
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBe("2022-07-28T14:38:55.766Z");
 
         cacheRefresher.stopAutoRefresh();
         client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
@@ -91,13 +91,13 @@ describe("CacheRefresher cache", function () {
             const cache = new Cache();
 
             const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
-            cacheRefresher._refresherStateCache.put("buildNumber", "9469");
-            cacheRefresher._refresherStateCache.put("time", "2022-07-28T14:38:55.766Z");
+            await cacheRefresher._refresherStateCache.put("buildNumber", "9469");
+            await cacheRefresher._refresherStateCache.put("time", "2022-07-28T14:38:55.766Z");
 
             client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_CLEAR_RESPONSE);
             await cacheRefresher._callAndRefresh();
-            expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
-            expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+            await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBe("9469");
+            await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBe("2022-07-28T14:38:55.766Z");
 
             client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
 
@@ -122,20 +122,20 @@ describe("CacheRefresher cache", function () {
         const cache = new Cache();
         const cacheRefresher = new CacheRefresher(cache, client, "xtk:schema", "rootkey");
 
-        cache.put("xtk:schema|nms:recipient", "<content recipient>");
-        cache.put("xtk:schema|nms:replicationStrategy", "<content xtk:schema|nms:replicationStrategy>");
-        cache.put("xtk:schema|nms:operation", "<content xtk:schema|nms:operation>");
-        expect(cache.get("xtk:schema|nms:recipient")).toBe("<content recipient>");
-        expect(cache.get("xtk:schema|nms:replicationStrategy")).toBe("<content xtk:schema|nms:replicationStrategy>");
-        expect(cache.get("xtk:schema|nms:operation")).toBe("<content xtk:schema|nms:operation>");
+        await cache.put("xtk:schema|nms:recipient", "<content recipient>");
+        await cache.put("xtk:schema|nms:replicationStrategy", "<content xtk:schema|nms:replicationStrategy>");
+        await cache.put("xtk:schema|nms:operation", "<content xtk:schema|nms:operation>");
+        await expect(cache.get("xtk:schema|nms:recipient")).resolves.toBe("<content recipient>");
+        await expect(cache.get("xtk:schema|nms:replicationStrategy")).resolves.toBe("<content xtk:schema|nms:replicationStrategy>");
+        await expect(cache.get("xtk:schema|nms:operation")).resolves.toBe("<content xtk:schema|nms:operation>");
 
         client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_SCHEMA_RESPONSE);
         await cacheRefresher._callAndRefresh();
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
-        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T15:32:00.785Z");
-        expect(cache.get("xtk:schema|nms:recipient")).toBeUndefined();
-        expect(cache.get("xtk:schema|nms:replicationStrategy")).toBeUndefined();
-        expect(cache.get("xtk:schema|nms:operation")).toBe("<content xtk:schema|nms:operation>");
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBe("9469");
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBe("2022-07-28T15:32:00.785Z");
+        await expect(cache.get("xtk:schema|nms:recipient")).resolves.toBeUndefined();
+        await expect(cache.get("xtk:schema|nms:replicationStrategy")).resolves.toBeUndefined();
+        await expect(cache.get("xtk:schema|nms:operation")).resolves.toBe("<content xtk:schema|nms:operation>");
 
         client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
         await client.NLWS.xtkSession.logoff();
@@ -153,8 +153,8 @@ describe("CacheRefresher cache", function () {
 
         client._transport.mockReturnValueOnce(Mock.GETMODIFIEDENTITIES_UNDEFINED_RESPONSE);
         await cacheRefresher._callAndRefresh();
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBeUndefined();
-        expect(cacheRefresher._refresherStateCache.get("time")).toBeUndefined();
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBeUndefined();
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBeUndefined();
         expect(cacheRefresher._intervalId).toBeNull();
 
         client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);
@@ -178,8 +178,8 @@ describe("CacheRefresher cache", function () {
         } catch (e) {
             expect(e).not.toBeNull();
         }
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBeUndefined();
-        expect(cacheRefresher._refresherStateCache.get("time")).toBeUndefined();
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBeUndefined();
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBeUndefined();
         expect(cacheRefresher._intervalId).not.toBeNull();
 
         cacheRefresher.stopAutoRefresh();
@@ -211,8 +211,8 @@ describe("CacheRefresher cache", function () {
         // to allow soap call to finish
         await new Promise(process.nextTick);
 
-        expect(cacheRefresher._refresherStateCache.get("buildNumber")).toBe("9469");
-        expect(cacheRefresher._refresherStateCache.get("time")).toBe("2022-07-28T14:38:55.766Z");
+        await expect(cacheRefresher._refresherStateCache.get("buildNumber")).resolves.toBe("9469");
+        await expect(cacheRefresher._refresherStateCache.get("time")).resolves.toBe("2022-07-28T14:38:55.766Z");
 
         cacheRefresher.stopAutoRefresh();
         client._transport.mockReturnValueOnce(Mock.LOGOFF_RESPONSE);