@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/model/csnUtils.js

@@ -1,13 +1,17 @@
 'use strict';
 
 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 { typeParameters } = require("../compiler/builtins");
+const { applyTransformations, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary } = require('../transform/db/applyTransformations');
+const { isBuiltinType } = require('../compiler/builtins.js');
+const {
+  sortCsn,
+  cloneCsnDictionary: _cloneCsnDictionary,
+  cloneAnnotationValue: _cloneAnnotationValue,
+} = require('../json/to-csn');
+const { ModelError } = require('../base/error');
+const { typeParameters } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
-const version = require('../../package.json').version;
+const { version } = require('../../package.json');
 
 // Low-level utility functions to work with compact CSN.
 
@@ -87,7 +91,7 @@ function getUtils(model, universalReady) {
    * @param {boolean} [isSubquery]
    * @returns {object} Map of sources
    */
-  function getSources(query, isSubquery=false) {
+  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)
@@ -102,15 +106,15 @@ function getUtils(model, universalReady) {
       else if (query.SELECT.from.ref) {
         let art = artifactRef(query.SELECT.from);
 
-        if(art.target)
+        if (art.target)
           art = artifactRef(art.target);
 
-        if(isSubquery && !query.SELECT.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 );
+                                    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);
@@ -163,18 +167,17 @@ function getUtils(model, universalReady) {
    * @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
+   * @param {any} [errorParent] Parent name to use for error messages, ref before alias
    * @returns {object} existingMap
    */
-  function mergeElementsIntoMap(existingMap, elements, $location, parent, error_parent) {
+  function mergeElementsIntoMap(existingMap, elements, $location, parent, errorParent) {
     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,
+        element, name: elementName, source: $location, parent: getBaseName(parent), errorParent,
       });
     }
 
@@ -190,9 +193,9 @@ function getUtils(model, universalReady) {
       return name;
 
     if (name.id)
-      return name.id.substring( name.id.lastIndexOf('.')+1 );
+      return name.id.substring( name.id.lastIndexOf('.') + 1 );
 
-    return name.substring( name.lastIndexOf('.')+1 )
+    return name.substring( name.lastIndexOf('.') + 1 );
   }
 
   /**
@@ -202,17 +205,17 @@ function getUtils(model, universalReady) {
   function getQueryPrimarySource(query) {
     if (!query)
       return undefined;
-    else if (query.SELECT) {
+    else if (query.SELECT)
       return getQueryPrimarySource(query.SELECT);
-    } else if (query.SET) {
+    else if (query.SET)
       return getQueryPrimarySource(query.SET);
-    } else if (query.from) {
+    else if (query.from)
       return getQueryPrimarySource(query.from);
-    } else if (query.ref) {
+    else if (query.ref)
       return query;
-    } else if (query.args) {
+    else if (query.args)
       return getQueryPrimarySource(query.args[0]);
-    }
+
     return undefined;
   }
 
@@ -222,7 +225,7 @@ function getUtils(model, universalReady) {
    * @param {string} [initialId] Initial entry (optional)
    */
   function createVisited(initialId) {
-    let visited = Object.create(null);
+    const visited = Object.create(null);
     check(initialId);
     return { check };
 
@@ -232,10 +235,11 @@ function getUtils(model, universalReady) {
      * @param {string} id unique identifier
      */
     function check(id) {
-      if (!id) return;
-      if (visited[id]) {
+      if (!id)
+        return;
+      if (visited[id])
         throw new ModelError('Circular dependency');
-      }
+
       visited[id] = true;
     }
   }
@@ -246,9 +250,8 @@ function getUtils(model, universalReady) {
    */
   function getCsnDef(defName) {
     if (model.definitions[defName])
-      return model.definitions[defName]
-    else
-      throw new ModelError(`Nonexistent definition in the model: '${defName}'`);
+      return model.definitions[defName];
+    throw new ModelError(`Nonexistent definition in the model: '${ defName }'`);
   }
 
   /**
@@ -256,10 +259,10 @@ function getUtils(model, universalReady) {
    * or a typedef of a structured type.
    *
    * @param {object} obj
+   * @returns {boolean}
    */
   function isStructured(obj) {
-    return obj.elements ||
-      (obj.type && ((getFinalTypeDef(obj.type).elements) || (obj.type.ref && getFinalBaseTypeWithProps(obj.type)?.elements)));
+    return !!(obj.elements || (obj.type && getFinalBaseTypeWithProps(obj.type)?.elements));
   }
 
   /**
@@ -270,11 +273,11 @@ function getUtils(model, universalReady) {
    * @returns {object}
    */
   function getFinalTypeDef(typeName) {
-    let visited = createVisited(typeName);
+    const visited = createVisited(typeName);
     let type = model.definitions[typeName];
-    if (!type) {
+    if (!type)
       return typeName;
-    }
+
     for (let nextType = type; nextType;) {
       type = nextType;
       visited.check(type.type);
@@ -289,7 +292,7 @@ function getUtils(model, universalReady) {
    * @returns {string}
    */
   function getFinalType(typeName) {
-    let visited = createVisited(typeName);
+    const visited = createVisited(typeName);
     let type = model.definitions[typeName];
     while (type && type.type) {
       typeName = type.type;
@@ -313,7 +316,7 @@ function getUtils(model, universalReady) {
   function isAssocOrComposition(typeName) {
     if (typeName === 'cds.Association' || typeName === 'cds.Composition')
       return true;
-    let visited = createVisited(typeName);
+    const visited = createVisited(typeName);
     let type = model.definitions[typeName];
     while (type) {
       if (type.type === 'cds.Association' || type.type === 'cds.Composition')
@@ -331,7 +334,7 @@ function getUtils(model, universalReady) {
   function isAssociation(typeName) {
     if (typeName === 'cds.Association')
       return true;
-    let visited = createVisited(typeName);
+    const visited = createVisited(typeName);
     let type = model.definitions[typeName];
     while (type) {
       if (type.type === 'cds.Association')
@@ -349,7 +352,7 @@ function getUtils(model, universalReady) {
   function isComposition(typeName) {
     if (typeName === 'cds.Composition')
       return true;
-    let visited = createVisited(typeName);
+    const visited = createVisited(typeName);
     let type = model.definitions[typeName];
     while (type) {
       if (type.type === 'cds.Composition')
@@ -366,12 +369,14 @@ function getUtils(model, universalReady) {
    */
   function getNamespaceOfArtifact(name) {
     let lastDotIdx = name.lastIndexOf('.');
-    if (lastDotIdx === -1) return undefined;
+    if (lastDotIdx === -1)
+      return undefined;
     while (model.definitions[name]) {
       if (model.definitions[name].kind === 'namespace')
         return name;
       lastDotIdx = name.lastIndexOf('.');
-      if (lastDotIdx === -1) return undefined;
+      if (lastDotIdx === -1)
+        return undefined;
       name = name.substring(0, lastDotIdx);
     }
     return name;
@@ -387,7 +392,8 @@ function getUtils(model, universalReady) {
       if (model.definitions[name].kind === 'context' || model.definitions[name].kind === 'service')
         return name;
       lastDotIdx = name.lastIndexOf('.');
-      if (lastDotIdx === -1) return undefined;
+      if (lastDotIdx === -1)
+        return undefined;
       name = name.substring(0, lastDotIdx);
     }
     return undefined;
@@ -402,11 +408,11 @@ function getUtils(model, universalReady) {
    */
   function addStringAnnotationTo(absoluteName, theValue, node) {
     // Sanity check
-    if (!absoluteName.startsWith('@')) {
-      throw Error('Annotation name should start with "@": ' + absoluteName);
-    }
+    if (!absoluteName.startsWith('@'))
+      throw Error(`Annotation name should start with "@": ${ absoluteName }`);
+
     // Only overwrite if undefined or null
-    if(node[absoluteName] === undefined || node[absoluteName] === null) {
+    if (node[absoluteName] === undefined || node[absoluteName] === null) {
       // Assemble the annotation
       node[absoluteName] = theValue;
     }
@@ -420,14 +426,14 @@ function getUtils(model, universalReady) {
    * @returns {string|null}
    */
   function getServiceName(artifactName) {
-    for(;;) {
-      let idx = artifactName.lastIndexOf('.');
-      if (idx === -1) return null;
+    for (;;) {
+      const idx = artifactName.lastIndexOf('.');
+      if (idx === -1)
+        return null;
       artifactName = artifactName.substring(0, idx);
-      let artifact = model.definitions[artifactName];
-      if (artifact && artifact.kind === 'service') {
+      const artifact = model.definitions[artifactName];
+      if (artifact && artifact.kind === 'service')
         return artifactName;
-      }
     }
   }
 
@@ -450,35 +456,33 @@ function getUtils(model, universalReady) {
    * @returns {object}
    */
   function cloneWithTransformations(rootNode, transformers) {
-
     return transformNode(rootNode);
 
-  // This general transformation function will be applied to each node recursively
+    // This general transformation function will be applied to each node recursively
     function transformNode(node) {
     // Return primitive values and null unchanged, but let objects and dictionaries through
     // (Note that 'node instanceof Object' would be false for dictionaries).
-      if (node === null || typeof node !== 'object') {
-        return node
-      }
-    // Simply return if node is to be ignored
-      if (node == undefined || node._ignore)
+      if (node === null || typeof node !== 'object')
+        return node;
+
+      // Simply return if node is to be ignored
+      if (node === undefined || node._ignore)
         return undefined;
-    // Transform arrays element-wise
-      if (Array.isArray(node)) {
+      // Transform arrays element-wise
+      if (Array.isArray(node))
         return node.map(transformNode);
-      }
-    // Things not having 'proto' are dictionaries
-      let proto = Object.getPrototypeOf(node);
-    // Iterate own properties of 'node' and transform them into 'resultNode'
-      let resultNode = Object.create(proto);
-      for (let key of Object.keys(node)) {
+
+      // Things not having 'proto' are dictionaries
+      const proto = Object.getPrototypeOf(node);
+      // Iterate own properties of 'node' and transform them into 'resultNode'
+      const resultNode = Object.create(proto);
+      for (const key of Object.keys(node)) {
       // Dictionary always use transformNode(), other objects their transformer according to key
-        let transformer = (proto == undefined) ? transformNode : transformers[key] || transformers[key.charAt(0)];
-      // Apply transformer, or use transformNode() if there is none
-        let resultValue = (transformer || transformNode)(node[key], node, resultNode, key);
-        if (resultValue !== undefined) {
+        const transformer = (proto === null || proto === undefined) ? transformNode : transformers[key] || transformers[key.charAt(0)];
+        // Apply transformer, or use transformNode() if there is none
+        const resultValue = (transformer || transformNode)(node[key], node, resultNode, key);
+        if (resultValue !== undefined)
           resultNode[key] = resultValue;
-        }
       }
       return resultNode;
     }
@@ -514,21 +518,21 @@ function getUtils(model, universalReady) {
       return null;
 
     // Nothing to copy from builtin type name.
-    if (typeof type === 'string' && isBuiltinType( type )) {
+    if (typeof type === 'string' && isBuiltinType( type ))
       return { type };
-    }
+
 
     // We differentiate between ref and type to avoid collisions due to dict key.
     // Delimiter chosen arbitrarily; just one that is rarely used.
-    const resolvedKey = (typeof type === 'object') ? `ref[${type.ref.length}]:${type.ref.join('\\')}` : `type:${type}`;
+    const resolvedKey = (typeof type === 'object') ? `ref[${ type.ref.length }]:${ type.ref.join('\\') }` : `type:${ type }`;
 
     if (finalBaseTypeCache[resolvedKey]) {
       if (finalBaseTypeCache[resolvedKey] === true)
-        throw new ModelError(`Detected circular type reference; can't resolve: ${resolvedKey}`);
+        throw new ModelError(`Detected circular type reference; can't resolve: ${ resolvedKey }`);
       return finalBaseTypeCache[resolvedKey];
     }
 
-    let typeRef = artifactRef(type); // throws if not found
+    const typeRef = artifactRef(type); // throws if not found
     const isNonScalar = _cacheNonScalar(typeRef);
     if (isNonScalar)
       return finalBaseTypeCache[resolvedKey];
@@ -597,9 +601,8 @@ function getUtils(model, universalReady) {
       target.type = source.type;
       const typeProps = [ ...typeParameters.list, 'enum', 'default', 'localized' ];
       for (const param of typeProps) {
-        if (target[param] === undefined && source[param] !== undefined) {
+        if (target[param] === undefined && source[param] !== undefined)
           target[param] = source[param];
-        }
       }
       return target;
     }
@@ -609,7 +612,12 @@ function getUtils(model, universalReady) {
 /**
  * Deeply clone the given CSN model and return it.
  * In testMode (or with testSortCsn), definitions are sorted.
- * Note that annotations are only copied shallowly.
+ *
+ * This function is CSN aware! Don't put annotation values into it, or
+ * keys such as "elements" will be interpreted according to CSN rules!
+ *
+ * @see cloneAnnotationValue
+ * @see cloneCsnDictionary
  *
  * @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`
@@ -620,18 +628,34 @@ function cloneCsnNonDict(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 cloneCsnNonDict() if you want sorted definitions.
  *
+ * This function is CSN aware! Don't put annotation values into it, or
+ * keys such as "elements" will be interpreted according to CSN rules!
+ *
+ * @see cloneAnnotationValue
+ * @see cloneCsnNonDict
+ *
  * @param {object} csn
  * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
- *                              used and cloneOptions are passed to sort().
+ *                              used and cloneOptions are passed to sortCsn().
  */
 function cloneCsnDictionary(csn, options) {
   return _cloneCsnDictionary(csn, options);
 }
 
+/**
+ * Clones the given annotation _value_.  `value` must not be an object with annotations,
+ * but the annotation value itself, e.g. `[ { a: 1 } ]`, not `@anno: [...]`.
+ *
+ * @param {any} value
+ * @returns {any}
+ */
+function cloneAnnotationValue(value) {
+  return _cloneAnnotationValue( value );
+}
+
 /**
  * Apply function `callback` to all artifacts in dictionary
  * `model.definitions`.  See function `forEachGeneric` for details.
@@ -660,28 +684,28 @@ function forEachDefinition( csn, callback, iterateOptions = {} ) {
  * @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) {
+  if (ignoreIgnore && construct._ignore)
     return;
-  }
+
 
   // `items` itself is a structure that can contain "elements", and more.
-  if (construct.items) {
-    forEachMember( construct.items, callback, [...path, 'items'], ignoreIgnore, iterateOptions, constructCallback );
-  }
+  if (construct.items)
+    forEachMember( construct.items, callback, [ ...path, 'items' ], ignoreIgnore, iterateOptions, constructCallback );
+
 
   // Unlike XSN, we don't make "returns" a "params" in the callback.
   // Backends rely on the fact that `forEachElement` also goes through all
   // `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, constructCallback );
-  }
+  if (construct.returns && !iterateOptions.elementsOnly)
+    forEachMember( construct.returns, callback, [ ...path, 'returns' ], ignoreIgnore, iterateOptions, constructCallback );
 
-  path = [...path]; // Copy
-  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'actions', 'params']);
+
+  path = [ ...path ]; // Copy
+  const propsWithMembers = (iterateOptions.elementsOnly ? [ 'elements' ] : [ 'elements', 'enum', 'actions', 'params' ]);
   propsWithMembers.forEach((prop) => {
     forEachGeneric( construct, prop, callback, path, iterateOptions );
     if (construct[prop]) {
@@ -703,15 +727,14 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
  * @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) => {}) {
+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) {
+      if (s)
         forEachMember(s, callback, p, ignoreIgnore, iterateOptions);
-      }
     }, [ ...path, 'query' ]);
   }
 }
@@ -727,10 +750,10 @@ function forEachMemberWithQuery( construct, callback, path=[], ignoreIgnore=true
  * @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 = {},
+function forEachMemberRecursively( construct, callback, path = [], ignoreIgnore = true, iterateOptions = {},
                                    constructCallback = (_construct, _prop, _path) => {}) {
   forEachMember( construct, ( member, memberName, prop, subpath, parent ) => {
-    if(Array.isArray(callback))
+    if (Array.isArray(callback))
       callback.forEach(cb => cb( member, memberName, prop, subpath, parent ));
     else
       callback( member, memberName, prop, subpath, parent );
@@ -751,15 +774,14 @@ function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=tr
  * @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) => {}) {
+function forEachMemberRecursivelyWithQuery( construct, callback, path = [], ignoreIgnore = true, iterateOptions = {},
+                                            constructCallback = (_construct, _prop, _path) => {}) {
   forEachMemberRecursively(construct, callback, path, ignoreIgnore, iterateOptions, constructCallback);
-  if(construct.query) {
+  if (construct.query) {
     forAllQueries(construct.query, (q, p) => {
       const s = q.SELECT;
-      if(s) {
+      if (s)
         forEachMemberRecursively(s, callback, p, ignoreIgnore, iterateOptions);
-      }
     }, [ ...path, 'query' ]);
   }
 }
@@ -782,9 +804,9 @@ function forEachGeneric( construct, prop, callback, path = [], iterateOptions =
     if (!Object.prototype.hasOwnProperty.call(dict, name))
       continue;
     const dictObj = dict[name];
-    if((iterateOptions.skip && iterateOptions.skip.includes(dictObj.kind))
-       || (iterateOptions.skipArtifact && typeof iterateOptions.skipArtifact === 'function'
-           && iterateOptions.skipArtifact(dictObj, name)))
+    if ((iterateOptions.skip && iterateOptions.skip.includes(dictObj.kind)) ||
+       (iterateOptions.skipArtifact && typeof iterateOptions.skipArtifact === 'function' &&
+           iterateOptions.skipArtifact(dictObj, name)))
       continue;
     executeCallbacks( dictObj, name );
   }
@@ -794,7 +816,7 @@ function forEachGeneric( construct, prop, callback, path = [], iterateOptions =
     if (Array.isArray(callback))
       callback.forEach(cb => cb( o, name, prop, path.concat(p), construct ));
     else
-      callback( o, name, prop, path.concat(p), construct )
+      callback( o, name, prop, path.concat(p), construct );
   }
 }
 
@@ -803,13 +825,13 @@ function forEachGeneric( construct, prop, callback, path = [], iterateOptions =
  * @param {queryCallback|queryCallback[]} queryCallback
  * @param {CSN.Path} path
  */
-function forAllQueries(mainQuery, queryCallback, path = []){
+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'))
+      if (!(path.length === 3 && path[2] === 'projection'))
         queryPath.push('SELECT');
       executeCallbacks();
       query = query.SELECT;
@@ -821,25 +843,24 @@ function forAllQueries(mainQuery, queryCallback, path = []){
     }
 
     if (query.from)
-      traverseFrom( query.from, callback, queryPath.concat(['from']) );
+      traverseFrom( query.from, callback, queryPath.concat([ 'from' ]) );
 
-    for (const prop of ['args', 'xpr', 'columns', 'where', 'having']) {
+    for (const prop of [ 'args', 'xpr', 'columns', 'where', 'having' ]) {
       // all properties which could have sub queries (directly or indirectly)
       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, queryPath.concat([prop, i]));
-          }
-        } else {
-          for(const argName of Object.keys( expr )){
-            traverseQuery(expr[argName], callback, queryPath.concat([prop, argName]))
-          }
+        if (Array.isArray(expr)) {
+          for (let i = 0; i < expr.length; i++)
+            traverseQuery(expr[i], callback, queryPath.concat([ prop, i ]));
+        }
+        else {
+          for (const argName of Object.keys( expr ))
+            traverseQuery(expr[argName], callback, queryPath.concat([ prop, argName ]));
         }
       }
     }
     function executeCallbacks() {
-      if(Array.isArray(callback))
+      if (Array.isArray(callback))
         callback.forEach(cb => cb( query, queryPath ));
       else
         callback( query, queryPath );
@@ -852,15 +873,16 @@ function forAllQueries(mainQuery, queryCallback, path = []){
    * @param {CSN.Path} csnPath
    */
   function traverseFrom( from, callback, csnPath = [] ) {
-    if (from.ref) // ignore
+    if (from.ref) { // ignore
       return;
-    else if (from.args){ // join
-      for(let i = 0; i < from.args.length; i++){
-        traverseFrom(from.args[i], callback, csnPath.concat(['args', i]));
-      }
     }
-    else
-      traverseQuery( from, callback, csnPath ); // sub query in FROM
+    else if (from.args) { // join
+      for (let i = 0; i < from.args.length; i++)
+        traverseFrom(from.args[i], callback, csnPath.concat([ 'args', i ]));
+    }
+    else {
+      traverseQuery( from, callback, csnPath );
+    } // sub query in FROM
   }
 }
 
@@ -886,12 +908,11 @@ function forAllQueries(mainQuery, queryCallback, path = []){
  * @returns {boolean}
  */
 function hasAnnotationValue(artifact, annotationName, expected = true, caseInsensitive = false) {
-  if(expected === false)
+  if (expected === false)
     return artifact[annotationName] === expected || artifact[annotationName] === null;
   else if (typeof artifact[annotationName] === 'string' && caseInsensitive === true)
     return artifact[annotationName].toLowerCase() === expected.toLowerCase();
-  else
-    return artifact[annotationName] === expected;
+  return artifact[annotationName] === expected;
 }
 
 /**
@@ -910,11 +931,11 @@ function isEdmPropertyRendered(elementCsn, options) {
   // V4 struct: on/off
   const renderForeignKey = (options.odataVersion === 'v4' && options.odataFormat === 'structured') ? !!options.odataForeignKeys : true;
   const isNotIgnored = !elementCsn.target ? !elementCsn['@cds.api.ignore'] : true;
-  const isNavigable = elementCsn.target ?
-    (elementCsn['@odata.navigable'] === undefined ||
+  const isNavigable = elementCsn.target
+    ? (elementCsn['@odata.navigable'] === undefined ||
      elementCsn['@odata.navigable'] !== undefined && (elementCsn['@odata.navigable'] === null || elementCsn['@odata.navigable'] === true)) : true;
   // Foreign Keys can be ignored
-  if(elementCsn['@odata.foreignKey4'])
+  if (elementCsn['@odata.foreignKey4'])
     return isNotIgnored && renderForeignKey;
   // ordinary elements can be ignored and isNavigable is always true for them
   // assocs cannot be ignored but not navigable
@@ -941,18 +962,18 @@ function isEdmPropertyRendered(elementCsn, options) {
  * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming mode.
  */
 // eslint-disable-next-line no-unused-vars
-function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn, sqlDialect='plain') {
-  if(csn && typeof csn === 'object' && csn.definitions) {
-    isValidMappingDialectCombi(sqlDialect, sqlMapping)
-    if (sqlMapping === 'quoted' || sqlMapping === 'hdbcds') {
+function getArtifactDatabaseNameOf(artifactName, sqlMapping, csn, sqlDialect = 'plain') {
+  if (csn && typeof csn === 'object' && csn.definitions) {
+    isValidMappingDialectCombi(sqlDialect, sqlMapping);
+    if (sqlMapping === 'quoted' || sqlMapping === 'hdbcds')
       return getResultingName(csn, sqlMapping, artifactName);
-    }
-    else if (sqlMapping === 'plain') {
+
+    else if (sqlMapping === 'plain')
       return artifactName.replace(/\./g, '_').toUpperCase();
-    } else {
-      throw new Error('Unknown naming mode: ' + sqlMapping);
-    }
-  } else {
+
+    throw new Error(`Unknown naming mode: ${ sqlMapping }`);
+  }
+  else {
     throw new Error('A valid CSN model is required to correctly calculate the database name of an artifact.');
   }
 }
@@ -988,7 +1009,7 @@ function getResultingName(csn, namingMode, artifactName) {
   const name = realParts ? realParts.join('.') : artifactName;
 
 
-  return (namespace && namingMode === 'hdbcds') ? `${namespace}::${name.slice(namespace.length + 1)}` : name;
+  return (namespace && namingMode === 'hdbcds') ? `${ namespace }::${ name.slice(namespace.length + 1) }` : name;
 }
 
 
@@ -1019,7 +1040,8 @@ function getUnderscoredName(startIndex, parts, csn) {
         result.push(suffix);
 
       return result;
-    } else if(art && art.kind === 'service') {
+    }
+    else if (art && art.kind === 'service') {
       // inside services, we immediately turn . into _
       const prefix = parts.slice(0, i).join('.');
       const suffix = parts.slice(i).join('_');
@@ -1037,8 +1059,8 @@ function getUnderscoredName(startIndex, parts, csn) {
 }
 
 function isValidMappingDialectCombi(sqlDialect, sqlMapping) {
-  if(sqlMapping === 'hdbcds' && sqlDialect !== 'hana')
-    throw new Error(`sqlMapping "hdbcds" must only be used with sqlDialect "hana" - found: ${sqlDialect}`);
+  if (sqlMapping === 'hdbcds' && sqlDialect !== 'hana')
+    throw new Error(`sqlMapping "hdbcds" must only be used with sqlDialect "hana" - found: ${ sqlDialect }`);
   return true;
 }
 
@@ -1060,20 +1082,18 @@ function isValidMappingDialectCombi(sqlDialect, sqlMapping) {
  * @returns {string} The resulting database element name for 'elemName', depending on the current naming mode.
  */
 // eslint-disable-next-line no-unused-vars
-function getElementDatabaseNameOf(elemName, sqlMapping, sqlDialect='plain') {
-  isValidMappingDialectCombi(sqlDialect, sqlMapping)
-  if (sqlMapping === 'hdbcds') {
+function getElementDatabaseNameOf(elemName, sqlMapping, sqlDialect = 'plain') {
+  isValidMappingDialectCombi(sqlDialect, sqlMapping);
+  if (sqlMapping === 'hdbcds')
     return elemName;
-  }
-  else if (sqlMapping === 'plain') {
+
+  else if (sqlMapping === 'plain')
     return elemName.replace(/\./g, '_').toUpperCase();
-  }
-  else if (sqlMapping === 'quoted') {
+
+  else if (sqlMapping === 'quoted')
     return elemName.replace(/\./g, '_');
-  }
-  else {
-    throw new Error('Unknown naming mode: ' + sqlMapping);
-  }
+
+  throw new Error(`Unknown naming mode: ${ sqlMapping }`);
 }
 
 const _dependencies = Symbol('_dependencies');
@@ -1086,38 +1106,40 @@ const _dependents = Symbol('_dependents');
  * _dependents: All artifacts that depend on this artifact (because they have a ref that points to it)
  * _dependencies: All artifacts this artifact depends on (because it has a ref to it)
  *
- * @param {object} csn A CSN to enrich in-place
+ * @param {CSN.Model} csn A CSN to enrich in-place
+ * @param {object} refs csnRefs, only used for artifactRef
  * @returns {object} CSN with _dependents/_dependencies set, "cleanup" function, _dependents/_dependencies Symbol used
  */
-function setDependencies( csn ) {
+function setDependencies( csn, refs = csnRefs(csn) ) {
   const cleanup = [];
-  const { artifactRef } = csnRefs(csn);
+  const { artifactRef } = refs;
 
   forEachDefinition(csn, (artifact, artifactName) => {
-    if(getNormalizedQuery(artifact).query) {
+    const queries = getNormalizedQuery(artifact).query;
+    if (queries) {
       initDependencies(artifact);
-      forAllQueries(getNormalizedQuery(artifact).query, (query) => {
-        if(query.SELECT && query.SELECT.from) {
-          if(query.SELECT.from.args) {
+      forAllQueries(queries, (query) => {
+        if (query.SELECT?.from) {
+          if (query.SELECT.from.args)
             handleArgs(artifact, artifactName, query.SELECT.from.args);
-          } else {
-            if(typeof query.SELECT.from === 'string' || query.SELECT.from.ref )
-              handleDependency(artifactRef(query.SELECT.from), artifact, artifactName);
-          }
+
+          else if (typeof query.SELECT.from === 'string' || query.SELECT.from.ref)
+            handleDependency(artifactRef(query.SELECT.from), artifact, artifactName);
         }
-      },  ['definitions', artifactName, (artifact.projection ? 'projection' : 'query')])
+      }, [ 'definitions', artifactName, (artifact.projection ? 'projection' : 'query') ]);
     }
-  })
+  });
 
-  return {cleanup, csn, _dependents, _dependencies};
+  return {
+    cleanup, csn, _dependents, _dependencies,
+  };
 
-  function handleArgs(artifact, artifactName, args){
-    for(let arg of args){
-      if (arg.args) {
+  function handleArgs(artifact, artifactName, args) {
+    for (const arg of args) {
+      if (arg.args)
         handleArgs(artifact, artifactName, arg.args);
-      } else if (arg.ref) {
-        handleDependency(artifactRef(arg), artifact, artifactName)
-      }
+      else if (arg.ref)
+        handleDependency(artifactRef(arg), artifact, artifactName);
     }
   }
 
@@ -1127,15 +1149,15 @@ function setDependencies( csn ) {
     dependency[_dependents][dependantName] = dependant;
   }
 
-  function initDependents(obj){
-    if(!obj[_dependents]) {
+  function initDependents(obj) {
+    if (!obj[_dependents]) {
       obj[_dependents] = Object.create(null);
       cleanup.push(() => delete obj[_dependents]);
     }
   }
 
-  function initDependencies(obj){
-    if(!obj[_dependencies]) {
+  function initDependencies(obj) {
+    if (!obj[_dependencies]) {
       obj[_dependencies] = new Set();
       cleanup.push(() => delete obj[_dependencies]);
     }
@@ -1150,7 +1172,35 @@ function setDependencies( csn ) {
  * @returns {boolean}
  */
 function isPersistedOnDatabase(art) {
-  return !('entity' === art.kind && (art.abstract || hasAnnotationValue(art, '@cds.persistence.skip')));
+  return !(art.kind === 'entity' && (art.abstract || hasAnnotationValue(art, '@cds.persistence.skip')));
+}
+/**
+ * Check if the given artifact will be persisted on the database via `CREATE VIEW`
+ *
+ * @param {CSN.Artifact} artifact
+ * @returns {boolean}
+ */
+function isPersistedAsView(artifact) {
+  return artifact && artifact.kind === 'entity' &&
+      !artifact._ignore &&
+      !artifact.abstract &&
+      ((artifact.query || artifact.projection) && !hasAnnotationValue(artifact, '@cds.persistence.table')) &&
+      !hasAnnotationValue(artifact, '@cds.persistence.skip') &&
+      !hasAnnotationValue(artifact, '@cds.persistence.exists');
+}
+/**
+ * Check if the given artifact will be persisted on the database via `CREATE TABLE`
+ *
+ * @param {CSN.Artifact} artifact
+ * @returns {boolean}
+ */
+function isPersistedAsTable(artifact) {
+  return artifact.kind === 'entity' &&
+      !artifact._ignore &&
+      !artifact.abstract &&
+      (!artifact.query && !artifact.projection || hasAnnotationValue(artifact, '@cds.persistence.table')) &&
+      !hasAnnotationValue(artifact, '@cds.persistence.skip') &&
+      !hasAnnotationValue(artifact, '@cds.persistence.exists');
 }
 
 /**
@@ -1160,7 +1210,7 @@ function isPersistedOnDatabase(art) {
  * @returns {string} String containing compiler version that was used to generate content
  */
 function generatedByCompilerVersion() {
-  return `generated by cds-compiler version ${version}`;
+  return `generated by cds-compiler version ${ version }`;
 }
 
 /**
@@ -1170,9 +1220,9 @@ function generatedByCompilerVersion() {
  * @returns {object} Object with a query property.
  */
 function getNormalizedQuery(art) {
-  if (art.projection) {
+  if (art.projection)
     return { query: { SELECT: art.projection } };
-  }
+
   return art;
 }
 
@@ -1196,14 +1246,14 @@ function getRootArtifactName(artifactName, csn) {
     if (seen === '')
       seen = parts[i];
     else
-        seen = `${seen}.${parts[i]}`;
+      seen = `${ seen }.${ parts[i] }`;
 
     const art = csn.definitions[seen];
-      // Our artifact seems to be contained in this context
+    // Our artifact seems to be contained in this context
     if (art && (art.kind === 'context' || art.kind === 'service'))
       return seen;
   }
-    // Our artifact is a root artifact itself
+  // Our artifact is a root artifact itself
   return seen;
 }
 
@@ -1223,7 +1273,7 @@ function getLastPartOf(name) {
 //   ['foo'] => 'foo';
 //   ['foo::bar'] => 'bar'
 function getLastPartOfRef(ref) {
-  let lastPathStep = ref[ref.length - 1];
+  const lastPathStep = ref[ref.length - 1];
   return getLastPartOf(lastPathStep.id || lastPathStep);
 }
 
@@ -1244,9 +1294,8 @@ function copyAnnotations(fromNode, toNode, overwrite = false) {
   const annotations = Object.keys(fromNode).filter(key => key.startsWith('@'));
 
   for (const anno of annotations) {
-    if (toNode[anno] === undefined || overwrite) {
+    if (toNode[anno] === undefined || overwrite)
       toNode[anno] = fromNode[anno];
-    }
   }
 }
 
@@ -1270,9 +1319,8 @@ function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
     .filter(key => key.startsWith('@') || key === 'doc');
 
   for (const anno of annotations) {
-    if (toNode[anno] === undefined || overwrite) {
+    if (toNode[anno] === undefined || overwrite)
       toNode[anno] = fromNode[anno];
-    }
   }
 }
 
@@ -1296,7 +1344,7 @@ function applyAnnotationsFromExtensions(csn, config) {
   if (!csn.extensions)
     return;
 
-  const filter = config.filter || ((_name) => true);
+  const filter = config.filter || (_name => true);
   for (let i = 0; i < csn.extensions.length; ++i) {
     const ext = csn.extensions[i];
     const name = ext.annotate || ext.extend;
@@ -1305,7 +1353,8 @@ function applyAnnotationsFromExtensions(csn, config) {
       if (def) {
         copyAnnotationsAndDoc(ext, def, config.override);
         applyAnnotationsToElements(ext, def);
-      } else if (config.notFound) {
+      }
+      else if (config.notFound) {
         config.notFound(name, i);
       }
     }
@@ -1343,8 +1392,7 @@ function isAspect(node) {
  */
 function hasValidSkipOrExists(artifact) {
   return artifact.kind === 'entity' &&
-         (hasAnnotationValue(artifact, '@cds.persistence.exists', true) || hasAnnotationValue(artifact, '@cds.persistence.skip', true))
-
+         (hasAnnotationValue(artifact, '@cds.persistence.exists', true) || hasAnnotationValue(artifact, '@cds.persistence.skip', true));
 }
 
 /**
@@ -1368,7 +1416,7 @@ function getNamespace(csn, artifactName) {
   for (let i = 1; i < parts.length; i++) {
     // This was definitely a namespace so far
     const previousArtifactName = seen;
-    seen = `${seen}.${parts[i]}`;
+    seen = `${ seen }.${ parts[i] }`;
     // This might not be - if it isn't, return the result.
     const currentArtifact = csn.definitions[seen];
     if (currentArtifact && currentArtifact.kind !== 'namespace')
@@ -1385,7 +1433,7 @@ function getNamespace(csn, artifactName) {
  * @param {CSN.Options} options
  */
 function sortCsnDefinitionsForTests(csn, options) {
-  if (!options.testMode)
+  if (!options.testMode && !options.testSortCsn)
     return;
   const sorted = Object.create(null);
   Object.keys(csn.definitions || {}).sort().forEach((name) => {
@@ -1401,11 +1449,10 @@ function sortCsnDefinitionsForTests(csn, options) {
  * @returns {string[]}
  */
 function getServiceNames(csn) {
-  let result = [];
+  const result = [];
   forEachDefinition(csn, (artifact, artifactName) => {
-    if (artifact.kind === 'service' && !artifact.abstract) {
+    if (artifact.kind === 'service' && !artifact.abstract)
       result.push(artifactName);
-    }
   });
   return result;
 }
@@ -1420,9 +1467,9 @@ function getServiceNames(csn) {
 function walkCsnPath(csn, path) {
   /** @type {object} */
   let obj = csn;
-  for(const segment of path){
+  for (const segment of path)
     obj = obj[segment];
-  }
+
 
   return obj;
 }
@@ -1436,23 +1483,21 @@ function walkCsnPath(csn, path) {
  * @returns {string|null}
  */
 function getVariableReplacement(ref, options) {
-  if(options && options.variableReplacements) {
+  if (options && options.variableReplacements) {
     let replacement = options.variableReplacements;
-    for(const segment of ref) {
+    for (const segment of ref) {
       replacement = replacement[segment];
-      if(replacement === undefined)
+      if (replacement === undefined)
         return null;
     }
 
-    if(replacement === undefined)
+    if (replacement === undefined)
       return null; // no valid replacement found
-    else if(typeof replacement === 'string')
+    else if (typeof replacement === 'string')
       return replacement; // valid replacement
-    else
-      return null; // $user.foo, but we only have configured $user.foo.bar -> error
-  } else {
-    return null;
+    return null; // $user.foo, but we only have configured $user.foo.bar -> error
   }
+  return null;
 }
 
 /**
@@ -1470,21 +1515,22 @@ 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 (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');
+  for (const 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]) {
+    }
+    else if (obj[key] !== other[key]) {
       return false;
     }
   }
@@ -1496,6 +1542,7 @@ module.exports = {
   cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
   cloneCsnNonDict,
   cloneCsnDictionary,
+  cloneAnnotationValue,
   isBuiltinType,
   applyAnnotationsFromExtensions,
   forEachGeneric,
@@ -1513,8 +1560,11 @@ module.exports = {
   getElementDatabaseNameOf,
   applyTransformations,
   applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
   setDependencies,
   isPersistedOnDatabase,
+  isPersistedAsView,
+  isPersistedAsTable,
   generatedByCompilerVersion,
   getNormalizedQuery,
   getRootArtifactName,