@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/model/csnUtils.js

@@ -1,9 +1,10 @@
 'use strict';
 
-const { csnRefs } = require('../model/csnRefs');
+const { csnRefs, implicitAs } = require('../model/csnRefs');
 const { applyTransformations, applyTransformationsOnNonDictionary } = require('../transform/db/applyTransformations');
 const { isBuiltinType } = require('../compiler/builtins.js')
 const { sortCsn, cloneCsnDictionary: _cloneCsnDictionary } = require('../json/to-csn');
+const { ModelError } = require("../base/error");
 const version = require('../../package.json').version;
 
 // Low-level utility functions to work with compact CSN.
@@ -36,15 +37,15 @@ const version = require('../../package.json').version;
  * Get utility functions for a given CSN.
  * @param {CSN.Model} model (Compact) CSN model
  */
-function getUtils(model) {
-  const { artifactRef, inspectRef, effectiveType, getOrigin } = csnRefs(model);
+function getUtils(model, universalReady) {
+  const { artifactRef, inspectRef, effectiveType, getOrigin, targetAspect, getColumn, getElement, initDefinition } = csnRefs(model, universalReady);
 
   return {
     getCsnDef,
     isStructured,
     getFinalType,
     getFinalTypeDef,
-    isManagedAssociationElement,
+    isManagedAssociation,
     isAssocOrComposition,
     isAssociation,
     isComposition,
@@ -62,6 +63,10 @@ function getUtils(model) {
     get$combined,
     getOrigin,
     getQueryPrimarySource,
+    targetAspect,
+    getColumn,
+    getElement,
+    initDefinition
   };
 
   /**
@@ -71,125 +76,125 @@ function getUtils(model) {
    * @returns {object}
    */
   function get$combined(query) {
-    const sources = getSources(query);
-    return sources;
+    return getSources(query);
+  }
 
-    /**
-     * Get the union of all elements from the from clause
-     * - descend into unions, following the lead query
-     * - merge all queries in case of joins
-     * - follow subqueries
-     *
-     * @param {CSN.Query} query Query to check
-     * @returns {object} Map of sources
-     */
-    function getSources(query, isSubquery=false) {
-      // Remark CW: better just a while along query.SET.args[0]
-      if (query.SET) {
-        if (query.SET.args[0].SELECT && query.SET.args[0].SELECT.elements)
-          return mergeElementsIntoMap(Object.create(null), query.SET.args[0].SELECT.elements, query.SET.args[0].$location);
+  /**
+   * Get the union of all elements from the from clause
+   * - descend into unions, following the lead query
+   * - merge all queries in case of joins
+   * - follow subqueries
+   *
+   * @param {CSN.Query} query Query to check
+   * @param {boolean} [isSubquery]
+   * @returns {object} Map of sources
+   */
+  function getSources(query, isSubquery=false) {
+    // Remark CW: better just a while along query.SET.args[0]
+    if (query.SET) {
+      if (query.SET.args[0].SELECT && query.SET.args[0].SELECT.elements)
+        return mergeElementsIntoMap(Object.create(null), query.SET.args[0].SELECT.elements, query.SET.args[0].$location);
 
-        return getSources(query.SET.args[0], isSubquery);
+      return getSources(query.SET.args[0], isSubquery);
+    }
+    else if (query.SELECT) {
+      if (query.SELECT.from.args) {
+        return walkArgs(query.SELECT.from.args);
       }
-      else if (query.SELECT) {
-        if (query.SELECT.from.args) {
-          return walkArgs(query.SELECT.from.args);
-        }
-        else if (query.SELECT.from.ref) {
-          let art = artifactRef(query.SELECT.from);
+      else if (query.SELECT.from.ref) {
+        let art = artifactRef(query.SELECT.from);
 
-          if(art.target)
-            art = artifactRef(art.target);
+        if(art.target)
+          art = artifactRef(art.target);
 
-          if(isSubquery && !query.SELECT.elements)
-            throw new Error('Expected subquery to have .elements');
+        if(isSubquery && !query.SELECT.elements)
+          throw new ModelError('Expected subquery to have .elements');
 
-          return mergeElementsIntoMap(Object.create(null), isSubquery ? query.SELECT.elements : art.elements, art.$location,
-            query.SELECT.from.as || query.SELECT.from.ref[query.SELECT.from.ref.length - 1],
-            query.SELECT.from.ref[query.SELECT.from.ref.length - 1] || query.SELECT.from.as );
-        }
-        else if (query.SELECT.from.SET || query.SELECT.from.SELECT) {
-          return getSources(query.SELECT.from, true);
-        }
+        return mergeElementsIntoMap(Object.create(null), isSubquery ? query.SELECT.elements : art.elements, art.$location,
+          query.SELECT.from.as || query.SELECT.from.ref[query.SELECT.from.ref.length - 1],
+          query.SELECT.from.ref[query.SELECT.from.ref.length - 1] || query.SELECT.from.as );
       }
-
-      function walkArgs(args) {
-        let elements = Object.create(null);
-        for (const arg of args) {
-          if (arg.args) {
-            elements = mergeElementMaps(elements, walkArgs(arg.args));
-          }
-          else if (arg.ref) {
-            const art = artifactRef(arg);
-            elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || arg.ref[arg.ref.length - 1], arg.ref[arg.ref.length - 1] || arg.as);
-          }
-          else if (arg.SELECT || arg.SET) {
-            elements = mergeElementMaps(elements, getSources(arg));
-          }
-        }
-
-        return elements;
+      else if (query.SELECT.from.SET || query.SELECT.from.SELECT) {
+        return getSources(query.SELECT.from, true);
       }
+    }
 
-      return {};
-
-      /**
-       * Merge two maps of elements together
-       *
-       * @param {object} mapA Map a - will be returned
-       * @param {object} mapB Map b - will not be returned
-       * @returns {object} mapA
-       */
-      function mergeElementMaps(mapA, mapB) {
-        for (const elementName in mapB) {
-          if (!mapA[elementName])
-            mapA[elementName] = [];
-
-          mapB[elementName].forEach(e => mapA[elementName].push(e));
-        }
+    return {};
+  }
 
-        return mapA;
+  function walkArgs(args) {
+    let elements = Object.create(null);
+    for (const arg of args) {
+      if (arg.args) {
+        elements = mergeElementMaps(elements, walkArgs(arg.args));
+      }
+      else if (arg.ref) {
+        const art = artifactRef(arg);
+        elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || arg.ref[arg.ref.length - 1], arg.ref[arg.ref.length - 1] || arg.as);
+      }
+      else if (arg.SELECT || arg.SET) {
+        elements = mergeElementMaps(elements, getSources(arg));
       }
+    }
 
-      /**
-       * Merge elements into an existing map
-       *
-       * @param {any} existingMap map to merge into - will be returned
-       * @param {object} elements elements to merge into the map
-       * @param {CSN.Location} $location $location of the elements - where they come from
-       * @param {any} [parent] Name of the parent of the elements, alias before ref
-       * @param {any} [error_parent] Parent name to use for error messages, ref before alias
-       * @returns {object} existingMap
-       */
-      function mergeElementsIntoMap(existingMap, elements, $location, parent, error_parent) {
-        for (const elementName in elements) {
-          const element = elements[elementName];
-          if (!existingMap[elementName])
-            existingMap[elementName] = [];
-
-
-          existingMap[elementName].push({
-            element, name: elementName, source: $location, parent: getBaseName(parent), error_parent,
-          });
-        }
+    return elements;
+  }
 
-        return existingMap;
-      }
+  /**
+   * Merge two maps of elements together
+   *
+   * @param {object} mapA Map a - will be returned
+   * @param {object} mapB Map b - will not be returned
+   * @returns {object} mapA
+   */
+  function mergeElementMaps(mapA, mapB) {
+    for (const elementName in mapB) {
+      if (!mapA[elementName])
+        mapA[elementName] = [];
+
+      mapB[elementName].forEach(e => mapA[elementName].push(e));
     }
 
-    /**
-     * Return the name part of the artifact name - no namespace etc.
-     * @param {string|object} name Absolute name of the artifact
-     */
-    function getBaseName(name) {
-      if (!name)
-        return name;
+    return mapA;
+  }
 
-      if (name.id)
-        return name.id.substring( name.id.lastIndexOf('.')+1 );
+  /**
+   * Merge elements into an existing map
+   *
+   * @param {any} existingMap map to merge into - will be returned
+   * @param {object} elements elements to merge into the map
+   * @param {CSN.Location} $location $location of the elements - where they come from
+   * @param {any} [parent] Name of the parent of the elements, alias before ref
+   * @param {any} [error_parent] Parent name to use for error messages, ref before alias
+   * @returns {object} existingMap
+   */
+  function mergeElementsIntoMap(existingMap, elements, $location, parent, error_parent) {
+    for (const elementName in elements) {
+      const element = elements[elementName];
+      if (!existingMap[elementName])
+        existingMap[elementName] = [];
 
-      return name.substring( name.lastIndexOf('.')+1 )
+
+      existingMap[elementName].push({
+        element, name: elementName, source: $location, parent: getBaseName(parent), error_parent,
+      });
     }
+
+    return existingMap;
+  }
+
+  /**
+   * Return the name part of the artifact name - no namespace etc.
+   * @param {string|object} name Absolute name of the artifact
+   */
+  function getBaseName(name) {
+    if (!name)
+      return name;
+
+    if (name.id)
+      return name.id.substring( name.id.lastIndexOf('.')+1 );
+
+    return name.substring( name.lastIndexOf('.')+1 )
   }
 
   /**
@@ -216,11 +221,11 @@ function getUtils(model) {
 
   /**
    * Create an object to track visited objects identified by a unique string.
-   * @param {string} [id] Initial entry (optional)
+   * @param {string} [initialId] Initial entry (optional)
    */
-  function createVisited(id) {
+  function createVisited(initialId) {
     let visited = Object.create(null);
-    check(id);
+    check(initialId);
     return { check };
 
     /**
@@ -231,7 +236,7 @@ function getUtils(model) {
     function check(id) {
       if (!id) return;
       if (visited[id]) {
-        throw new Error('Circular dependency');
+        throw new ModelError('Circular dependency');
       }
       visited[id] = true;
     }
@@ -245,7 +250,7 @@ function getUtils(model) {
     if (model.definitions[defName])
       return model.definitions[defName]
     else
-      throw new Error(`Nonexistent definition in the model: '${defName}'`);
+      throw new ModelError(`Nonexistent definition in the model: '${defName}'`);
   }
 
   /**
@@ -298,7 +303,7 @@ function getUtils(model) {
 
   // Return true if 'node' is a managed association element
   // TODO: what about elements having a type, which (finally) is an assoc?
-  function isManagedAssociationElement(node) {
+  function isManagedAssociation(node) {
     return node.target !== undefined && node.on === undefined && node.keys;
   }
 
@@ -442,13 +447,13 @@ function getUtils(model) {
    * The transformer functions are called with the following signature:
    * transformer(value, node, resultNode, key)
    *
-   * @param {any} node Node to transform
+   * @param {any} rootNode Node to transform
    * @param {any} transformers Object defining transformer functions
    * @returns {object}
    */
-  function cloneWithTransformations(node, transformers) {
+  function cloneWithTransformations(rootNode, transformers) {
 
-    return transformNode(node);
+    return transformNode(rootNode);
 
   // This general transformation function will be applied to each node recursively
     function transformNode(node) {
@@ -536,7 +541,7 @@ function getUtils(model) {
       if (cycleCheck) {
         let visited = path.length? type + ':' + path.join('.') : type;
         if (cycleCheck[visited])
-          throw new Error('Circular type chain on type ' + type);
+          throw new ModelError('Circular type chain on type ' + type);
         else
           cycleCheck[visited] = true;
       }
@@ -583,7 +588,7 @@ function getUtils(model) {
  * @param {object} csn Top-level CSN.  You can pass non-dictionary values.
  * @param {CSN.Options} options CSN Options, only used for `dictionaryPrototype`, `testMode`, and `testSortCsn`
  */
-function cloneCsn(csn, options) {
+function cloneCsnNonDict(csn, options) {
   return sortCsn(csn, options);
 }
 
@@ -591,7 +596,7 @@ function cloneCsn(csn, options) {
  * Deeply clone the given CSN dictionary and return it.
  * Note that annotations are only copied shallowly.
  * This function does _not_ sort the given dictionary.
- * See cloneCsn() if you want sorted definitions.
+ * See cloneCsnNonDict() if you want sorted definitions.
  *
  * @param {object} csn
  * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
@@ -627,8 +632,10 @@ function forEachDefinition( csn, callback, iterateOptions = {} ) {
  * @param {CSN.Path} [path]
  * @param {boolean} [ignoreIgnore]
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param constructCallback
  */
-function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {}) {
+function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                        constructCallback = (_construct, _prop, _path) => {}) {
   // Allow processing _ignored elements if requested
   if (ignoreIgnore && construct._ignore) {
     return;
@@ -636,8 +643,7 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
 
   // `items` itself is a structure that can contain "elements", and more.
   if (construct.items) {
-    // TODO: Should we go to the deepest items.items?
-    forEachMember( construct.items, callback, [...path, 'items'], ignoreIgnore, iterateOptions );
+    forEachMember( construct.items, callback, [...path, 'items'], ignoreIgnore, iterateOptions, constructCallback );
   }
 
   // Unlike XSN, we don't make "returns" a "params" in the callback.
@@ -645,12 +651,43 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
   // `elements` of the return type (if structured).
   // TODO: `returns` should be handled like a parameter just like XSN (maybe with different prop name)
   if (construct.returns && !iterateOptions.elementsOnly) {
-    forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions );
+    forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions, constructCallback );
   }
 
   path = [...path]; // Copy
-  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'foreignKeys', 'actions', 'params']);
-  propsWithMembers.forEach((prop) => forEachGeneric( construct, prop, callback, path, iterateOptions ));
+  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'actions', 'params']);
+  propsWithMembers.forEach((prop) => {
+    forEachGeneric( construct, prop, callback, path, iterateOptions );
+    if (construct[prop]) {
+      if (Array.isArray(constructCallback))
+        constructCallback.forEach(cb => cb(construct, prop, path));
+      else
+        constructCallback(construct, prop, path);
+    }
+  });
+}
+
+/**
+ * Call `forEachMember` and then apply `forEachMember` on queries.
+ *
+ * @param {CSN.Artifact} construct
+ * @param {genericCallback|genericCallback[]} callback
+ * @param {CSN.Path} [path]
+ * @param {boolean} [ignoreIgnore]
+ * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
+ */
+function forEachMemberWithQuery( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+  constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMember(construct, callback, path, ignoreIgnore, iterateOptions, constructCallback);
+  if (construct.query) {
+    forAllQueries(construct.query, (q, p) => {
+      const s = q.SELECT;
+      if(s) {
+        forEachMember(s, callback, p, ignoreIgnore, iterateOptions);
+      }
+    }, [ ...path, 'query' ]);
+  }
 }
 
 /**
@@ -662,16 +699,43 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
  * @param {CSN.Path} [path]
  * @param {boolean} [ignoreIgnore]
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
  */
-function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {}) {
-  forEachMember( construct, ( member, memberName, prop, subpath ) => {
+function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                                   constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMember( construct, ( member, memberName, prop, subpath, parent ) => {
     if(Array.isArray(callback))
-      callback.forEach(cb => cb( member, memberName, prop, subpath, construct ));
+      callback.forEach(cb => cb( member, memberName, prop, subpath, parent ));
     else
-      callback( member, memberName, prop, subpath, construct );
+      callback( member, memberName, prop, subpath, parent );
     // Descend into nested members, too
-    forEachMemberRecursively( member, callback, subpath, ignoreIgnore, iterateOptions);
-  }, path, ignoreIgnore, iterateOptions);
+    forEachMemberRecursively( member, callback, subpath, ignoreIgnore, iterateOptions, constructCallback);
+  }, path, ignoreIgnore, iterateOptions, constructCallback);
+}
+
+/**
+ * Apply function `callback(member, memberName)` to each member in `construct`,
+ * recursively (i.e. also for sub-elements of elements).
+ * Recursively iterate over elements of `construct` query.
+ *
+ * @param {CSN.Artifact} construct
+ * @param {genericCallback|genericCallback[]} callback
+ * @param {CSN.Path} [path]
+ * @param {boolean} [ignoreIgnore]
+ * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
+ */
+function forEachMemberRecursivelyWithQuery( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                                              constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMemberRecursively(construct, callback, path, ignoreIgnore, iterateOptions, constructCallback);
+  if(construct.query) {
+    forAllQueries(construct.query, (q, p) => {
+      const s = q.SELECT;
+      if(s) {
+        forEachMemberRecursively(s, callback, p, ignoreIgnore, iterateOptions);
+      }
+    }, [ ...path, 'query' ]);
+  }
 }
 
 /**
@@ -680,14 +744,14 @@ function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=tr
  * the following arguments: the object, the name, and -if it is a duplicate-
  * the array index and the array containing all duplicates.
  *
- * @param {object} obj
+ * @param {object} construct
  * @param {string} prop
  * @param {genericCallback|genericCallback[]} callback
  * @param {CSN.Path} path
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
  */
-function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
-  const dict = obj[prop];
+function forEachGeneric( construct, prop, callback, path = [], iterateOptions = {}) {
+  const dict = construct[prop];
   for (const name in dict) {
     if (!Object.prototype.hasOwnProperty.call(dict, name))
       continue;
@@ -696,65 +760,26 @@ function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
        || (iterateOptions.skipArtifact && typeof iterateOptions.skipArtifact === 'function'
            && iterateOptions.skipArtifact(dictObj, name)))
       continue;
-    cb( dictObj, name );
+    executeCallbacks( dictObj, name );
   }
-  function cb(o, name ) {
+  function executeCallbacks(o, name ) {
     if (Array.isArray(callback))
-      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name])));
+      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name]), construct ));
     else
-      callback( o, name, prop, path.concat([prop, name]))
-  }
-}
-
-/**
- * For each property named 'ref' in 'node' (recursively), call callback(ref, node, path)
- *
- * @param {object} node
- * @param {refCallback|refCallback[]} callback
- * @param {CSN.Path} path
- */
-function forEachRef(node, callback, path = []) {
-  if (node === null || typeof node !== 'object') {
-    // Primitive node
-    return;
-  }
-
-  if(node._ignore){
-    return;
-  }
-
-  if(Array.isArray(node)){
-    for (let i = 0; i < node.length; i++) {
-      // Descend recursively
-      forEachRef(node[i], callback, path.concat([i]));
-    }
-  } else {
-    for (let name in node) {
-      if (!Object.hasOwnProperty.call( node, name ))
-        continue;
-      // If ref found within a non-dictionary, call callback
-      if (name === 'ref' && Object.getPrototypeOf(node)) {
-        if(Array.isArray(callback))
-          callback.forEach(cb => cb( node.ref, node, path ));
-        else
-          callback( node.ref, node, path );
-      }
-      // Descend recursively
-      forEachRef(node[name], callback, path.concat([name]));
-    }
+      callback( o, name, prop, path.concat([prop, name]), construct )
   }
 }
 
 // Like Object.assign() but copies also non enumerable properties
 function assignAll(target, ...sources) {
   sources.forEach(source => {
-    let descriptors = Object.getOwnPropertyNames(source).reduce((descriptors, key) => {
-      descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
-      return descriptors;
+    const descriptors = Object.getOwnPropertyNames(source).reduce((propertyDescriptors, current) => {
+      propertyDescriptors[current] = Object.getOwnPropertyDescriptor(source, current);
+      return propertyDescriptors;
     }, {});
     // by default, Object.assign copies enumerable Symbols too
     Object.getOwnPropertySymbols(source).forEach(sym => {
-      let descriptor = Object.getOwnPropertyDescriptor(source, sym);
+      const descriptor = Object.getOwnPropertyDescriptor(source, sym);
       if (descriptor.enumerable) {
         descriptors[sym] = descriptor;
       }
@@ -765,101 +790,68 @@ function assignAll(target, ...sources) {
 }
 
 /**
- * @param {CSN.Query} query
- * @param {queryCallback|queryCallback[]} callback
+ * @param {CSN.Query} mainQuery
+ * @param {queryCallback|queryCallback[]} queryCallback
  * @param {CSN.Path} path
  */
-function forAllQueries(query, callback, path = []){
-  return traverseQuery(query, callback, path);
-  function traverseQuery( q, callback, p ) {
-    if (q.SELECT) {
+function forAllQueries(mainQuery, queryCallback, path = []){
+  return traverseQuery(mainQuery, queryCallback, path);
+  function traverseQuery( query, callback, queryPath ) {
+    if (query.SELECT) {
       // The projection is turned into a normalized query - there
       // is no real SELECT, it is fake
       if(!(path.length === 3 && path[2] === 'projection'))
-        p.push('SELECT');
-      cb( q, p );
-      q = q.SELECT;
+        queryPath.push('SELECT');
+      executeCallbacks();
+      query = query.SELECT;
     }
-    else if (q.SET) {
-      p.push('SET');
-      cb( q, p );
-      q = q.SET;
+    else if (query.SET) {
+      queryPath.push('SET');
+      executeCallbacks();
+      query = query.SET;
     }
 
-    if (q.from)
-      traverseFrom( q.from, callback, p.concat(['from']) );
+    if (query.from)
+      traverseFrom( query.from, callback, queryPath.concat(['from']) );
 
     for (const prop of ['args', 'xpr', 'columns', 'where', 'having']) {
       // all properties which could have sub queries (directly or indirectly)
-      const expr = q[prop];
+      const expr = query[prop];
       if (expr && typeof expr === 'object') {
         if(Array.isArray(expr)){
           for(let i = 0; i < expr.length; i++){
-            traverseQuery(expr[i], callback, p.concat([prop, i]));
+            traverseQuery(expr[i], callback, queryPath.concat([prop, i]));
           }
         } else {
           for(const argName of Object.keys( expr )){
-            traverseQuery(expr[argName], callback, p.concat([prop, argName]))
+            traverseQuery(expr[argName], callback, queryPath.concat([prop, argName]))
           }
         }
       }
     }
-    function cb(q, p) {
+    function executeCallbacks() {
       if(Array.isArray(callback))
-        callback.forEach(cb => cb( q, p ));
+        callback.forEach(cb => cb( query, queryPath ));
       else
-        callback( q, p );
+        callback( query, queryPath );
     }
   }
 
   /**
    * @param {CSN.QueryFrom} from
    * @param {Function} callback
-   * @param {CSN.Path} path
+   * @param {CSN.Path} csnPath
    */
-  function traverseFrom( from, callback, path = [] ) {
+  function traverseFrom( from, callback, csnPath = [] ) {
     if (from.ref) // ignore
       return;
     else if (from.args){ // join
       for(let i = 0; i < from.args.length; i++){
-        traverseFrom(from.args[i], callback, path.concat(['args', i]));
+        traverseFrom(from.args[i], callback, csnPath.concat(['args', i]));
       }
     }
     else
-      traverseQuery( from, callback, path ); // sub query in FROM
-  }
-}
-
-function forAllElements(artifact, artifactName, cb, includeActions = false){
-  if(artifact.elements) {
-    cb(artifact, artifact.elements, ['definitions', artifactName, 'elements']);
-  }
-
-  if(includeActions && artifact.actions) {
-    Object.entries(artifact.actions).forEach( ([actionName, action]) => {
-      const path = ['definitions', artifactName, 'actions', actionName];
-      if(action.params) {
-        Object.entries(action.params).forEach( ([paramName, param]) => {
-          if(param.elements)
-            cb(param, param.elements, path.concat(['params', paramName, 'elements']));
-        });
-      }
-      if(action.returns && action.returns.elements)
-        cb(action.returns, action.returns.elements,path.concat(['returns', 'elements']));
-    });
-  }
-
-  if(artifact.query) {
-    forAllQueries(artifact.query, (q, p) => {
-      const s = q.SELECT;
-      if(s) {
-        if(s.elements) {
-          cb(s, s.elements, [...p, 'elements']);
-        } else if(s.$elements) { // huh?, is just refloc output
-          cb(s, s.$elements, [...p, '$elements']);
-        }
-      }
-    }, ['definitions', artifactName, 'query'])
+      traverseQuery( from, callback, csnPath ); // sub query in FROM
   }
 }
 
@@ -925,48 +917,48 @@ function isEdmPropertyRendered(elementCsn, options) {
 
 /**
  * Return the resulting database name for (absolute) 'artifactName', depending on the current naming
- * convention.
+ * mode.
  *
- * - For the 'hdbcds' naming convention, this means converting '.' to '::' on
+ * - For the 'hdbcds' naming mode, this means converting '.' to '::' on
  *   the border between namespace and top-level artifact and correctly replacing some '.' with '_'.
- * - For the 'plain' naming convention, it means converting all '.' to '_' and uppercasing.
- * - For the 'quoted' naming convention, this means correctly replacing some '.' with '_'.
+ * - For the 'plain' naming mode, it means converting all '.' to '_' and upper-casing.
+ * - For the 'quoted' naming mode, this means correctly replacing some '.' with '_'.
  *
  * If the old function signature is used - with a namespace as the third argument - the result might be wrong,
  * since the '.' -> '_' conversion for quoted/hdbcds is missing.
  *
- * @param {string} artifactName The name of the artifact
- * @param {('plain'|'quoted'|'hdbcds')} namingConvention The naming convention to use
+ * @param {string} artifactName The fully qualified name of the artifact
+ * @param {('plain'|'quoted'|'hdbcds')} sqlMapping The naming mode to use
  * @param {CSN.Model|string|undefined} csn
- * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming convention.
+ * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming mode.
  */
-function getArtifactDatabaseNameOf(artifactName, namingConvention, csn) {
+function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn) {
   if(csn && typeof csn === 'object' && csn.definitions)
-    if (namingConvention === 'quoted' || namingConvention === 'hdbcds') {
-      return getResultingName(csn, namingConvention, artifactName);
+    if (sqlMapping === 'quoted' || sqlMapping === 'hdbcds') {
+      return getResultingName(csn, sqlMapping, artifactName);
     }
-    else if (namingConvention === 'plain') {
+    else if (sqlMapping === 'plain') {
       return artifactName.replace(/\./g, '_').toUpperCase();
     } else {
-      throw new Error('Unknown naming convention: ' + namingConvention);
+      throw new Error('Unknown naming mode: ' + sqlMapping);
     }
   else {
     console.error(`This invocation of "getArtifactCdsPersistenceName" is deprecated, as it doesn't produce correct output with definition names containing dots - please provide a CSN as the third parameter.`);
-    if (namingConvention === 'hdbcds') {
+    if (sqlMapping === 'hdbcds') {
       if (csn) {
         const namespace = String(csn);
         return `${namespace}::${artifactName.substring(namespace.length + 1)}`;
       }
       return artifactName;
     }
-    else if (namingConvention === 'plain') {
+    else if (sqlMapping === 'plain') {
       return artifactName.replace(/\./g, '_').toUpperCase();
     }
-    else if (namingConvention === 'quoted') {
+    else if (sqlMapping === 'quoted') {
       return artifactName;
     }
     else {
-      throw new Error('Unknown naming convention: ' + namingConvention);
+      throw new Error('Unknown naming mode: ' + sqlMapping);
     }
   }
 }
@@ -1034,7 +1026,7 @@ function getUnderscoredName(startIndex, parts, csn) {
 
       return result;
     } else if(art && art.kind === 'service') {
-      // inside services, we immediatly turn . into _
+      // inside services, we immediately turn . into _
       const prefix = parts.slice(0, i).join('.');
       const suffix = parts.slice(i).join('_');
       const result = [];
@@ -1052,29 +1044,29 @@ function getUnderscoredName(startIndex, parts, csn) {
 
 
 /**
- *  Return the resulting database element name for 'elemName', depending on the current naming
- *  convention.
- *  - For the 'hdbcds' naming convention, this is just 'elemName'.
- *  - For the 'plain' naming convention, it means converting all '.' to '_' and uppercasing.
- *  - For the 'quoted' naming convention, it means converting all '.' to '_'.
- *  No other naming conventions are accepted
+ *  Return the resulting database element name for 'elemName', depending on the current
+ *  naming mode.
+ *  - For the 'hdbcds' naming mode, this is just 'elemName'.
+ *  - For the 'plain' naming mode, it means converting all '.' to '_' and upper-casing.
+ *  - For the 'quoted' naming mode, it means converting all '.' to '_'.
+ *  No other naming modes are accepted!
  *
- * @param {string} elemName Name of the element
- * @param {('plain'|'quoted'|'hdbcds')} namingConvention The naming convention to use
- * @returns {string} The resulting database element name for 'elemName', depending on the current naming convention.
+ * @param {string} elemName The name of the element
+ * @param {('plain'|'quoted'|'hdbcds')} sqlMapping The naming mode to use
+ * @returns {string} The resulting database element name for 'elemName', depending on the current naming mode.
  */
-function getElementDatabaseNameOf(elemName, namingConvention) {
-  if (namingConvention === 'hdbcds') {
+function getElementDatabaseNameOf(elemName, sqlMapping) {
+  if (sqlMapping === 'hdbcds') {
     return elemName;
   }
-  else if (namingConvention === 'plain') {
+  else if (sqlMapping === 'plain') {
     return elemName.replace(/\./g, '_').toUpperCase();
   }
-  else if (namingConvention === 'quoted') {
+  else if (sqlMapping === 'quoted') {
     return elemName.replace(/\./g, '_');
   }
   else {
-    throw new Error('Unknown naming convention: ' + namingConvention);
+    throw new Error('Unknown naming mode: ' + sqlMapping);
   }
 }
 
@@ -1152,7 +1144,7 @@ function setDependencies( csn ) {
  * @returns {boolean}
  */
 function isPersistedOnDatabase(art) {
-  return !([ 'entity', 'view' ].includes(art.kind) && (art.abstract || hasAnnotationValue(art, '@cds.persistence.skip')));
+  return !('entity' === art.kind && (art.abstract || hasAnnotationValue(art, '@cds.persistence.skip')));
 }
 
 /**
@@ -1206,44 +1198,44 @@ function mergeOptions(...optionsObjects) {
 
   // Recursively used for scalars, too
   function mergeTwo(left, right, name) {
-    let result;
+    let intermediateResult;
     // Copy left as far as required
     if (Array.isArray(left)) {
       // Shallow-copy left array
-      result = left.slice();
+      intermediateResult = left.slice();
     } else if (isObject(left)) {
       // Deep-copy left object (unless empty)
-      result = Object.keys(left).length ? mergeTwo({}, left, name) : {};
+      intermediateResult = Object.keys(left).length ? mergeTwo({}, left, name) : {};
     } else {
       // Just use left scalar
-      result = left;
+      intermediateResult = left;
     }
     // Check against improper overwriting
     if (isObject(left) && !Array.isArray(left) && (Array.isArray(right) || isScalar(right))) {
-      throw new Error(`Cannot overwrite structured option "${name}" with array or scalar value`);
+      throw new ModelError(`Cannot overwrite structured option "${name}" with array or scalar value`);
     }
     if ((isScalar(left) && typeof left !== 'boolean' || Array.isArray(left)) && isObject(right) && !Array.isArray(right)) {
-      throw new Error(`Cannot overwrite non-boolean scalar or array option "${name}" with structured value`);
+      throw new ModelError(`Cannot overwrite non-boolean scalar or array option "${name}" with structured value`);
     }
 
     // Copy or overwrite properties from right to left
     if (Array.isArray(right)) {
       // Shallow-copy right array
-      result = right.slice();
+      intermediateResult = right.slice();
     } else if (isObject(right)) {
       // Object overwrites undefined, scalars and arrays
-      if (result === undefined || isScalar(result) || Array.isArray(result)) {
-        result = {};
+      if (intermediateResult === undefined || isScalar(intermediateResult) || Array.isArray(intermediateResult)) {
+        intermediateResult = {};
       }
       // Deep-copy right object into result
       for (let key of Object.keys(right)) {
-        result[key] = mergeTwo(result[key], right[key], `${name}.${key}`);
+        intermediateResult[key] = mergeTwo(intermediateResult[key], right[key], `${name}.${key}`);
       }
     } else {
       // Right scalar wins (unless undefined)
-      result = (right !== undefined) ? right : result;
+      intermediateResult = (right !== undefined) ? right : intermediateResult;
     }
-    return result;
+    return intermediateResult;
   }
 
   // Return true if 'o' is a non-null object or array
@@ -1331,19 +1323,73 @@ function getParentNamesOf(name) {
 }
 
 
-// Copy all annotations from 'fromNode' to 'toNode'. Overwrite existing ones only if 'overwrite' is true
-function copyAnnotations(fromNode, toNode, overwrite=false) {
+/**
+ * Copy all annotations from 'fromNode' to 'toNode'.
+ *
+ * Overwrite existing ones only if 'overwrite' is true.
+ *
+ * @param {object} fromNode
+ * @param {object} toNode
+ * @param {boolean} [overwrite]
+ */
+function copyAnnotations(fromNode, toNode, overwrite = false) {
+  // Ignore if no toNode (in case of errors)
+  if (!toNode)
+    return;
+
+  const annotations = Object.keys(fromNode).filter(key => key.startsWith('@'));
+
+  for (const anno of annotations) {
+    if (toNode[anno] === undefined || overwrite) {
+      toNode[anno] = fromNode[anno];
+    }
+  }
+}
+
+
+/**
+ * Same as `copyAnnotations()` but also copies the
+ * annotation-like property `doc`.
+ *
+ * Overwrite existing ones only if 'overwrite' is true.
+ *
+ * @param {object} fromNode
+ * @param {object} toNode
+ * @param {boolean} [overwrite]
+ */
+function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
   // Ignore if no toNode (in case of errors)
-  if (!toNode) {
+  if (!toNode)
     return;
+
+  const annotations = Object.keys(fromNode)
+    .filter(key => key.startsWith('@') || key === 'doc');
+
+  for (const anno of annotations) {
+    if (toNode[anno] === undefined || overwrite) {
+      toNode[anno] = fromNode[anno];
+    }
   }
-  for (let prop in fromNode) {
-    if (!Object.hasOwnProperty.call( fromNode, prop ))
-      continue;
-    if (prop.startsWith('@')) {
-      if (toNode[prop] === undefined || overwrite) {
-        toNode[prop] = fromNode[prop];
-      }
+}
+
+/**
+ * Applies annotations from `csn.extensions` to definitions, i.e. top-level artifacts.
+ * Does _not_ apply element/param/action/... annotations.
+ * `config.filter` can be used to only copy annotations for those definitions,
+ * for which the filter returns true.
+ *
+ * @param {CSN.Model} csn
+ * @param {{overwrite?: boolean, filter?: (name: string) => boolean}} config
+ */
+function applyDefinitionAnnotationsFromExtensions(csn, config) {
+  if (!csn.extensions)
+    return;
+
+  const filter = config.filter || ((_name) => true);
+  for (const ext of csn.extensions) {
+    const name = ext.annotate || ext.extend;
+    if (name && csn.definitions[name] && filter(name)) {
+      copyAnnotationsAndDoc(ext, csn.definitions[name], config.overwrite);
     }
   }
 }
@@ -1378,7 +1424,7 @@ function forEachPath(node, callback) {
  * @returns {boolean}
  */
 function hasValidSkipOrExists(artifact) {
-  return (artifact.kind === 'entity' || artifact.kind === 'view') &&
+  return artifact.kind === 'entity' &&
          (hasAnnotationValue(artifact, '@cds.persistence.exists', true) || hasAnnotationValue(artifact, '@cds.persistence.skip', true))
 
 }
@@ -1447,7 +1493,7 @@ function getServiceNames(csn) {
 }
 
 /**
- * Check wether the artifact is @cds.persistence.skip
+ * Check whether the artifact is @cds.persistence.skip
  *
  * @param {CSN.Artifact} artifact
  * @returns {Boolean}
@@ -1501,19 +1547,57 @@ function getVariableReplacement(ref, options) {
   }
 }
 
+/**
+ *
+ * @param {object} obj
+ * @param {*} other
+ * @param {boolean} noExtendedProps
+ * @returns {boolean} returns equality
+ *
+ * noExtendedProps remove '$', '_' and '@' properties from
+ * the comparison. This eliminates false negatives such as
+ *  mismatching $locations or @odata.foreignKey4.
+ */
+function isDeepEqual(obj, other, noExtendedProps) {
+  let objectKeys = Object.keys(obj);
+  let otherKeys = Object.keys(other);
+
+  if(noExtendedProps) {
+    objectKeys = objectKeys.filter(k => !['@', '$', '_'].includes(k[0]));
+    otherKeys = otherKeys.filter(k => !['@', '$', '_'].includes(k[0]));
+  }
+  if (objectKeys.length !== otherKeys.length)
+    return false;
+
+  for (let key of objectKeys) {
+    const areValuesObjects = (obj[key] != null && typeof obj[key] === 'object')
+      && (other[key] !== null && typeof other[key] === 'object');
+
+    if (areValuesObjects) {
+      if (!isDeepEqual(obj[key], other[key], noExtendedProps))
+        return false;
+    } else if (obj[key] !== other[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 module.exports = {
   getUtils,
-  cloneCsn,
+  cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
+  cloneCsnNonDict,
   cloneCsnDictionary,
   isBuiltinType,
   assignAll,
+  applyDefinitionAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,
   forEachMember,
+  forEachMemberWithQuery,
   forEachMemberRecursively,
-  forEachRef,
+  forEachMemberRecursivelyWithQuery,
   forAllQueries,
-  forAllElements,
   hasAnnotationValue,
   isEdmPropertyRendered,
   getArtifactDatabaseNameOf,
@@ -1533,6 +1617,7 @@ module.exports = {
   getParentNameOf,
   getLastPartOf,
   copyAnnotations,
+  copyAnnotationsAndDoc,
   isAspect,
   forEachPath,
   hasValidSkipOrExists,
@@ -1541,5 +1626,7 @@ module.exports = {
   getServiceNames,
   isSkipped,
   walkCsnPath,
-  getVariableReplacement
+  getVariableReplacement,
+  implicitAs,
+  isDeepEqual,
 };