@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/model/csnUtils.js

@@ -1,9 +1,10 @@
 'use strict';
 
-const { setProp } = require('../base/model');
-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,
@@ -61,6 +62,11 @@ function getUtils(model) {
     effectiveType,
     get$combined,
     getOrigin,
+    getQueryPrimarySource,
+    targetAspect,
+    getColumn,
+    getElement,
+    initDefinition
   };
 
   /**
@@ -70,135 +76,156 @@ 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 );
+      }
+      else if (query.SELECT.from.SET || query.SELECT.from.SELECT) {
+        return getSources(query.SELECT.from, true);
       }
+    }
 
-      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 {};
+  }
 
-        return elements;
+  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 {};
-
-      /**
-       * 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 elements;
+  }
 
-        return mapA;
-      }
+  /**
+   * 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] = [];
 
-      /**
-       * 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,
-          });
-        }
+      mapB[elementName].forEach(e => mapA[elementName].push(e));
+    }
 
-        return existingMap;
-      }
+    return mapA;
+  }
+
+  /**
+   * 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 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;
+  function getBaseName(name) {
+    if (!name)
+      return name;
 
-      if (name.id)
-        return name.id.substring( name.id.lastIndexOf('.')+1 );
+    if (name.id)
+      return name.id.substring( name.id.lastIndexOf('.')+1 );
+
+    return name.substring( name.lastIndexOf('.')+1 )
+  }
 
-      return name.substring( name.lastIndexOf('.')+1 )
+  /**
+   * Return the left-most, primary source of the given query.
+   * @param {*} query Definition's query object
+   */
+  function getQueryPrimarySource(query) {
+    if (!query)
+      return undefined;
+    else if (query.SELECT) {
+      return getQueryPrimarySource(query.SELECT);
+    } else if (query.SET) {
+      return getQueryPrimarySource(query.SET);
+    } else if (query.from) {
+      return getQueryPrimarySource(query.from);
+    } else if (query.ref) {
+      return query;
+    } else if (query.args) {
+      return getQueryPrimarySource(query.args[0]);
     }
+    return undefined;
   }
 
 
   /**
    * 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 };
 
     /**
@@ -209,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;
     }
@@ -223,14 +250,14 @@ 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}'`);
   }
 
   /**
    * Returns true if an artifact is a structured type
    * or a typedef of a structured type.
    *
-   * @param {CSN.Artifact} obj
+   * @param {object} obj
    */
   function isStructured(obj) {
     return obj.elements ||
@@ -276,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;
   }
 
@@ -397,7 +424,7 @@ function getUtils(model) {
   function getServiceName(artifactName) {
     for(;;) {
       let idx = artifactName.lastIndexOf('.');
-      if (idx == -1) return null;
+      if (idx === -1) return null;
       artifactName = artifactName.substring(0, idx);
       let artifact = model.definitions[artifactName];
       if (artifact && artifact.kind === 'service') {
@@ -514,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;
       }
@@ -627,7 +654,7 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
   }
 
   path = [...path]; // Copy
-  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'foreignKeys', 'actions', 'params']);
+  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'actions', 'params']);
   propsWithMembers.forEach((prop) => forEachGeneric( construct, prop, callback, path, iterateOptions ));
 }
 
@@ -684,45 +711,6 @@ function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
   }
 }
 
-/**
- * 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]));
-    }
-  }
-}
-
 // Like Object.assign() but copies also non enumerable properties
 function assignAll(target, ...sources) {
   sources.forEach(source => {
@@ -808,39 +796,6 @@ function forAllQueries(query, callback, path = []){
   }
 }
 
-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'])
-  }
-}
-
 /**
  * Compare a given annotation value with an expectation value and return
  *
@@ -859,11 +814,14 @@ function forAllElements(artifact, artifactName, cb, includeActions = false){
  * @param {CSN.Artifact} artifact
  * @param {string} annotationName Name of the annotation (including the at-sign)
  * @param {any} expected
+ * @param {boolean} caseInsensitive
  * @returns {boolean}
  */
-function hasAnnotationValue(artifact, annotationName, expected = true) {
+function hasAnnotationValue(artifact, annotationName, expected = true, caseInsensitive = 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;
 }
@@ -900,48 +858,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);
     }
   }
 }
@@ -1027,135 +985,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);
-  }
-}
-
-
-/**
- * Loop through the model, applying the custom transformations on the node's matching.
- *
- * Each transformer gets:
- * - the parent having the property
- * - the name of the property
- * - the value of the property
- * - the path to the property
- *
- * @param {object} csn CSN to enrich in-place
- * @param {object} customTransformers Map of prop to transform and function to apply
- * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {Boolean} [skipIgnore=true] Wether to skip _ignore elements or not
- * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
- * @returns {object} CSN with transformations applied
- */
-function applyTransformations( csn, customTransformers={}, artifactTransformers=[], skipIgnore = true, options = {} ) {
-  const transformers = {
-    elements: dictionary,
-    definitions: dictionary,
-    actions: dictionary,
-    params: dictionary,
-    enum: dictionary,
-    mixin: dictionary,
-    ref: pathRef,
-    //type: simpleRef,
-    //target: simpleRef,
-    //includes: simpleRef,
-  }
-
-  const csnPath = [];
-  if (csn.definitions)
-    definitions( csn, 'definitions', csn.definitions );
-  return csn;
-
-  function standard( parent, prop, node ) {
-    if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ) || (typeof prop === 'string' && prop.startsWith('@')) || (skipIgnore && node._ignore))
-      return;
-
-    csnPath.push( prop );
-
-    if (Array.isArray(node)) {
-      node.forEach( (n, i) => standard( node, i, n ) );
-    }
-
-    else {
-      for (let name of Object.getOwnPropertyNames( node )) {
-        const trans = transformers[name] || standard;
-        if(customTransformers[name])
-          customTransformers[name](node, name, node[name], csnPath, parent, prop);
-
-        trans( node, name, node[name], csnPath );
-      }
-    }
-    csnPath.pop();
-  }
-
-  function dictionary( node, prop, dict ) {
-    // Allow skipping dicts like actions in forHanaNew
-    if(options.skipDict && options.skipDict[prop])
-      return;
-    csnPath.push( prop );
-    for (let name of Object.getOwnPropertyNames( dict )) {
-      standard( dict, name, dict[name] );
-    }
-    if (!Object.prototype.propertyIsEnumerable.call( node, prop ))
-      setProp(node, '$' + prop, dict);
-    csnPath.pop();
-  }
-
-  function definitions( node, prop, dict ) {
-    csnPath.push( prop );
-    for (let name of Object.getOwnPropertyNames( dict )) {
-      const skip = options && options.skipArtifact && options.skipArtifact(dict[name], name) || false;
-      if(!skip) {
-        artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-        standard( dict, name, dict[name] );
-      }
-    }
-    if (!Object.prototype.propertyIsEnumerable.call( node, prop ))
-      setProp(node, '$' + prop, dict);
-    csnPath.pop();
-  }
-
-  //Keep looping through the pathRef
-  function pathRef( node, prop, path ) {
-    csnPath.push( prop );
-    path.forEach( function step( s, i ) {
-      if (s && typeof s === 'object') {
-        csnPath.push( i );
-        if(options.drillRef) {
-          standard(path, i, s);
-        } else {
-          if (s.args)
-            standard( s, 'args', s.args );
-          if (s.where)
-            standard( s, 'where', s.where );
-        }
-        csnPath.pop();
-      }
-    } );
-    csnPath.pop();
+    throw new Error('Unknown naming mode: ' + sqlMapping);
   }
 }
 
@@ -1233,7 +1085,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')));
 }
 
 /**
@@ -1301,10 +1153,10 @@ function mergeOptions(...optionsObjects) {
     }
     // 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
@@ -1338,38 +1190,6 @@ function mergeOptions(...optionsObjects) {
   }
 }
 
-// Return the name of the top-level artifact surrounding the artifact 'name'
-// in 'model'.
-// We define "top-level artifact" to be an artifact that has either no parent or only
-// ancestors of kind 'namespace'. Note that it is possible for a non-top-level artifact
-// to have a namespace as parent and e.g. a context as grandparent (weird but true).
-// Will return the artifact 'name' if it is a top-level artifact itself, and 'undefined'
-// if there is no artifact surrounding 'name' in the model
-// TODO: to be checked by author: still intended behaviour with 'cds' prefix?
-// TODO: Can this be replaced by getRootArtifactName? Or maybe not rely on namespace-hacking...
-// FIXME: This only works with namespace-hacking, i.e. adding them as artifacts...
-function getTopLevelArtifactNameOf(name, model) {
-  let dotIdx = name.indexOf('.');
-  if (dotIdx == -1) {
-    // No '.' in the name, i.e. no parent - this is a top-level artifact (if it exists)
-    return model.definitions[name] ? name : undefined;
-  }
-  // If the first name part is not in the model, there is nothing to find
-  if (!model.definitions[name.substring(0, dotIdx)]) {
-    return undefined;
-  }
-  // Skip forward through '.'s until finding a non-namespace
-  while (dotIdx != -1 && (!model.definitions[name.substring(0, dotIdx)] || model.definitions[name.substring(0, dotIdx)].kind === 'namespace')) {
-    dotIdx = name.indexOf('.', dotIdx + 1);
-  }
-  if (dotIdx == -1) {
-    // This is a top-level artifact
-    return name;
-  }
-  // The skipped part of 'name' is the top-level artifact name
-  return name.substring(0, dotIdx);
-}
-
 /**
 * If the artifact with the name given is part of a context (or multiple), return the top-most context.
 * Else, return the artifact itself. Namespaces are not of concern here.
@@ -1491,7 +1311,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))
 
 }
@@ -1560,7 +1380,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}
@@ -1579,8 +1399,8 @@ function isSkipped(artifact) {
 function walkCsnPath(csn, path) {
   /** @type {object} */
   let obj = csn;
-  for(let i = 0; i < path.length; i++){
-    obj = obj[path[i]];
+  for(const segment of path){
+    obj = obj[segment];
   }
 
   return obj;
@@ -1589,16 +1409,16 @@ function walkCsnPath(csn, path) {
 /**
  * If provided, get the replacement string for the given magic variable ref.
  * No validation is done that the ref is actually magic!
- * 
- * @param {array} ref 
- * @param {CSN.Options} options 
- * @returns {string|null} 
+ *
+ * @param {array} ref
+ * @param {CSN.Options} options
+ * @returns {string|null}
  */
 function getVariableReplacement(ref, options) {
   if(options && options.variableReplacements) {
     let replacement = options.variableReplacements;
-    for(let i = 0; i < ref.length; i++) {
-      replacement = replacement[ref[i]];
+    for(const segment of ref) {
+      replacement = replacement[segment];
       if(replacement === undefined)
         return null;
     }
@@ -1614,6 +1434,42 @@ function getVariableReplacement(ref, options) {
   }
 }
 
+/**
+ *
+ * @param {object} obj
+ * @param {*} other
+ * @param {boolean} noExtendedProps
+ * @returns {boolean} returns equality
+ *
+ * noExtendedProps remove '$', '_' and '@' properties from
+ * the comparision. 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,
@@ -1624,9 +1480,7 @@ module.exports = {
   forEachDefinition,
   forEachMember,
   forEachMemberRecursively,
-  forEachRef,
   forAllQueries,
-  forAllElements,
   hasAnnotationValue,
   isEdmPropertyRendered,
   getArtifactDatabaseNameOf,
@@ -1634,12 +1488,12 @@ module.exports = {
   getUnderscoredName,
   getElementDatabaseNameOf,
   applyTransformations,
+  applyTransformationsOnNonDictionary,
   setDependencies,
   isPersistedOnDatabase,
   generatedByCompilerVersion,
   getNormalizedQuery,
   mergeOptions,
-  getTopLevelArtifactNameOf,
   getRootArtifactName,
   getLastPartOfRef,
   getParentNamesOf,
@@ -1654,5 +1508,7 @@ module.exports = {
   getServiceNames,
   isSkipped,
   walkCsnPath,
-  getVariableReplacement
+  getVariableReplacement,
+  implicitAs,
+  isDeepEqual,
 };