@adobe/acc-js-sdk 1.0.7 → 1.1.0

package/src/application.js

@@ -22,6 +22,9 @@ governing permissions and limitations under the License.
 const { DomException, XPath } = require('./domUtil.js');
 const XtkCaster = require('./xtkCaster.js').XtkCaster;
 const EntityAccessor = require('./entityAccessor.js').EntityAccessor;
+const { ArrayMap } = require('./util.js');
+
+const PACKAGE_STATUS = { "never": 0, "always": 1, "default": 2, "preCreate": 3 };
 
 /**
  * @namespace Campaign
@@ -30,10 +33,6 @@ const EntityAccessor = require('./entityAccessor.js').EntityAccessor;
 // ========================================================================================
 // Helper functions
 // ========================================================================================
- 
-// Determine if a name is an attribute name, i.e. if it starts with the "@" character
-const isAttributeName = function(name) { return name.length > 0 && name[0] == '@'; };
-
 
 /**
   * Creates a schema object from an XML representation
@@ -45,12 +44,42 @@ const isAttributeName = function(name) { return name.length > 0 && name[0] == '@
   * @see {@link XtkSchema}
   * @memberof Campaign
   */
-function newSchema(xml) {
+ function newSchema(xml, application) {
     if (xml.nodeType == 9) xml = xml.documentElement;       // Document -> element
-    var schema = new XtkSchema(xml);
+    var schema = new XtkSchema(application, xml);
     return schema;
 }
 
+// Propagate implicit values
+// Name -> Label -> Desc -> HelpText
+function propagateImplicitValues(xtkDesc, labelOnly) {
+    if (!xtkDesc.label) {
+        if (xtkDesc.isAttribute) xtkDesc.label = xtkDesc.name.substring(1); // without @
+        else xtkDesc.label = xtkDesc.name;
+        // Force first letter as uppercase
+        xtkDesc.label = xtkDesc.label.substring(0, 1).toUpperCase() + xtkDesc.label.substring(1);
+    }
+    if (!labelOnly && !xtkDesc.description) xtkDesc.description = xtkDesc.label;
+}
+
+// ========================================================================================
+// Schema Cache
+// ========================================================================================
+class SchemaCache {
+    constructor(client) {
+        this._client = client;
+        this._schemas = {};
+    }
+    async getSchema(schemaId) {
+        let schema = this._schemas[schemaId];
+        if (schema === undefined) {
+            schema = await this._client.application._getSchema(schemaId);
+            if (!schema) schema = null; // null = not found
+        this._schemas[schemaId] = schema;
+        }
+        return schema;
+    }
+}
 
 // ========================================================================================
 // Keys
@@ -70,22 +99,63 @@ function newSchema(xml) {
 class XtkSchemaKey {
 
     constructor(schema, xml, schemaNode) {
+
+        /**
+         * The schema this key belongs to
+         * @type {Campaign.XtkSchema}
+         */
         this.schema = schema;
+
+        /**
+         * The name of the key
+         * @type {string}
+         */
         this.name = EntityAccessor.getAttributeAsString(xml, "name");
+
+        /**
+         * A human friendly name for they key
+         * @type {string}
+         */
         this.label = EntityAccessor.getAttributeAsString(xml, "label");
+
+         /**
+         * A longer, human friendly description for they key
+         * @type {string}
+         */
         this.description = EntityAccessor.getAttributeAsString(xml, "desc");
-        this.isInternal = EntityAccessor.getAttributeAsString(xml, "internal");
+
+        /**
+         * Indicates if the key is internal or not
+         * @type {boolean}
+         */
+        this.isInternal = EntityAccessor.getAttributeAsBoolean(xml, "internal");
+
+        /**
+         * Indicates if the fields (parts) of a composite key may be empty (null). At least one part must always be populated
+         * @type {boolean}
+         */
         this.allowEmptyPart = EntityAccessor.getAttributeAsString(xml, "allowEmptyPart");
-        this.fields = {};
+
+        /**
+         * The fields making up the key
+         * @type {Utils.ArrayMap<Campaign.XtkSchemaNode>}
+         */
+        this.fields = new ArrayMap();
 
         for (var child of EntityAccessor.getChildElements(xml, "keyfield")) {
-            const xpath = EntityAccessor.getAttributeAsString(child, "xpath");
-            if (xpath == "") throw new DomException(`Cannot create XtkSchemaKey for key '${this.name}': keyfield does not have an xpath attribute`);
-            const field = schemaNode.findNode(xpath);
-            this.fields[field.name] = field;
+            const xpathString = EntityAccessor.getAttributeAsString(child, "xpath");
+            if (xpathString == "") throw new DomException(`Cannot create XtkSchemaKey for key '${this.name}': keyfield does not have an xpath attribute`);
+            
+            // find key field
+            const xpath = new XPath(xpathString);
+            const elements = xpath.getElements();
+            let keyNode = schemaNode;
+            while (keyNode && elements.length > 0)
+                keyNode = keyNode.children[elements.shift()];
+            if (keyNode)
+            this.fields._push(xpathString, keyNode);
         }
     }
-
 }
 
 /**
@@ -100,10 +170,21 @@ class XtkSchemaKey {
  class XtkJoin {
 
     constructor(xml) {
+
+        /**
+         * The xpath of the join condition on the source table
+         * @type {string}
+         */
         this.src = EntityAccessor.getAttributeAsString(xml, "xpath-src");
-        this.dst = EntityAccessor.getAttributeAsString(xml, "xpath-dst");
+
+        /**
+         * The xpath of the join condition on the destination table
+         * @type {string}
+         */
+         this.dst = EntityAccessor.getAttributeAsString(xml, "xpath-dst");
     }
 }
+
 // ========================================================================================
 // Schema nodes
 // ========================================================================================
@@ -137,62 +218,123 @@ class XtkSchemaNode {
          * @type {XtkSchema}
          */
         this.schema = schema;
+
+        /**
+         * Returns a string of characters which provides the data policy of the current node.
+         * @type {string}
+         */
+         this.dataPolicy = EntityAccessor.getAttributeAsString(xml, "dataPolicy");
+
+        /**
+         * Returns a string of characters which specifies the editing type of the current node.
+         * @type {string}
+         */
+         this.editType = EntityAccessor.getAttributeAsString(xml, "editType");
+
+        /**
+         * Only on the root node, returns a string which contains the folder template(s). On the other nodes, it returns undefined.
+         * @type {string}
+         */
+        this.folderModel = EntityAccessor.getAttributeAsString(xml, "folderModel");
+
         /**
          * The parent node
          * @type {XtkSchemaNode}
          */
         this.parent = parentNode;
+
         /**
          * Indicates if the node is an attribute or not (element or schema itself)
          * @type {boolean}
          */
         this.isAttribute = isAttribute;
+
         /**
-         * The attribute or the node name (without the "@" sign for attributes)
+         * The attribute or the node name (with the "@" sign for attributes)
          * @type {string}
          */
         this.name = (this.isAttribute ? "@" : "") + EntityAccessor.getAttributeAsString(xml, "name");
+
         /**
          * A human friendly name for the node. If the node is the schema node, the label will be in the plural form and "labelSingular"
          * should be used for the singular form
          * @type {string}
          */
         this.label = EntityAccessor.getAttributeAsString(xml, "label");
+
         /**
          * A long description of the node
          * @type {string}
          */
         this.description = EntityAccessor.getAttributeAsString(xml, "desc");
+
         /**
          * An optional image for the node
          * @type {string}
          */
         this.img = EntityAccessor.getAttributeAsString(xml, "img");
+
         /**
-         * The node type
+         * An optional image for the node (alias to the img property)
+         * @type {string}
+         */
+         this.image = this.img;
+
+        /**
+         * Returns the name of the image of the current node in the form of a string of characters.
+         * @type {string}
+         */
+         this.enumerationImage = EntityAccessor.getAttributeAsString(xml, "enumImage");
+
+        /**
+         * The node type. Attribute nodes without an explicitedly defined type will be reported as "string"
          * @type {string}
          */
         this.type = EntityAccessor.getAttributeAsString(xml, "type");
+        if (!this.type && isAttribute) this.type = "string";
+
         /**
-         * The node target
+         * For link type nodes, the target of the link
          * @type {string}
          */
-         this.target = EntityAccessor.getAttributeAsString(xml, "target");
+        this.target = EntityAccessor.getAttributeAsString(xml, "target");
+
         /**
          * The node integrity
          * @type {string}
          */
-         this.integrity = EntityAccessor.getAttributeAsString(xml, "integrity");
+        this.integrity = EntityAccessor.getAttributeAsString(xml, "integrity");
+
         /**
          * The node data length (applicable for string-types only)
          * @type {number}
          */
         this.length = EntityAccessor.getAttributeAsLong(xml, "length");
+
+        /**
+         * The node data length (applicable for string-types only)
+         * @type {number}
+         */
+        this.size = this.length;
+
         /**
          * The enum of the node
          * @type {string}
          */
         this.enum = EntityAccessor.getAttributeAsString(xml, "enum");
+
+        /**
+         * Returns a string of characters which is the name of the user enumeration used by the current node.
+         * @type {string}
+         */
+        this.userEnumeration = EntityAccessor.getAttributeAsString(xml, "userEnum");
+
+        /**
+         * Returns a boolean which indicates whether the value of the current node is linked to a user enumeration.
+         * @type {boolean}
+         */
+        this.hasUserEnumeration = !!this.userEnumeration;
+
         /**
          * "ref" attribute of the node, which references another node
          * @type {string}
@@ -204,88 +346,266 @@ class XtkSchemaNode {
          * @type {boolean}
          */
         this.unbound = EntityAccessor.getAttributeAsBoolean(xml, "unbound");
+
+        /**
+         * Has an unlimited number of children of the same type
+         * @type {boolean}
+         */
+        this.isCollection = this.unbound;
+
+        /**
+         * is mapped as a xml
+         * @type {boolean}
+         */
+        this.isMappedAsXML = EntityAccessor.getAttributeAsBoolean(xml, "xml");
+
+        /**
+         * is an advanced node
+         * @type {boolean}
+         */
+        this.isAdvanced = EntityAccessor.getAttributeAsBoolean(xml, "advanced");
+
         /**
          * Children of the node. This is a object whose key are the names of the children nodes (without the "@"
          * character for attributes) 
-         * @type {Object.<string, Campaign.XtkSchemaNode>}
+         * @type {Utils.ArrayMap.<Campaign.XtkSchemaNode>}
          */
-        this.children = {};
+        this.children = new ArrayMap();
+
         /**
          * Count the children of a node
          * @type {number}
          */
         this.childrenCount = 0;
+
         /**
          * Indicates if the node is the root node, i.e. the first child node of the schema, whose name is the same as the schema name
          * @type {boolean}
          */
         this.isRoot = this.parent && !this.parent.parent && this.parent.name == this.name;
-        /**
-         * A user desciption of the node, in the form "label (name)"
-         * @type {string}
-         */
-        this.userDescription = (this.label == "" || this.label == this.name) ? this.name : `${this.label} (${this.name})`;
+
         /**
          * Schema root elements may have a list of keys. This is a dictionary whose names are the key names and values the keys
-         * @type {Object<string, XtkSchemaKey>}
+         * @type {ArrayNode<Campaign.XtkSchemaKey>}
          */
-        this.keys = {};
+        this.keys = new ArrayMap();
+
         /**
          * The full path of the node
          * @type {string}
          */
         this.nodePath = this._getNodePath(true)._path;
+
         /**
          * Element of type "link" has an array of XtkJoin
-         * @type {@type {XtkJoin[]}}
+         * @type {XtkJoin[]}
          */
         this.joins = [];
-
         for (var child of EntityAccessor.getChildElements(xml, "join")) {
             this.joins.push(new XtkJoin(child));
         }
 
-        // Children (elements and attributes)
+        /**
+         * Returns a boolean which indicates whether the current node is ordinary.
+         * @type {boolean}
+         */
+        this.isAnyType = this.type === "ANY";
+
+        /**
+         * Returns a boolean which indicates whether the node is a link.
+         * @type {boolean}
+         */
+        this.isLink = this.type === "link";
+
+        /**
+         * Returns a boolean which indicates whether the value of the current node is linked to an enumeration.
+         * @type {boolean}
+         */
+        this.hasEnumeration = this.enum !== "";
+
+        /**
+         * Returns a boolean which indicates whether the current node is linked to an SQL table.
+         * @type {boolean}
+         */
+        this.hasSQLTable = this.sqlTable !== '';
+
+         /**
+          * The SQL name of the field. The property is an empty string if the object isn't an SQL type field.
+          * @type {string}
+          */
+        this.SQLName = EntityAccessor.getAttributeAsString(xml, "sqlname");
+
+         /**
+          * The SQL name of the table. The property is an empty string if the object isn't the main element or if schema mapping isn't of SQL type.
+          * @type {string}
+          */
+        this.SQLTable = EntityAccessor.getAttributeAsString(xml, "sqltable");
+
+        /**
+         * Returns a boolean indicating whether the table is a temporary table. The table will not be created during database creation.
+         * @type {boolean}
+         */
+        this.isTemporaryTable = EntityAccessor.getAttributeAsBoolean(xml, "temporaryTable");
+
+        /**
+         * Returns a boolean which indicates whether the current node is a logical sub-division of the schema.
+         * @type {boolean}
+         */
+        // An element has no real value if its type is empty
+        this.isElementOnly = this.type === "";
+
+        /**
+         * Returns a boolean. If the value added is vrai, during record deduplication, the default value (defined in defaultValue) is automatically reapplied during recording.
+         * @type {boolean}
+         */
+        this.isDefaultOnDuplicate = EntityAccessor.getAttributeAsBoolean(xml, "defOnDuplicate");
+
+        /**
+         * True if the node is a link and if the join is external.
+         * @type {boolean}
+         */
+        this.isExternalJoin = EntityAccessor.getAttributeAsBoolean(xml, "externalJoin");
+
+        /**
+         * Returns a boolean which indicates whether the current node is mapped by a Memo.
+         * @type {boolean}
+         */
+        this.isMemo = this.type === "memo" || this.type === "CDATA";
+
+        /**
+         * Returns a boolean which indicates whether the current node is mapped by a MemoData.
+         * @type {boolean}
+         */
+        this.isMemoData = this.isMemo && this.name === 'data';
+
+        /**
+         * Returns a boolean which indicates whether the current node is a BLOB.
+         * @type {boolean}
+         */
+        this.isBlob = this.type === "blob";
+
+        /**
+         * Returns a boolean which indicates whether the current node is mapped from CDATA type XML.
+         * @type {boolean}
+         */
+        this.isCDATA = this.type === "CDATA";
+
+        const notNull = EntityAccessor.getAttributeAsString(xml, "notNull");
+        const sqlDefault = EntityAccessor.getAttributeAsString(xml, "sqlDefault");
+        const notNullOverriden = notNull || sqlDefault === "NULL";
+        /**
+         * Returns a boolean which indicates whether or not the current node can take the null value into account.
+         * @type {boolean}
+         */
+        this.isNotNull = notNullOverriden ? XtkCaster.asBoolean(notNull) : this.type === "int64" || this.type === "short" ||
+            this.type === "long" || this.type === "byte" || this.type === "float" || this.type === "double" ||
+            this.type === "money" || this.type === "percent" || this.type === "time" || this.type === "boolean";
+
+        /**
+         * Returns a boolean which indicates whether or not the value of the current node is mandatory.
+         * @type {boolean}
+         */
+        this.isRequired = EntityAccessor.getAttributeAsBoolean(xml, "required");
+
+        /**
+         * Returns a boolean which indicates whether the current node is mapped in SQL.
+         * @type {boolean}
+         */
+        this.isSQL = !!this.SQLName || !!this.SQLTable || (this.isLink && this.schema.mappingType === 'sql' && !this.isMappedAsXML);
+
+         /**
+          * The SQL name of the field. The property is an empty string if the object isn't an SQL type field.
+          * @type {string}
+          */
+        this.PKSequence = EntityAccessor.getAttributeAsString(xml, "pkSequence");
+
+         /**
+          * Name of the reverse link in the target schema
+          * @type {string}
+          */
+        this.revLink = EntityAccessor.getAttributeAsString(xml, "revLink");
+
+        /**
+         * Returns a boolean which indicates whether the value of the current node is the result of a calculation.
+         * @type {boolean}
+         */
+        this.isCalculated = false;
+
+        /**
+          * Expression associated with the node
+          * @type {string}
+          */
+        this.expr = EntityAccessor.getAttributeAsString(xml, "expr");
+        if (this.expr) this.isCalculated = true;
+
+        /**
+         * Returns a boolean which indicates whether the value of the current node is incremented automatically.
+         * @type {boolean}
+         */
+        this.isAutoIncrement = EntityAccessor.getAttributeAsBoolean(xml, "autoIncrement");
+
+        /**
+         * Returns a boolean which indicates whether the current node is a primary key.
+         * @type {boolean}
+         */
+        this.isAutoPK = EntityAccessor.getAttributeAsBoolean(xml, "autopk");
+
+        /**
+         * Returns a boolean which indicates whether the current node is an automatic UUID
+         * @type {boolean}
+         */
+        this.isAutoUUID = EntityAccessor.getAttributeAsBoolean(xml, "autouuid");
+
+        /**
+         * Returns a boolean which indicates whether the schema is a staging schema
+         * @type {boolean}
+         */
+        this.isAutoStg = EntityAccessor.getAttributeAsBoolean(xml, "autoStg");
+
+        /**
+         * Returns a string that gives the package status.
+         * @type {"never" | "always" | "default" | "preCreate"}
+         */
+        this.packageStatusString = EntityAccessor.getAttributeAsString(xml, "pkgStatus");
+        
+        /**
+         * Returns a number that gives the package status.
+         * @type {0 | 1 | 2 | 3}
+         */
+        this.packageStatus = PACKAGE_STATUS[this.packageStatusString];
+
+         // Children (elements and attributes)
         const childNodes = [];
-        for (const child of EntityAccessor.getChildElements(xml, "attribute")) {
-            const node = new XtkSchemaNode();
-            node.init(schema, child, this, true);
-            childNodes.push(node);
-        }
-        for (const child of EntityAccessor.getChildElements(xml, "element")) {
-            const node = new XtkSchemaNode();
-            node.init(schema, child, this, false);
-            childNodes.push(node);
+        for (const child of EntityAccessor.getChildElements(xml)) {
+            if (child.tagName === "attribute") {
+                const node = new XtkSchemaNode();
+                node.init(schema, child, this, true);
+                childNodes.push(node);
+            }
+            if (child.tagName === "element") {
+                const node = new XtkSchemaNode();
+                node.init(schema, child, this, false);
+                childNodes.push(node);    
+            }
+            if (child.tagName === "compute-string") {
+                this.expr = EntityAccessor.getAttributeAsString(child, "expr");
+                this.isCalculated = false;
+            }
         }
         for (const childNode of childNodes) {
-            if (this.children[childNode.name]) {
-                // already a child with the name => there's a problem with the schema
-                throw new DomException(`Failed to create schema node '${childNode.name}': there's a already a node with this name`);
-            }
-            this.children[childNode.name] = childNode;
+            this.children._push(childNode.name, childNode);
             this.childrenCount = this.childrenCount + 1;
         }
 
         // Keys (after elements and attributes have been found)
         for (const child of EntityAccessor.getChildElements(xml, "key")) {
             const key = new XtkSchemaKey(schema, child, this);
-            this.keys[key.name] = key;
+            this.keys._push(key.name, key);
         }
-    }
 
-    /**
-     * Does the node have a child with the given name?
-     * 
-     * @param {string} name the child name, without the "@" character for attributes
-     * @returns {boolean} a boolean indicating whether the node contains a child with the given name
-     */
-    hasChild(name) {
-        var child = this.children[name];
-        if (child) return true;
-        // TODO: handle ref target
-    //    if (this.hasRefTarget())
-    //        return this.refTarget().hasChild(name);
-        return false;
+        // Propagate implicit values
+        // Name -> Label -> Desc -> HelpText
+        propagateImplicitValues(this);
     }
 
     /**
@@ -325,34 +645,78 @@ class XtkSchemaNode {
         return new XPath(path);
     }
 
+    /**
+     * Find the target of a ref node.
+     * @returns {Promise<Campaign.XtkNode>} the target node, or undefined if not found
+     */
+    async refTarget() {
+        if (!this.ref) return;
+        const index = this.ref.lastIndexOf(':');
+        if (index !== -1) {
+            // find the associated schame
+            const refSchemaId = this.ref.substring(0, index);
+            if (refSchemaId.indexOf(':') === -1)
+                throw Error(`Cannot find ref target '${this.ref}' from node '${this.nodePath}' of schema '${this.schema.id}': ref value is not correct (expeted <schemaId>:<path>)`);
+            const refPath = this.ref.substring(index + 1);
+            // inside current schema ?
+            if (refSchemaId === this.schema.id)
+                return this.schema.findNode(refPath);
+            const refSchema = await this.schema._application.getSchema(refSchemaId);
+            if (!refSchema) return;
+            return refSchema.findNode(refPath);
+        }
+        else {
+            // ref is in the current schema
+            return this.schema.findNode(this.ref);
+        }
+    }
+
+    /**
+     * Find the target of a link node.
+     * @returns {Promise<Campaign.XtkNode>} the target node, or undefined if not found
+     */
+     async linkTarget() {
+        if (this.type !== "link") return this.schema.root;
+        let schemaId = this.target;
+        let xpath = "";
+        if (this.target.indexOf(',') !== -1)
+            throw new Error(`Cannot find target of link '${this.target}': target has multiple schemas`);
+        const index = this.target.indexOf('/');
+        if (index !== -1) {
+            xpath = this.target.substring(index + 1);
+            schemaId = this.target.substring(0, index);
+            xpath = this.target.substring(index + 1);
+        }
+        if (schemaId.indexOf(':') === -1)
+            throw new Error(`Cannot find target of link '${this.target}': target is not a valid link target (missing schema id)`);
+        const schema = await this.schema._application.getSchema(schemaId);
+        if (!schema) return;
+        const root = schema.root;
+        if (!root) return;
+        if (!xpath) return root;
+        return await root.findNode(xpath);
+    }
 
     /**
-     * Returns an instance of XtkSchemaNode or null if the node doesn't exist and the mustExist parameter is set to false.
+     * Returns an instance of XtkSchemaNode or null if the node doesn't exist. In version 1.1.0 and above, this function is
+     * asynchronous (returns a Promise)
      *
      * @param {XML.XPath|string} path XPath represents the name of the node to be searched
-     * @param {boolean} strict indicates whether (strict to false) or not, when the name of the last item in the path does not exist as is, it should be searched for as an attribute or an element. By default to true.
-     * @param {boolean} mustExist indicates whether an exception must be raised if the node does not exist. true by default
-     * @returns Returns a XtkSchemaNode instance if the node can be found, or null if the mustExist parameter is set to false.
-     * @throws {Error} if the request cannot be find (when mustExist is set)
+     * @returns {Promise<XtkSchemaNode>} Returns a XtkSchemaNode instance if the node can be found
     */
-    findNode(path, strict, mustExist) {
-        if (strict === undefined) strict = true;
-        if (mustExist === undefined) mustExist = true;
-        if (typeof path == "string")
-            path = new XPath(path);
+     async findNode(path) {
+        if (typeof path == "string") path = new XPath(path);
 
         // Find the starting node
         var node = this;
         if (path.isEmpty() || path.isAbsolute()) {
             node = this.schema.root;
-            if (!node)
-                throw new DomException(`Cannot find node '${path}' in node ${this.name} : schema ${this.schema.name} does not have a root node`);
+            if (!node) return;
             path = path.getRelativePath();
         }
 
         // Special case for current path "."
-        if (path.isSelf())
-            return this;
+        if (path.isSelf()) return this;
 
         const elements = path.getElements();
         while (node && elements.length > 0) {
@@ -360,57 +724,27 @@ class XtkSchemaNode {
             var name = element.asString();
 
             // TODO: if the path is a collection path, ignore the collection index
-            // TODO: handle ref elements (consider the ref target instead)
-            // TODO: Handle link between schemas
-            // TODO: Handle any type
-            
-            if (!strict && elements.length == 0 && (!node.children[name] || !isAttributeName(name))) {
-                // name is the final part of the path and the associated definition
-                // does not exists. Since strict is set to false we check if the
-                // alternate name exists (element name for an attribute or attribute
-                // name for an element).
-                var found = node.children[name];
-                if (!found && isAttributeName(name)) found = node.children[name.substring(1)];
-                if (!found && !isAttributeName(name)) found = node.children[`@${name}`];
-                if (found) name = found.name;
-            }
+
+            // handle ref elements (consider the ref target instead)
+            if (node.ref) node = await node.refTarget();
+            if (!node) break;
+
+            if (node.type === "link") node = await node.linkTarget();
+            if (!node) break;
+
+            // Don't continue for any type
+            // kludge to accept immediate child of an ANY type node (cas in packages)
+            if (node.type === 'ANY') return this.children[name];
 
             var childNode = null;
-            if (element.isSelf()) 
-                childNode = node;
-            else if (element.isParent())
-                childNode = node.parent;
-            else
-                childNode = node._getChildDefAutoExpand(name, mustExist);
+            if (element.isSelf()) childNode = node;
+            else if (element.isParent()) childNode = node.parent;
+            else childNode = await node.children[name];
             node = childNode;
         }
         return node;
     }
 
-    // See CXtkNodeDef::GetChildDefAutoExpand
-    _getChildDefAutoExpand(name, mustExist) {
-        var child = this.children[name];
-        if (child)
-            return child;
-        
-        // TODO: handle ref
-
-        if (mustExist) {    
-            // TODO: handle auto-expand schemas
-            const path = this._getNodePath();
-            const isAttribute = isAttributeName(name);
-            const schemaDesc = this.schema.userDescription;
-            if( path.isRootPath() ) {
-                if (isAttribute) throw new DomException(`Unknown attribute '${name.substring(1)}' (see definition of schema '${schemaDesc}').`);
-                else throw new DomException(`Unknown element '${name}' (see definition of schema '${schemaDesc}').`);
-            }
-            if (isAttribute) throw new DomException(`Unknown attribute '${name.substring(1)}' (see definition of element '${path.asString()}' in schema '${schemaDesc}').`);
-            else throw new DomException(`Unknown element '${name}' (see definition of element '${path.asString()}' in schema '${schemaDesc}').`);
-        }
-
-        return null;
-    }
-
     /**
      * Internal recursive function used to create a multi-line debug string representing the schema
      * 
@@ -420,13 +754,104 @@ class XtkSchemaNode {
      */
     toString(indent) {
         indent = indent || "";
-        var s = `${indent}${this.userDescription}\n`;
-        for (var name in this.children) {
-            s = s + this.children[name].toString(`   ${indent}`);
+        var s = `${indent}${this.label} (${this.name})\n`;
+        for (var child of this.children) {
+            s = s + child.toString(`    ${indent}`);
         }
         return s;
     }
 
+    /**
+     * Return the XtkSchemaNodes making up the join of a link-type node
+     * @returns {Promise<Array>} returns an array of joins. Each join is an element having a source and destination attributes, whose value is the corresponding XtkSchemaNode
+     */
+    async joinNodes() {
+        if (!this.isLink) return;
+        const joinParts = [];
+        for (const join of this.joins) {
+            const source = await this.parent.findNode(join.src);
+            let destination = await this.linkTarget();
+            if (destination) 
+                destination = await destination.findNode(join.dst);
+            if (source && destination)
+                joinParts.push({
+                    source: source,
+                    destination: destination
+                });
+        }
+        return joinParts;
+    }
+
+    /**
+     * Returns the reverse link node of a link-type node
+     * @returns {Promise<Campaign.XtkSchemaNode>}
+     */
+    async reverseLink() {
+        if (!this.isLink) return;
+        const target = await this.linkTarget();
+        if (!target) return;
+        const revLink = await target.findNode(this.revLink);
+        return revLink;
+    }
+
+    /**
+     * Returns the compute string of a node. As the node can be a link or a reference, this function is asynchronous
+     * @returns {Promise<string>}
+     */
+     async computeString() {
+        if (this.expr) return this.expr;
+         // if we are a ref: ask the target of the ref
+         if (this.ref) {
+            const refTarget = await this.refTarget();
+            if (!refTarget) return "";
+            return await refTarget.computeString();
+        }
+        // No compute-string found: generate a default one (first key field)
+        if (this.keys && this.keys.length > 0) {
+            const key = this.keys[0];
+            if (key && key.fields && key.fields.length > 0 && key.fields[0])
+                return this.schema._application.client.sdk.expandXPath(key.fields[0].nodePath);
+        }
+        return "";
+    }
+
+    /**
+     * Returns an Enumeration object which is the enumeration linked to the current node or null if there is no enumeration.
+     * @param {string} an optional enumeration name. If none is specified, the node `enum` property will be used
+     * @returns Promise<Campaign.XtkEnumeration>
+     */
+    async enumeration(optionalName) {
+        const name = optionalName || this.enum;
+        if (!name) return;
+        const enumaration = await this.schema._application.getSysEnum(name, this.schema);
+        return enumaration;
+    }
+
+    /**
+     * Get the first internal key (if there is one)
+     * @returns {Campaign.XtkSchemaKey}
+     */
+    firstInternalKeyDef() {
+        return this.keys.find((k) => k.isInternal);
+    }
+    
+    /**
+     * Get the first external key (if there is one)
+     * @returns {Campaign.XtkSchemaKey}
+     */
+    firstExternalKeyDef() {
+        return this.keys.find((k) => !k.isInternal);
+    }
+    
+    /**
+     * Get the first key (internal first)
+     * @returns {Campaign.XtkSchemaKey}
+     */
+    firstKeyDef() {
+        let key = this.firstInternalKeyDef();
+        if (!key) key = this.firstExternalKeyDef();
+        return key;
+    }
 }
 
 // ========================================================================================
@@ -489,6 +914,8 @@ function XtkEnumerationValue(xml, baseType) {
      * @type {*}
      */
     this.value = XtkCaster.as(stringValue, baseType);
+
+    propagateImplicitValues(this, true);
 }
 
 /**
@@ -500,52 +927,69 @@ function XtkEnumerationValue(xml, baseType) {
  * @param {XML.XtkObject} xml the enumeration definition
  * @memberof Campaign
  */
-function XtkEnumeration(xml) {
-    /**
-     * The system enumeration name
-     * @type {string}
-     */
-    this.name = EntityAccessor.getAttributeAsString(xml, "name");
-    /**
-     * A human friendly name for the system enumeration
-     * @type {string}
-     */
-    this.label = EntityAccessor.getAttributeAsString(xml, "label");
-    /**
-     * A human friendly long description of the enumeration
-     * @type {string}
-     */
-    this.description = EntityAccessor.getAttributeAsString(xml, "desc");
-    /**
-     * The type of the enumeration
-     * @type {Campaign.XtkEnumerationType}
-     */
-    this.baseType = EntityAccessor.getAttributeAsString(xml, "basetype");
-    /**
-     * The default value of the enumeration
-     * @type {Campaign.XtkEnumerationValue}
-     */
-    this.default = null;
-    /**
-     * Indicates if the enumeration has an image, i.e. if any of its values has an image
-     * @type {boolean}
-     */
-    this.hasImage = false;
-    /**
-     * The enumerations values 
-     * @type {Object<string, Campaign.XtkEnumerationValue>}
-     */
-    this.values = {};
+class XtkEnumeration {
+    constructor(schemaId, xml) {
+        /**
+         * The system enumeration name, fully qualified, i.e. prefixed with the schema id
+         * @type {string}
+         */
+        this.name = EntityAccessor.getAttributeAsString(xml, "name");
+
+        /**
+         * A human friendly name for the system enumeration
+         * @type {string}
+         */
+        this.label = EntityAccessor.getAttributeAsString(xml, "label");
+
+        /**
+         * A human friendly long description of the enumeration
+         * @type {string}
+         */
+        this.description = EntityAccessor.getAttributeAsString(xml, "desc");
+
+        /**
+         * The type of the enumeration, usually "string" or "byte"
+         * @type {Campaign.XtkEnumerationType}
+         */
+        this.baseType = EntityAccessor.getAttributeAsString(xml, "basetype");
+
+        /**
+         * The default value of the enumeration
+         * @type {Campaign.XtkEnumerationValue}
+         */
+        this.default = null;
+
+        /**
+         * Indicates if the enumeration has an image, i.e. if any of its values has an image
+         * @type {boolean}
+         */
+        this.hasImage = false;
 
-    var defaultValue = EntityAccessor.getAttributeAsString(xml, "default");
+        /**
+         * The enumerations values 
+         * @type {Utils.ArrayMap<Campaign.XtkEnumerationValue>}
+         */
+         this.values = new ArrayMap();
+
+        var defaultValue = EntityAccessor.getAttributeAsString(xml, "default");
+
+        for (var child of EntityAccessor.getChildElements(xml, "value")) {
+            const e = new XtkEnumerationValue(child, this.baseType);
+            this.values._push(e.name, e);
+            if (e.image != "") this.hasImage = true;
+            const stringValue = EntityAccessor.getAttributeAsString(child, "value");
+            if (defaultValue == stringValue)
+                this.default = e;
+        }
+
+        propagateImplicitValues(this, true);
 
-    for (var child of EntityAccessor.getChildElements(xml, "value")) {
-        const e = new XtkEnumerationValue(child, this.baseType);
-        this.values[e.name] = e;
-        if (e.image != "") this.hasImage = true;
-        const stringValue = EntityAccessor.getAttributeAsString(child, "value");
-        if (defaultValue == stringValue)
-            this.default = e;
+        /**
+         * The system enumeration name, without the schema id prefix
+         * @type {string}
+         */
+         this.shortName = this.name;
+        this.name = `${schemaId}:${this.shortName}`;
     }
 }
 
@@ -565,58 +1009,79 @@ function XtkEnumeration(xml) {
  */
 class XtkSchema extends XtkSchemaNode {
 
-    constructor(xml) {
+    constructor(application, xml) {
         super();
-        this.init(this, xml);
+        this._application = application;
 
         /**
          * The namespace of the schema
          * @type {string}
          */
         this.namespace = EntityAccessor.getAttributeAsString(xml, "namespace");
+
         /**
          * The schema id, in the form "namespace:name"
          * @type {string}
          */
+        this.name = EntityAccessor.getAttributeAsString(xml, "name");
         this.id = `${this.namespace}:${this.name}`;
+
         /**
          * Indicates whether the schema is a library schema or not
          * @type {boolean}
          */
         this.isLibrary = EntityAccessor.getAttributeAsBoolean(xml, "library");
+
         /**
          * A human name for the schema, in singular
          * @type {string}
          */
         this.labelSingular = EntityAccessor.getAttributeAsString(xml, "labelSingular");
+
         /**
          * The schema mappgin type, following the xtk:srcSchema:mappingType enumeration
          * @type {Campaign.XtkSchemaMappingType}
          */
         this.mappingType = EntityAccessor.getAttributeAsString(xml, "mappingType");
+
+        /**
+         * The MD5 checksum of the schema in the form of a hexadecimal string
+         * @type {string}
+         */
+        this.md5 = EntityAccessor.getAttributeAsString(xml, "md5");
+
         /**
          * The schema definition
          * @private
          * @type {XML.XtkObject}
          */
         this.xml = xml;
+
+        this.init(this, xml);
+
         /**
          * The schema root node, if it has one, i.e. the first child whose name matches the schema name
          * @type {Campaign.XtkSchemaNode}
          */
         this.root = this.children[this.name];
+        
+        /**
+         * A user desciption of the node, in the form "label (name)"
+         * @type {string}
+         */
+         this.userDescription = (this.label == this.name) ? this.name : `${this.label} (${this.name})`;
+
         /**
          * Enumerations in this schema, as a dictionary whose keys are enumeration names and values are the
          * corresponding enumeration definitions
-         * @type {Object<string, XtkEnumeration>}
+         * @type {Utils.ArrayMap<Campaign.XtkEnumeration>}
          */
-        this.enumerations = {};
-
-        for (var child of EntityAccessor.getChildElements(xml, "enumeration")) {
-            const e = new XtkEnumeration(child);
-            this.enumerations[e.name] = e;
-        }
-    }
+         this.enumerations = new ArrayMap();
+         for (var child of EntityAccessor.getChildElements(xml, "enumeration")) {
+             const e = new XtkEnumeration(this.id, child);
+             this.enumerations._push(e.shortName, e);
+         }
+     }
 
     /**
      * Creates a multi-line debug string representing the schema
@@ -625,9 +1090,8 @@ class XtkSchema extends XtkSchemaNode {
      */
     toString() {
         var s =  `${this.userDescription}\n`;
-        //s = s + `   enumerations: [${enumerations}]`
-        for (var name in this.children) {
-            s = s + this.children[name].toString("    - ");
+        for (var child of this.children) {
+            s = s + child.toString("    - ");
         }
         return s;
     }
@@ -657,21 +1121,25 @@ class CurrentLogin {
          * @type {string}
          */
         this.login = EntityAccessor.getAttributeAsString(userInfo, "login");
+
         /**
          * The operator login id
          * @type {number}
          */
         this.id = EntityAccessor.getAttributeAsLong(userInfo, "loginId");
+        
         /**
          * A human friendly string naming the operator (compute string)
          * @type {string}
          */
         this.computeString = EntityAccessor.getAttributeAsString(userInfo, "loginCS");
+        
         /**
          * The operator timezone
          * @type {string}
          */
         this.timezone = EntityAccessor.getAttributeAsString(userInfo, "timezone");
+        
         /**
          * The llist of operator rights
          * @type {string[]}
@@ -680,8 +1148,8 @@ class CurrentLogin {
         this._rightsSet = {};
         for (var child of EntityAccessor.getChildElements(userInfo, "login-right")) {
             const right = EntityAccessor.getAttributeAsString(child, "right");
-            this.rights.push(right);
-            this._rightsSet[right] = true;
+        this.rights.push(right);
+        this._rightsSet[right] = true;
         }
     }
 
@@ -729,6 +1197,7 @@ class Application {
      */
     constructor(client) {
         this.client = client;
+        this._schemaCache = new SchemaCache(client);
         const info = this.client.getSessionInfo();
         // When using "SessionToken" authentication, there is no actual logon, and therefore
         // no "sessionInfo" object
@@ -738,25 +1207,25 @@ class Application {
              * The server build number
              * @type {string}
              */
-            this.buildNumber = EntityAccessor.getAttributeAsString(serverInfo, "buildNumber");
+        this.buildNumber = EntityAccessor.getAttributeAsString(serverInfo, "buildNumber");
             /**
              * The Campaign instance name
              * @type {string}
              */
-            this.instanceName = EntityAccessor.getAttributeAsString(serverInfo, "instanceName");
+        this.instanceName = EntityAccessor.getAttributeAsString(serverInfo, "instanceName");
             const userInfo = EntityAccessor.getElement(info, "userInfo");
             /**
              * The logged operator
              * @type {Campaign.CurrentLogin}
              */
-            this.operator = new CurrentLogin(userInfo);
+        this.operator = new CurrentLogin(userInfo);
             /**
              * The list of installed packages
              * @type {string[]}
              */
-            this.packages = [];
+        this.packages = [];
             for (var p of EntityAccessor.getChildElements(userInfo, "installed-package")) {
-                this.packages.push(`${EntityAccessor.getAttributeAsString(p, "namespace")}:${EntityAccessor.getAttributeAsString(p, "name")}`);
+            this.packages.push(`${EntityAccessor.getAttributeAsString(p, "namespace")}:${EntityAccessor.getAttributeAsString(p, "name")}`);
             }
         }
     }
@@ -769,10 +1238,15 @@ class Application {
      * @returns {Campaign.XtkSchema} the schema, or null if the schema was not found
      */
      async getSchema(schemaId) {
+        return this._schemaCache.getSchema(schemaId);
+    }
+
+    // Private function: get a schema without using the cache
+    async _getSchema(schemaId) {
         const xml = await this.client.getSchema(schemaId, "xml");
         if (!xml)
             return null;
-        return newSchema(xml);
+        return newSchema(xml, this);
     }
 
     /**
@@ -787,6 +1261,32 @@ class Application {
         }
         return false;
     }
+
+    /**
+     * Get a system enumeration
+     * 
+     * @param {string} enumerationName The name of the enumeration, which can be fully qualified (ex: "nms:recipient:gender") or not (ex: "gender")
+     * @param {string} schemaOrSchemaId An optional schema id. If the enumerationName is not qualified, the search for the enumeration will be done in this schema
+     * @returns {XtkEnumeration} the enumeration
+     */
+    async getSysEnum(enumerationName, schemaOrSchemaId) {
+        const index = enumerationName.lastIndexOf(':');
+        if (index === -1) {
+            let schema = schemaOrSchemaId;
+            if (schema && typeof schema === "string")
+                schema = await this.getSchema(schema);
+            // unqualified enumeration name
+            if (!schema) return;
+            return schema.enumerations[enumerationName];
+        }
+        // qualified enumeration name
+        const schemaId = enumerationName.substring(0, index);
+        if (schemaId.indexOf(':') === -1)
+            throw Error(`Invalid enumeration name '${enumerationName}': expecting {name} or {schemaId}:{name}`);
+        let schema = await this.getSchema(schemaId);
+        if (!schema) return;
+        return schema.enumerations[enumerationName.substring(index + 1)];
+    }
 }
 
 
@@ -797,4 +1297,5 @@ exports.Application = Application;
 // For tests
 exports.newSchema = newSchema;
 exports.newCurrentLogin = newCurrentLogin;
+exports.SchemaCache = SchemaCache;
 })();