@adobe/acc-js-sdk 1.0.3 → 1.0.7

package/src/xtkEntityCache.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
 Copyright 2020 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -10,7 +9,11 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
+(function() {
+"use strict";
+
 const DomUtil = require('./domUtil.js').DomUtil;
+const { Cache } = require('./cache.js');
 
 
 /**********************************************************************************
@@ -19,14 +22,40 @@ const DomUtil = require('./domUtil.js').DomUtil;
  * 
  *********************************************************************************/
 
-function entityKey(entityType, entityFullName) {
-    return entityType + "|" + entityFullName;
-}
- 
-class XtkEntityCache {
+/**
+ * @private
+ * @class
+ * @constructor
+ * @memberof Campaign
+ */
+class XtkEntityCache extends Cache {
     
-    constructor() {
-        this.cache = {}
+    /**
+     * A in-memory cache for xtk entities. Not intended to be used directly,
+     * but an internal cache for the Campaign.Client object.
+     * 
+     * Cached object are made of
+     * - the key is a string in the form <entityType>|<entityName>, such as "xtk:schema|nms:recipient"
+     * - the value is a DOM element corresponding to the entity. It's always a DOM element, regardless of the client representation
+     * 
+     * @param {Storage} storage is an optional Storage object, such as localStorage or sessionStorage
+     * @param {string} rootKey is an optional root key to use for the storage object
+     * @param {number} ttl is the TTL for objects in ms. Defaults to 5 mins
+     */
+     constructor(storage, rootKey, ttl) {
+        super(storage, rootKey, ttl, (entityType, entityFullName) => entityType + "|" + entityFullName, (item, serDeser) => {
+            if (serDeser) {
+                if (!item || !item.value) throw Error(`Cannot serialize falsy cached item`);
+                const value = Object.assign({}, item);
+                value.value = DomUtil.toXMLString(item.value);
+                return JSON.stringify(value);
+            }
+            else {
+                const json = JSON.parse(item);
+                json.value = DomUtil.parse(json.value).documentElement;
+                return json;
+            }
+        });
     }
 
     /**
@@ -36,9 +65,7 @@ class XtkEntityCache {
      * @returns {*} the cached entity, or undefined if not found
      */
     get(entityType, entityFullName) {
-        const key = entityKey(entityType, entityFullName);
-        var entity = this.cache[key]
-        return entity;
+        return super.get(entityType, entityFullName);
     }
 
     /**
@@ -48,31 +75,22 @@ class XtkEntityCache {
      * @param {*} entity is the entity
      */
     put(entityType, entityFullName, entity) {
-        var key = entityKey(entityType, entityFullName);
-        this.cache[key] = entity;
-
+        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")}`;
-                const key = entityKey(entityType, name);
-                this.cache[key] = interfaceElement;
+                super.put(entityType, name, interfaceElement);
                 interfaceElement = DomUtil.getNextSiblingElement(interfaceElement, "interface");
             }
         }
     }
-
-    /**
-     * Clears the cache
-     */
-    clear() {
-        this.cache = {};
-    }
-
 }
 
 
 // Public exports
 exports.XtkEntityCache = XtkEntityCache;
+
+})();

package/test/application.test.js

@@ -290,7 +290,10 @@ describe('Schemas', function() {
                                             <value name="prospect" label="Prospect" value="0" img=""/>
                                             <value name="customer" label="Client"   value="1" img=""/>
                                         </enumeration>
-                                        <element name='recipient' label='Recipients'></element>
+                                        <element name='recipient' label='Recipients'>
+                                        <attribute advanced="true" desc="Recipient sex" enum="nms:recipient:gender"
+                                            label="Gender" name="gender" sqlname="iGender" type="byte"/>
+                                        </element>
                                     </schema>`);
             var schema = newSchema(xml);
             var enumerations = schema.enumerations;
@@ -303,6 +306,7 @@ describe('Schemas', function() {
             // at least one img attribute
             expect(enumerations.status2.name).toBe("status2");
             expect(enumerations.status2.hasImage).toBe(false);
+            expect(schema.root.children["@gender"].enum).toBe("nms:recipient:gender");
         })
 
         it("Should list enumeration values", () => {
@@ -383,6 +387,41 @@ describe('Schemas', function() {
         })
     });
 
+    describe("Link", () => {
+        it("Should have a link element", () => {
+            var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
+                                        <element name='recipient' label='Recipients'>
+                                            <element integrity="neutral" label="Info on the email" name="emailInfo"
+                                                target="nms:address" type="link" unbound="true">
+                                                <join xpath-dst="@address" xpath-src="@email"/>
+                                                <join xpath-dst="@dst" xpath-src="@source"/>
+                                            </element>
+                                        </element>
+                                    </schema>`);
+            var schema = newSchema(xml);
+            var link = schema.root.children["emailInfo"];
+            expect(link.target).toBe("nms:address");
+            expect(link.integrity).toBe("neutral");
+            expect(link.isUnbound()).toBe(true);
+            expect(link.joins.length).toBe(2);
+            expect(link.joins[0].dst).toBe("@address");
+            expect(link.joins[0].src).toBe("@email");
+
+            xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
+                                    <element name='recipient' label='Recipients'>
+                                        <element integrity="neutral" label="Info on the email" name="emailInfo"
+                                            target="nms:address" type="link">
+                                            <join xpath-dst="@address" xpath-src="@email"/>
+                                            <join xpath-dst="@dst" xpath-src="@source"/>
+                                        </element>
+                                    </element>
+                                </schema>`);
+            schema = newSchema(xml);
+            link = schema.root.children["emailInfo"];
+            expect(link.isUnbound()).toBe(false);
+        })
+    })
+
     describe("getnodepath", () => {
         var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
                 <element name='recipient' label='Recipients'>

package/test/caches.test.js

@@ -18,6 +18,7 @@ governing permissions and limitations under the License.
  *********************************************************************************/
 
 const assert = require('assert');
+const { Cache, SafeStorage } = require('../src/cache.js');
 const OptionCache = require('../src/optionCache.js').OptionCache;
 const MethodCache = require('../src/methodCache.js').MethodCache;
 const XtkEntityCache = require('../src/xtkEntityCache.js').XtkEntityCache;
@@ -25,6 +26,36 @@ const { DomUtil } = require('../src/domUtil.js');
 
 describe('Caches', function() {
 
+    describe("Generic cache", () => {
+        it("Should cache with default TTL and default key function", () => {
+            const cache = new Cache();
+            cache.put("Hello", "World");
+            expect(cache.get("Hello")).toBe("World");
+        })
+
+        it("Should expires after TTL", () => {
+            const cache = new Cache(undefined, undefined, -1);    // negative TTL => will immediately expire
+            cache.put("Hello", "World");
+            expect(cache.get("Hello")).toBeUndefined();
+        })
+
+        it("Should support custom key function", () => {
+            const cache = new Cache(undefined, undefined, 300000, ((a, b) => a + "||" + b));
+            cache.put("key-part-1", "key-part-2", "value");
+            expect(cache.get("key-part-1")).toBeUndefined();
+            expect(cache.get("key-part-2")).toBeUndefined();
+            expect(cache.get("key-part-1", "key-part-2")).toBe("value");
+        })
+
+        it("Should clear cache", () => {
+            const cache = new Cache();
+            cache.put("Hello", "World");
+            expect(cache.get("Hello")).toBe("World");
+            cache.clear();
+            expect(cache.get("Hello")).toBeUndefined();
+        })
+    })
+
     describe("Entity cache", function() {
         it("Should cache value", function() {
             const cache = new XtkEntityCache();
@@ -55,15 +86,15 @@ describe('Caches', function() {
         it("Should cache value", function() {
             const cache = new OptionCache();
             expect(cache.get("hello")).toBeUndefined();
-            cache.cache("hello", ["world", 6]);
+            cache.put("hello", ["world", 6]);
             expect(cache.get("hello")).toBe("world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
         });
 
         it("Should cache multiple value", function() {
             const cache = new OptionCache();
-            cache.cache("hello", ["world", 6]);
-            cache.cache("foo", ["bar", 6]);
+            cache.put("hello", ["world", 6]);
+            cache.put("foo", ["bar", 6]);
             expect(cache.get("hello")).toBe("world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
             expect(cache.get("foo")).toBe("bar");
@@ -72,17 +103,17 @@ describe('Caches', function() {
 
         it("Should overwrite cached value", function() {
             const cache = new OptionCache();
-            cache.cache("hello", ["world", 6]);
+            cache.put("hello", ["world", 6]);
             expect(cache.get("hello")).toBe( "world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
-            cache.cache("hello", ["cruel world", 6]);
+            cache.put("hello", ["cruel world", 6]);
             expect(cache.get("hello")).toBe("cruel world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "cruel world", "type": 6, "value": "cruel world"});
         });
 
         it("Should clear cache", function() {
             const cache = new OptionCache();
-            cache.cache("hello", ["world", 6]);
+            cache.put("hello", ["world", 6]);
             expect(cache.get("hello")).toBe("world");
             expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
             cache.clear();
@@ -96,13 +127,19 @@ describe('Caches', function() {
             expect(cache.getOption("hello")).toBeUndefined();
         });
 
+        it("Deprecated cache methods should now replaced with put", () => {
+            const cache = new OptionCache();
+            cache.cache("hello", ["world", 6]);
+            expect(cache.get("hello")).toBe("world");
+            expect(cache.getOption("hello")).toEqual({"rawValue": "world", "type": 6, "value": "world"});
+        });
     });
 
     describe("Method cache", function() {
         it("Should cache methods", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             var found = cache.get("nms:recipient", "Delete");
             assert.ok(found !== null && found !== undefined);
@@ -118,7 +155,7 @@ describe('Caches', function() {
         it("Should cache interface methods", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient' implements='nms:i'><interface name='i'><method name='Update'/></interface><element name='recipient'/><methods><method name='Delete'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
             // interface method should be on schema
             var found = cache.get("nms:recipient", "Update");
             assert.ok(found !== null && found !== undefined);
@@ -127,10 +164,10 @@ describe('Caches', function() {
             assert.ok(found !== null && found !== undefined);
         });
 
-        it("Should cler the cache", function() {
+        it("Should clear the cache", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             var found = cache.get("nms:recipient", "Delete");
             assert.ok(found !== null && found !== undefined);
@@ -143,7 +180,7 @@ describe('Caches', function() {
         it("Should ignore non-method nodes", function() {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><dummy name='Update'/><method name='Create'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             var found = cache.get("nms:recipient", "Delete");
             assert.ok(found !== null && found !== undefined);
@@ -152,6 +189,33 @@ describe('Caches', function() {
             found = cache.get("nms:recipient", "Create");
             assert.ok(found !== null && found !== undefined);
         });
+
+        it("Deprecated cache methods should now replaced with put", () => {
+            const cache = new MethodCache();
+            var schema = DomUtil.parse("<schema namespace='nms' name='recipient'><methods><method name='Delete'/><method name='Create'/></methods></schema>");
+            cache.cache(schema.documentElement);
+
+            var found = cache.get("nms:recipient", "Delete");
+            assert.ok(found !== null && found !== undefined);
+            assert.equal(found.nodeName, "method");
+            assert.equal(found.getAttribute("name"), "Delete");
+
+            found = cache.get("nms:recipient", "Create");
+            assert.ok(found !== null && found !== undefined);
+            assert.equal(found.nodeName, "method");
+            assert.equal(found.getAttribute("name"), "Create");
+        })
+   
+        it("Deserialized method should be a DOM element", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            const cached = {value: { x:3, method:DomUtil.parse("<hello/>")} };
+            const serialized = serDeser(cached, true); 
+            const deserialized = serDeser(serialized, false);
+            const method = deserialized.value.method;
+            // should be a DOM element, not a DOM document
+            expect(method.nodeType).toBe(1);
+        })
     });
 
     describe("Method cache for interfaces", function() {
@@ -160,7 +224,7 @@ describe('Caches', function() {
             // Test for fix in verion 0.1.23. The xtk:session schema has a direct method "Logon" but also implements the
             // xtk:persist interface.
             var schema = DomUtil.parse("<schema namespace='xtk' name='session' implements='xtk:persist'><interface name='persist'><method name='Write' static='true'/></interface><methods><method name='Logon'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             // Logon method should be found in xtk:session and have the xtk:session URN (for SOAP action)
             var found = cache.get("xtk:session", "Logon");
@@ -196,7 +260,7 @@ describe('Caches', function() {
         it("Edge cases for getSoapUrn", () => {
             const cache = new MethodCache();
             var schema = DomUtil.parse("<schema namespace='xtk' name='session' implements='xtk:persist'><interface name='persist'><method name='Write' static='true'/></interface><methods><method name='Logon'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             // Schema and method exist
             var urn = cache.getSoapUrn("xtk:session", "Logon");
@@ -215,7 +279,7 @@ describe('Caches', function() {
             const cache = new MethodCache();
             // Schema has xtk:persist interface but does not implement it
             var schema = DomUtil.parse("<schema namespace='xtk' name='session'><interface name='persist'><method name='Write' static='true'/></interface><methods><method name='Logon'/></methods></schema>");
-            cache.cache(schema.documentElement);
+            cache.put(schema.documentElement);
 
             // Logon method should be found in xtk:session and have the xtk:session URN (for SOAP action)
             var found = cache.get("xtk:session", "Logon");
@@ -226,4 +290,140 @@ describe('Caches', function() {
             assert.strictEqual(urn, "xtk:session");
         });
     });
+
+    describe("SafeStorage", () => {
+
+        describe("JSON safe storage", () => {
+
+            it("Should find mock json from the cache", () => {
+                const map = {};
+                const delegate = {
+                    getItem: jest.fn((key) => map[key]),
+                    setItem: jest.fn((key, value) => map[key] = value)
+                }
+                const storage = new SafeStorage(delegate, "");
+                expect(storage.getItem("not_found")).toBeUndefined();
+                map["k1"] = `{ "hello": "world" }`;
+                expect(storage.getItem("k1")).toMatchObject({ hello: "world" });
+                map["k2"] = `{ "value": { "hello": "world" } }`;
+                expect(storage.getItem("k2")).toMatchObject({ value: { hello: "world" } });
+            });
+        });
+
+        describe("XML safe storage", () => {
+
+            const xmlSerDeser = (item, serDeser) => {
+                if (serDeser) {
+                    const xml = DomUtil.toXMLString(item.value);
+                    const value = {...item, value: xml };
+                    return JSON.stringify(value);
+                }
+                else {
+                    const json = JSON.parse(item);
+                    const dom = DomUtil.parse(json.value);
+                    return {...json, value:dom.documentElement};
+                }
+            };
+
+            it("Should find mock xml from the cache", () => {
+                const map = {};
+                const delegate = {
+                    getItem: jest.fn((key) => map[key]),
+                    setItem: jest.fn((key, value) => map[key] = value)
+                }
+                const storage = new SafeStorage(delegate, "", xmlSerDeser);
+                expect(storage.getItem("not_found")).toBeUndefined();
+                map["k1"] = `{ "hello": "world" }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute containing serialized XML
+                map["k1"] = `{ "hello": "world", "value": "" }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute containing serialized XML
+                map["k1"] = `{ "value": { "hello": "world" } }`;
+                expect(storage.getItem("k2")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k1"] = `{ "value": "" } }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k1"] = `{ "value": "bad" } }`;
+                expect(storage.getItem("k1")).toBeUndefined();      // k1 cached object does not have "value" attribute but it's not valid XML
+                map["k2"] = `{ "value": "<hello/>" }`;
+                expect(storage.getItem("k2").value.tagName).toBe("hello");
+            });
+        });
+    });
+
+    describe("Cache seralizers", () => {
+        it("Should serialize json", () => {
+            const cache = new OptionCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({ hello: "World" }, true)).toBe('{"hello":"World"}');
+            expect(serDeser({ }, true)).toBe('{}');
+            expect(() => {serDeser(null, true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser(undefined, true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser("", true)}).toThrow("Cannot serialize");
+            expect(() => {serDeser("Hello", true)}).toThrow("Cannot serialize");
+        })
+
+        it("Should deserialize json", () => {
+            const cache = new OptionCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser('{"hello":"World"}', false)).toMatchObject({ hello: "World" });
+            expect(serDeser('{}', false)).toMatchObject({ });
+            expect(() => {serDeser(null, false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser(undefined, false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser("", false)}).toThrow("Cannot deserialize");
+            expect(() => {serDeser("Hello", false)}).toThrow("Unexpected token");
+        })
+
+        it("Should serialize XML entity", () => {
+            const cache = new XtkEntityCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({value: DomUtil.parse("<hello/>")}, true)).toBe('{"value":"<hello/>"}')
+            expect(() => { serDeser({}, true); }).toThrow();
+            expect(() => { serDeser(null, true); }).toThrow();
+            expect(() => { serDeser(undefined, true); }).toThrow();
+            expect(() => { serDeser("", true); }).toThrow();
+            expect(() => { serDeser("Hello", true); }).toThrow();
+        })
+
+        it("Should deserialize XML entity", () => {
+            const cache = new XtkEntityCache();
+            const serDeser = cache._storage._serDeser;
+            expect(DomUtil.toXMLString(serDeser(`{"value":"<hello/>"}`, false).value)).toBe("<hello/>");
+            expect(() => {serDeser(null, false)}).toThrow();
+            expect(() => {serDeser(undefined, false)}).toThrow();
+            expect(() => {serDeser("", false)}).toThrow();
+            expect(() => {serDeser("Hello", false)}).toThrow();
+        })
+
+        it("Should serialize methods", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            expect(serDeser({value: { x:3, method:DomUtil.parse("<hello/>")} }, true)).toBe('{"value":{"x":3,"method":"<hello/>"}}')
+            expect(() => { serDeser({value: { x:3 }}, true); }).toThrow();
+            expect(() => { serDeser({}, true); }).toThrow();
+            expect(() => { serDeser(null, true); }).toThrow();
+            expect(() => { serDeser(undefined, true); }).toThrow();
+            expect(() => { serDeser("", true); }).toThrow();
+            expect(() => { serDeser("Hello", true); }).toThrow();
+        })
+
+        it("Should deserialize methods", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            expect(DomUtil.toXMLString(serDeser('{"value":{"x":3,"method":"<hello/>"}}', false).value.method)).toBe("<hello/>");
+            expect(() => { serDeser('{"value":{"x":3}}', false); }).toThrow();
+            expect(() => { serDeser({}, false); }).toThrow();
+            expect(() => { serDeser(null, false); }).toThrow();
+            expect(() => { serDeser(undefined, false); }).toThrow();
+            expect(() => { serDeser("", false); }).toThrow();
+            expect(() => { serDeser("Hello", false); }).toThrow();
+        })
+
+        it("Method serialization should not change initial object", () => {
+            const cache = new MethodCache();
+            const serDeser = cache._storage._serDeser;
+            const cached = {value: { x:3, method:DomUtil.parse("<hello/>")} };
+            serDeser(cached, true); // make sure this call does not change the input parameter "cached"
+            expect(cached.value.x).toBe(3);
+            expect(cached.value.method.documentElement.tagName).toBe("hello");
+        })
+    })
 });