@sap/cds-compiler 2.12.0 → 2.13.6

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;
   }
 
@@ -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;
       }
@@ -649,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 ));
 }
 
@@ -706,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 => {
@@ -830,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
  *
@@ -925,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);
     }
   }
 }
@@ -1052,29 +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);
+    throw new Error('Unknown naming mode: ' + sqlMapping);
   }
 }
 
@@ -1152,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')));
 }
 
 /**
@@ -1220,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
@@ -1378,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))
 
 }
@@ -1447,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}
@@ -1501,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,
@@ -1511,9 +1480,7 @@ module.exports = {
   forEachDefinition,
   forEachMember,
   forEachMemberRecursively,
-  forEachRef,
   forAllQueries,
-  forAllElements,
   hasAnnotationValue,
   isEdmPropertyRendered,
   getArtifactDatabaseNameOf,
@@ -1541,5 +1508,7 @@ module.exports = {
   getServiceNames,
   isSkipped,
   walkCsnPath,
-  getVariableReplacement
+  getVariableReplacement,
+  implicitAs,
+  isDeepEqual,
 };