@sap/cds-compiler 2.13.6 → 2.15.4

package/lib/model/csnUtils.js

@@ -447,13 +447,13 @@ function getUtils(model, universalReady) {
    * The transformer functions are called with the following signature:
    * transformer(value, node, resultNode, key)
    *
-   * @param {any} node Node to transform
+   * @param {any} rootNode Node to transform
    * @param {any} transformers Object defining transformer functions
    * @returns {object}
    */
-  function cloneWithTransformations(node, transformers) {
+  function cloneWithTransformations(rootNode, transformers) {
 
-    return transformNode(node);
+    return transformNode(rootNode);
 
   // This general transformation function will be applied to each node recursively
     function transformNode(node) {
@@ -588,7 +588,7 @@ function getUtils(model, universalReady) {
  * @param {object} csn Top-level CSN.  You can pass non-dictionary values.
  * @param {CSN.Options} options CSN Options, only used for `dictionaryPrototype`, `testMode`, and `testSortCsn`
  */
-function cloneCsn(csn, options) {
+function cloneCsnNonDict(csn, options) {
   return sortCsn(csn, options);
 }
 
@@ -596,7 +596,7 @@ function cloneCsn(csn, options) {
  * Deeply clone the given CSN dictionary and return it.
  * Note that annotations are only copied shallowly.
  * This function does _not_ sort the given dictionary.
- * See cloneCsn() if you want sorted definitions.
+ * See cloneCsnNonDict() if you want sorted definitions.
  *
  * @param {object} csn
  * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
@@ -632,8 +632,10 @@ function forEachDefinition( csn, callback, iterateOptions = {} ) {
  * @param {CSN.Path} [path]
  * @param {boolean} [ignoreIgnore]
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param constructCallback
  */
-function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {}) {
+function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                        constructCallback = (_construct, _prop, _path) => {}) {
   // Allow processing _ignored elements if requested
   if (ignoreIgnore && construct._ignore) {
     return;
@@ -641,8 +643,7 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
 
   // `items` itself is a structure that can contain "elements", and more.
   if (construct.items) {
-    // TODO: Should we go to the deepest items.items?
-    forEachMember( construct.items, callback, [...path, 'items'], ignoreIgnore, iterateOptions );
+    forEachMember( construct.items, callback, [...path, 'items'], ignoreIgnore, iterateOptions, constructCallback );
   }
 
   // Unlike XSN, we don't make "returns" a "params" in the callback.
@@ -650,12 +651,43 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
   // `elements` of the return type (if structured).
   // TODO: `returns` should be handled like a parameter just like XSN (maybe with different prop name)
   if (construct.returns && !iterateOptions.elementsOnly) {
-    forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions );
+    forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions, constructCallback );
   }
 
   path = [...path]; // Copy
   const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'actions', 'params']);
-  propsWithMembers.forEach((prop) => forEachGeneric( construct, prop, callback, path, iterateOptions ));
+  propsWithMembers.forEach((prop) => {
+    forEachGeneric( construct, prop, callback, path, iterateOptions );
+    if (construct[prop]) {
+      if (Array.isArray(constructCallback))
+        constructCallback.forEach(cb => cb(construct, prop, path));
+      else
+        constructCallback(construct, prop, path);
+    }
+  });
+}
+
+/**
+ * Call `forEachMember` and then apply `forEachMember` on queries.
+ *
+ * @param {CSN.Artifact} construct
+ * @param {genericCallback|genericCallback[]} callback
+ * @param {CSN.Path} [path]
+ * @param {boolean} [ignoreIgnore]
+ * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
+ */
+function forEachMemberWithQuery( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+  constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMember(construct, callback, path, ignoreIgnore, iterateOptions, constructCallback);
+  if (construct.query) {
+    forAllQueries(construct.query, (q, p) => {
+      const s = q.SELECT;
+      if(s) {
+        forEachMember(s, callback, p, ignoreIgnore, iterateOptions);
+      }
+    }, [ ...path, 'query' ]);
+  }
 }
 
 /**
@@ -667,16 +699,43 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
  * @param {CSN.Path} [path]
  * @param {boolean} [ignoreIgnore]
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
  */
-function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {}) {
-  forEachMember( construct, ( member, memberName, prop, subpath ) => {
+function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                                   constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMember( construct, ( member, memberName, prop, subpath, parent ) => {
     if(Array.isArray(callback))
-      callback.forEach(cb => cb( member, memberName, prop, subpath, construct ));
+      callback.forEach(cb => cb( member, memberName, prop, subpath, parent ));
     else
-      callback( member, memberName, prop, subpath, construct );
+      callback( member, memberName, prop, subpath, parent );
     // Descend into nested members, too
-    forEachMemberRecursively( member, callback, subpath, ignoreIgnore, iterateOptions);
-  }, path, ignoreIgnore, iterateOptions);
+    forEachMemberRecursively( member, callback, subpath, ignoreIgnore, iterateOptions, constructCallback);
+  }, path, ignoreIgnore, iterateOptions, constructCallback);
+}
+
+/**
+ * Apply function `callback(member, memberName)` to each member in `construct`,
+ * recursively (i.e. also for sub-elements of elements).
+ * Recursively iterate over elements of `construct` query.
+ *
+ * @param {CSN.Artifact} construct
+ * @param {genericCallback|genericCallback[]} callback
+ * @param {CSN.Path} [path]
+ * @param {boolean} [ignoreIgnore]
+ * @param {object} iterateOptions can be used to skip certain kinds from being iterated
+ * @param {constructCallback|constructCallback[]} callback
+ */
+function forEachMemberRecursivelyWithQuery( construct, callback, path=[], ignoreIgnore=true, iterateOptions = {},
+                                              constructCallback = (_construct, _prop, _path) => {}) {
+  forEachMemberRecursively(construct, callback, path, ignoreIgnore, iterateOptions, constructCallback);
+  if(construct.query) {
+    forAllQueries(construct.query, (q, p) => {
+      const s = q.SELECT;
+      if(s) {
+        forEachMemberRecursively(s, callback, p, ignoreIgnore, iterateOptions);
+      }
+    }, [ ...path, 'query' ]);
+  }
 }
 
 /**
@@ -685,14 +744,14 @@ function forEachMemberRecursively( construct, callback, path=[], ignoreIgnore=tr
  * the following arguments: the object, the name, and -if it is a duplicate-
  * the array index and the array containing all duplicates.
  *
- * @param {object} obj
+ * @param {object} construct
  * @param {string} prop
  * @param {genericCallback|genericCallback[]} callback
  * @param {CSN.Path} path
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated
  */
-function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
-  const dict = obj[prop];
+function forEachGeneric( construct, prop, callback, path = [], iterateOptions = {}) {
+  const dict = construct[prop];
   for (const name in dict) {
     if (!Object.prototype.hasOwnProperty.call(dict, name))
       continue;
@@ -701,26 +760,26 @@ function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
        || (iterateOptions.skipArtifact && typeof iterateOptions.skipArtifact === 'function'
            && iterateOptions.skipArtifact(dictObj, name)))
       continue;
-    cb( dictObj, name );
+    executeCallbacks( dictObj, name );
   }
-  function cb(o, name ) {
+  function executeCallbacks(o, name ) {
     if (Array.isArray(callback))
-      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name])));
+      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name]), construct ));
     else
-      callback( o, name, prop, path.concat([prop, name]))
+      callback( o, name, prop, path.concat([prop, name]), construct )
   }
 }
 
 // Like Object.assign() but copies also non enumerable properties
 function assignAll(target, ...sources) {
   sources.forEach(source => {
-    let descriptors = Object.getOwnPropertyNames(source).reduce((descriptors, key) => {
-      descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
-      return descriptors;
+    const descriptors = Object.getOwnPropertyNames(source).reduce((propertyDescriptors, current) => {
+      propertyDescriptors[current] = Object.getOwnPropertyDescriptor(source, current);
+      return propertyDescriptors;
     }, {});
     // by default, Object.assign copies enumerable Symbols too
     Object.getOwnPropertySymbols(source).forEach(sym => {
-      let descriptor = Object.getOwnPropertyDescriptor(source, sym);
+      const descriptor = Object.getOwnPropertyDescriptor(source, sym);
       if (descriptor.enumerable) {
         descriptors[sym] = descriptor;
       }
@@ -731,68 +790,68 @@ function assignAll(target, ...sources) {
 }
 
 /**
- * @param {CSN.Query} query
- * @param {queryCallback|queryCallback[]} callback
+ * @param {CSN.Query} mainQuery
+ * @param {queryCallback|queryCallback[]} queryCallback
  * @param {CSN.Path} path
  */
-function forAllQueries(query, callback, path = []){
-  return traverseQuery(query, callback, path);
-  function traverseQuery( q, callback, p ) {
-    if (q.SELECT) {
+function forAllQueries(mainQuery, queryCallback, path = []){
+  return traverseQuery(mainQuery, queryCallback, path);
+  function traverseQuery( query, callback, queryPath ) {
+    if (query.SELECT) {
       // The projection is turned into a normalized query - there
       // is no real SELECT, it is fake
       if(!(path.length === 3 && path[2] === 'projection'))
-        p.push('SELECT');
-      cb( q, p );
-      q = q.SELECT;
+        queryPath.push('SELECT');
+      executeCallbacks();
+      query = query.SELECT;
     }
-    else if (q.SET) {
-      p.push('SET');
-      cb( q, p );
-      q = q.SET;
+    else if (query.SET) {
+      queryPath.push('SET');
+      executeCallbacks();
+      query = query.SET;
     }
 
-    if (q.from)
-      traverseFrom( q.from, callback, p.concat(['from']) );
+    if (query.from)
+      traverseFrom( query.from, callback, queryPath.concat(['from']) );
 
     for (const prop of ['args', 'xpr', 'columns', 'where', 'having']) {
       // all properties which could have sub queries (directly or indirectly)
-      const expr = q[prop];
+      const expr = query[prop];
       if (expr && typeof expr === 'object') {
         if(Array.isArray(expr)){
           for(let i = 0; i < expr.length; i++){
-            traverseQuery(expr[i], callback, p.concat([prop, i]));
+            traverseQuery(expr[i], callback, queryPath.concat([prop, i]));
           }
         } else {
           for(const argName of Object.keys( expr )){
-            traverseQuery(expr[argName], callback, p.concat([prop, argName]))
+            traverseQuery(expr[argName], callback, queryPath.concat([prop, argName]))
           }
         }
       }
     }
-    function cb(q, p) {
+    function executeCallbacks() {
       if(Array.isArray(callback))
-        callback.forEach(cb => cb( q, p ));
+        callback.forEach(cb => cb( query, queryPath ));
       else
-        callback( q, p );
+        callback( query, queryPath );
     }
   }
 
   /**
    * @param {CSN.QueryFrom} from
    * @param {Function} callback
-   * @param {CSN.Path} path
+   * @param {CSN.Path} csnPath
    */
-  function traverseFrom( from, callback, path = [] ) {
+  function traverseFrom( from, callback, csnPath = [] ) {
     if (from.ref) // ignore
       return;
     else if (from.args){ // join
       for(let i = 0; i < from.args.length; i++){
-        traverseFrom(from.args[i], callback, path.concat(['args', i]));
+        traverseFrom(from.args[i], callback, csnPath.concat(['args', i]));
       }
     }
     else
-      traverseQuery( from, callback, path ); // sub query in FROM
+      traverseQuery( from, callback, csnPath ); // sub query in FROM
   }
 }
 
@@ -967,7 +1026,7 @@ function getUnderscoredName(startIndex, parts, csn) {
 
       return result;
     } else if(art && art.kind === 'service') {
-      // inside services, we immediatly turn . into _
+      // inside services, we immediately turn . into _
       const prefix = parts.slice(0, i).join('.');
       const suffix = parts.slice(i).join('_');
       const result = [];
@@ -1139,17 +1198,17 @@ function mergeOptions(...optionsObjects) {
 
   // Recursively used for scalars, too
   function mergeTwo(left, right, name) {
-    let result;
+    let intermediateResult;
     // Copy left as far as required
     if (Array.isArray(left)) {
       // Shallow-copy left array
-      result = left.slice();
+      intermediateResult = left.slice();
     } else if (isObject(left)) {
       // Deep-copy left object (unless empty)
-      result = Object.keys(left).length ? mergeTwo({}, left, name) : {};
+      intermediateResult = Object.keys(left).length ? mergeTwo({}, left, name) : {};
     } else {
       // Just use left scalar
-      result = left;
+      intermediateResult = left;
     }
     // Check against improper overwriting
     if (isObject(left) && !Array.isArray(left) && (Array.isArray(right) || isScalar(right))) {
@@ -1162,21 +1221,21 @@ function mergeOptions(...optionsObjects) {
     // Copy or overwrite properties from right to left
     if (Array.isArray(right)) {
       // Shallow-copy right array
-      result = right.slice();
+      intermediateResult = right.slice();
     } else if (isObject(right)) {
       // Object overwrites undefined, scalars and arrays
-      if (result === undefined || isScalar(result) || Array.isArray(result)) {
-        result = {};
+      if (intermediateResult === undefined || isScalar(intermediateResult) || Array.isArray(intermediateResult)) {
+        intermediateResult = {};
       }
       // Deep-copy right object into result
       for (let key of Object.keys(right)) {
-        result[key] = mergeTwo(result[key], right[key], `${name}.${key}`);
+        intermediateResult[key] = mergeTwo(intermediateResult[key], right[key], `${name}.${key}`);
       }
     } else {
       // Right scalar wins (unless undefined)
-      result = (right !== undefined) ? right : result;
+      intermediateResult = (right !== undefined) ? right : intermediateResult;
     }
-    return result;
+    return intermediateResult;
   }
 
   // Return true if 'o' is a non-null object or array
@@ -1264,19 +1323,73 @@ function getParentNamesOf(name) {
 }
 
 
-// Copy all annotations from 'fromNode' to 'toNode'. Overwrite existing ones only if 'overwrite' is true
-function copyAnnotations(fromNode, toNode, overwrite=false) {
+/**
+ * Copy all annotations from 'fromNode' to 'toNode'.
+ *
+ * Overwrite existing ones only if 'overwrite' is true.
+ *
+ * @param {object} fromNode
+ * @param {object} toNode
+ * @param {boolean} [overwrite]
+ */
+function copyAnnotations(fromNode, toNode, overwrite = false) {
   // Ignore if no toNode (in case of errors)
-  if (!toNode) {
+  if (!toNode)
     return;
+
+  const annotations = Object.keys(fromNode).filter(key => key.startsWith('@'));
+
+  for (const anno of annotations) {
+    if (toNode[anno] === undefined || overwrite) {
+      toNode[anno] = fromNode[anno];
+    }
   }
-  for (let prop in fromNode) {
-    if (!Object.hasOwnProperty.call( fromNode, prop ))
-      continue;
-    if (prop.startsWith('@')) {
-      if (toNode[prop] === undefined || overwrite) {
-        toNode[prop] = fromNode[prop];
-      }
+}
+
+
+/**
+ * Same as `copyAnnotations()` but also copies the
+ * annotation-like property `doc`.
+ *
+ * Overwrite existing ones only if 'overwrite' is true.
+ *
+ * @param {object} fromNode
+ * @param {object} toNode
+ * @param {boolean} [overwrite]
+ */
+function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
+  // Ignore if no toNode (in case of errors)
+  if (!toNode)
+    return;
+
+  const annotations = Object.keys(fromNode)
+    .filter(key => key.startsWith('@') || key === 'doc');
+
+  for (const anno of annotations) {
+    if (toNode[anno] === undefined || overwrite) {
+      toNode[anno] = fromNode[anno];
+    }
+  }
+}
+
+/**
+ * Applies annotations from `csn.extensions` to definitions, i.e. top-level artifacts.
+ * Does _not_ apply element/param/action/... annotations.
+ * `config.filter` can be used to only copy annotations for those definitions,
+ * for which the filter returns true.
+ *
+ * @param {CSN.Model} csn
+ * @param {{overwrite?: boolean, filter?: (name: string) => boolean}} config
+ */
+function applyDefinitionAnnotationsFromExtensions(csn, config) {
+  if (!csn.extensions)
+    return;
+
+  const filter = config.filter || ((_name) => true);
+  for (const ext of csn.extensions) {
+    const name = ext.annotate || ext.extend;
+    if (name && csn.definitions[name] && filter(name)) {
+      copyAnnotationsAndDoc(ext, csn.definitions[name], config.overwrite);
     }
   }
 }
@@ -1442,7 +1555,7 @@ function getVariableReplacement(ref, options) {
  * @returns {boolean} returns equality
  *
  * noExtendedProps remove '$', '_' and '@' properties from
- * the comparision. This eliminates false negatives such as
+ * the comparison. This eliminates false negatives such as
  *  mismatching $locations or @odata.foreignKey4.
  */
 function isDeepEqual(obj, other, noExtendedProps) {
@@ -1472,14 +1585,18 @@ function isDeepEqual(obj, other, noExtendedProps) {
 
 module.exports = {
   getUtils,
-  cloneCsn,
+  cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
+  cloneCsnNonDict,
   cloneCsnDictionary,
   isBuiltinType,
   assignAll,
+  applyDefinitionAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,
   forEachMember,
+  forEachMemberWithQuery,
   forEachMemberRecursively,
+  forEachMemberRecursivelyWithQuery,
   forAllQueries,
   hasAnnotationValue,
   isEdmPropertyRendered,
@@ -1500,6 +1617,7 @@ module.exports = {
   getParentNameOf,
   getLastPartOf,
   copyAnnotations,
+  copyAnnotationsAndDoc,
   isAspect,
   forEachPath,
   hasValidSkipOrExists,

package/lib/model/enrichCsn.js

@@ -152,6 +152,7 @@ function enrichCsn( csn, options = {} ) {
     else {                      // targetAspect, target
       csnPath.push( prop );
       dictionary( ref, 'elements', ref.elements );
+      _cache_debug( ref );
       csnPath.pop();
     }
     // } catch (e) {

package/lib/model/revealInternalProperties.js

@@ -36,7 +36,7 @@ const kindsRepresentedAsLinks = {
   // represent table alias in from / join-args property as link:
   $tableAlias: tableAliasAsLink,
   // represent "navigation elemens" in _combined as links:
-  $navElement: (art, parent) => art._parent && parent !== art._parent.elements,
+  $navElement: (art, parent) => art._parent && parent !== art._parent.elements && art._parent.kind !== 'aspect',
   // represent mixin in $tableAliases as link:
   mixin: tableAliasAsLink,
   // represent $projection as link, as it is just another search name for $self:
@@ -129,7 +129,7 @@ function revealInternalProperties( model, nameOrPath ) {
 
     path = path.split('/');
     if (path.length === 1) {
-      return reveal( xsn.definitions[path] );
+      return reveal( xsn.definitions[path] || xsn.vocabularies && xsn.vocabularies[path] );
     }
 
     // with the code below, we might miss the right transformer function

package/lib/modelCompare/compare.js

@@ -45,19 +45,19 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   let afterVersionParts = afterVersion && afterVersion.split('.');
 
   if (!beforeVersionParts || beforeVersionParts.length < 2) {
-    const { error, throwWithError } = makeMessageFunction(beforeModel, options, 'modelCompare');
+    const { error, throwWithAnyError } = makeMessageFunction(beforeModel, options, 'modelCompare');
     error(null, null, `Invalid CSN version: ${beforeVersion}`);
-    throwWithError();
+    throwWithAnyError();
   }
   if (!afterVersionParts || afterVersionParts.length < 2) {
-    const { error, throwWithError } = makeMessageFunction(afterModel, options, 'modelCompare');
+    const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
     error(null, null, `Invalid CSN version: ${afterVersion}`);
-    throwWithError();
+    throwWithAnyError();
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {
-    const { error, throwWithError } = makeMessageFunction(afterModel, options, 'modelCompare');
+    const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
     error(null, null, `Incompatible CSN versions: ${afterVersion} is a major downgrade from ${beforeVersion}. Is @sap/cds-compiler version ${require('../../package.json').version} outdated?`);
-    throwWithError();
+    throwWithAnyError();
   }
 }