@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/model/csnUtils.js

@@ -2,7 +2,7 @@
 
 const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
-const { sortCsn } = require('../json/to-csn');
+const { sortCsn, cloneCsnDictionary: _cloneCsnDictionary } = require('../json/to-csn');
 const version = require('../../package.json').version;
 
 // Low-level utility functions to work with compact CSN.
@@ -36,7 +36,7 @@ const version = require('../../package.json').version;
  * @param {CSN.Model} model (Compact) CSN model
  */
 function getUtils(model) {
-  const { artifactRef, inspectRef, effectiveType } = csnRefs(model);
+  const { artifactRef, inspectRef, effectiveType, getOrigin } = csnRefs(model);
 
   return {
     getCsnDef,
@@ -52,14 +52,143 @@ function getUtils(model) {
     getContextOfArtifact,
     addStringAnnotationTo,
     getServiceName,
-    hasBoolAnnotation,
+    hasAnnotationValue,
     cloneWithTransformations,
     getFinalBaseType,
     inspectRef,
     artifactRef,
     effectiveType,
+    get$combined,
+    getOrigin,
   };
 
+  /**
+   * Compute and return $combined for the given query.
+   *
+   * @param {CSN.Query} query
+   * @returns {object}
+   */
+  function get$combined(query) {
+    const sources = getSources(query);
+    return sources;
+
+    /**
+     * 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);
+
+        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.from.ref) {
+          let art = artifactRef(query.SELECT.from);
+
+          if(art.target)
+            art = artifactRef(art.target);
+
+          if(isSubquery && !query.SELECT.elements)
+            throw new Error('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);
+        }
+      }
+
+      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;
+      }
+
+      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 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;
+
+      if (name.id)
+        return name.id.substring( name.id.lastIndexOf('.')+1 );
+
+      return name.substring( name.lastIndexOf('.')+1 )
+    }
+  }
 
 
   /**
@@ -328,45 +457,54 @@ function getUtils(model) {
       return resultNode;
     }
   }
-
-  // Resolve to the final type of a type, that means follow type chains, references to other types or
-  // elements a.s.o
-  // Works for all kinds of types, strings as well as type objects. Strings need to be absolute type names.
-  // Returns the final type as string (if it has a name, which is not always the case, think of embedded structures),
-  // else the type object itself is returned. If a type is structured, you can navigate into it by providing a path,
-  // e.g. given the following model
-  //     type bar: S.foo;
-  //     type s1 {
-  //       s: s2;
-  //     };
-  //     type s2 {
-  //       u: type of S.e:t;
-  //     }
-  //     service S {
-  //       type foo: type of S.e:i.j1;
-  //       entity e {
-  //         key i: { j1: Integer };
-  //         t: bar;
-  //         v: s1;
-  //         x: blutz.s.u;
-  //       };
-  //       type blutz: S.e.v;
-  //       view V as select from e {
-  //         1+1 as i: bar,
-  //       };
-  //       type tt: type of V:i;
-  //    }
-  // the following calls will all return 'cds.Integer'
-  //     getFinalBaseType('S.tt')
-  //     getFinalBaseType('S.e',['i','j1'])
-  //     getFinalBaseType('S.e',['t'])
-  //     getFinalBaseType('S.e',['x'])
-  //     getFinalBaseType('S.blutz',['s', 'u'])
-  // Types are always resolved as far as possible. A type name which has no further definition is simply returned.
-  // Composed types (structures, entities, vies, ...) are returned as type objects, if not drilled down into
-  // the elements. Path steps that have no corresponding element lead to 'undefined'. Refs to something that has
-  // no type (e.g. expr in a view without explicit type) returns 'null'
-  function getFinalBaseType(type, path = [], cycleCheck = undefined) {
+  
+  
+  /**
+   * Resolve to the final type of a type, that means follow type chains, references to other types or
+   * elements a.s.o
+   * Works for all kinds of types, strings as well as type objects. Strings need to be absolute type names.
+   * Returns the final type as string (if it has a name, which is not always the case, think of embedded structures),
+   * else the type object itself is returned. If a type is structured, you can navigate into it by providing a path,
+   * e.g. given the following model
+   *     type bar: S.foo;
+   *     type s1 {
+   *       s: s2;
+   *     };
+   *     type s2 {
+   *       u: type of S.e:t;
+   *     }
+   *     service S {
+   *       type foo: type of S.e:i.j1;
+   *       entity e {
+   *         key i: { j1: Integer };
+   *         t: bar;
+   *         v: s1;
+   *         x: blutz.s.u;
+   *       };
+   *       type blutz: S.e.v;
+   *       view V as select from e {
+   *         1+1 as i: bar,
+   *       };
+   *       type tt: type of V:i;
+   *    }
+   * the following calls will all return 'cds.Integer'
+   *     getFinalBaseType('S.tt')
+   *     getFinalBaseType('S.e',['i','j1'])
+   *     getFinalBaseType('S.e',['t'])
+   *     getFinalBaseType('S.e',['x'])
+   *     getFinalBaseType('S.blutz',['s', 'u'])
+   * Types are always resolved as far as possible. A type name which has no further definition is simply returned.
+   * Composed types (structures, entities, views, ...) are returned as type objects, if not drilled down into
+   * the elements. Path steps that have no corresponding element lead to 'undefined'. Refs to something that has
+   * no type (e.g. expr in a view without explicit type) returns 'null'
+   * 
+   * @param {string|object} type Type - either string or ref
+   * @param {CSN.Path} path 
+   * @param {WeakMap} [resolved=new WeakMap()] WeakMap containing already resolved refs - if a ref is not cached, it will be resolved JIT
+   * @param {object} [cycleCheck] Dictionary to remember already resolved types - to be cycle-safe 
+   * @returns 
+   */
+  function getFinalBaseType(type, path = [], resolved = new WeakMap(), cycleCheck = undefined) {
     if (!type)
       return type;
     if (typeof(type) === 'string') {
@@ -384,24 +522,24 @@ function getUtils(model) {
       }
       let definedType = model.definitions[type];
       if (definedType && definedType.type)
-        return getFinalBaseType(definedType.type, path, cycleCheck);
+        return getFinalBaseType(definedType.type, path, resolved, cycleCheck);
       else
-        return getFinalBaseType(definedType, path, cycleCheck);
+        return getFinalBaseType(definedType, path, resolved, cycleCheck);
     }
     else if (typeof(type) === 'object') {
       if (type.ref) {
         // assert type.ref instanceof Array && type.ref.length >= 1
-        const ref = artifactRef(type);
-        return getFinalBaseType(ref, path, cycleCheck);
+        const ref = resolved.has(type) ? resolved.get(type).art : artifactRef(type);
+        return getFinalBaseType(ref, path, resolved, cycleCheck);
       }
       else if (type.elements) {
         if (path.length) {
           let [e, ...p] = path;
-          return getFinalBaseType(type.elements[e], p, cycleCheck);
+          return getFinalBaseType(type.elements[e], p, resolved, cycleCheck);
         }
       }
       else if (type.type)
-        return (getFinalBaseType(type.type, path, cycleCheck));
+        return (getFinalBaseType(type.type, path, resolved, cycleCheck));
       else if (type.items)
         return type;
       else
@@ -426,15 +564,30 @@ function isBuiltinType(type) {
 
 /**
  * Deeply clone the given CSN model and return it.
- * In testMode, definitions are sorted.
+ * In testMode (or with testSortCsn), definitions are sorted.
+ * Note that annotations are only copied shallowly.
  *
- * @param {object} csn
+ * @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) {
   return sortCsn(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.
+ *
+ * @param {object} csn
+ * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
+ *                              used and cloneOptions are passed to sort().
+ */
+function cloneCsnDictionary(csn, options) {
+  return _cloneCsnDictionary(csn, options);
+}
+
 /**
  * Apply function `callback` to all artifacts in dictionary
  * `model.definitions`.  See function `forEachGeneric` for details.
@@ -478,12 +631,12 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
   // 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) {
+  if (construct.returns && !iterateOptions.elementsOnly) {
     forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions );
   }
 
   path = [...path]; // Copy
-  const propsWithMembers = ['elements', 'enum', 'foreignKeys', 'actions', 'params'];
+  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'foreignKeys', 'actions', 'params']);
   propsWithMembers.forEach((prop) => forEachGeneric( construct, prop, callback, path, iterateOptions ));
 }
 
@@ -526,7 +679,9 @@ function forEachGeneric( obj, prop, callback, path = [], iterateOptions = {}) {
     if (!Object.prototype.hasOwnProperty.call(dict, name))
       continue;
     const dictObj = dict[name];
-    if(iterateOptions.skip && iterateOptions.skip.includes(dictObj.kind))
+    if((iterateOptions.skip && iterateOptions.skip.includes(dictObj.kind))
+       || (iterateOptions.skipArtifact && typeof iterateOptions.skipArtifact === 'function'
+           && iterateOptions.skipArtifact(dictObj, name)))
       continue;
     cb( dictObj, name );
   }
@@ -682,15 +837,30 @@ function forAllElements(artifact, artifactName, cb){
 }
 
 /**
- * Returns true if the element has a specific annotation set to the given value.
+ * Compare a given annotation value with an expectation value and return
+ *
+ *          | Expected
+ *          | true  | false | null  | arb val
+ * Anno Val |-------|-------|-------|--------
+ * true     | true  | false | false | false
+ * false    | false | true  | false | false
+ * null     | false | true  | true  | false
+ * arb val  | false | false | false | true/false
+ *
+ * If the annotation value is 'null', 'true' is returned for the expectation values
+ * 'null' and 'false'. Expecting 'null' for an annotation value 'false' returns
+ * 'false'.
  *
  * @param {CSN.Artifact} artifact
  * @param {string} annotationName Name of the annotation (including the at-sign)
- * @param {any} value
+ * @param {any} expected
  * @returns {boolean}
  */
-function hasBoolAnnotation(artifact, annotationName, value = true) {
-  return artifact[annotationName] === value;
+function hasAnnotationValue(artifact, annotationName, expected = true) {
+  if(expected === false)
+    return artifact[annotationName] === expected || artifact[annotationName] === null;
+  else
+    return artifact[annotationName] === expected;
 }
 
 /**
@@ -890,11 +1060,12 @@ function getElementDatabaseNameOf(elemName, namingConvention) {
  *
  * @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 Wether to skip _ignore elements or not
+ * @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 ) {
+function applyTransformations( csn, customTransformers={}, artifactTransformers=[], skipIgnore = true, options = {} ) {
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -927,7 +1098,7 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
       for (let name of Object.getOwnPropertyNames( node )) {
         const trans = transformers[name] || standard;
         if(customTransformers[name])
-          customTransformers[name](node, name, node[name], csnPath);
+          customTransformers[name](node, name, node[name], csnPath, parent, prop);
 
         trans( node, name, node[name], csnPath );
       }
@@ -948,8 +1119,11 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
   function definitions( node, prop, dict ) {
     csnPath.push( prop );
     for (let name of Object.getOwnPropertyNames( dict )) {
-      artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-      standard( dict, name, dict[name] );
+      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);
@@ -962,10 +1136,14 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
     path.forEach( function step( s, i ) {
       if (s && typeof s === 'object') {
         csnPath.push( i );
-        if (s.args)
-          standard( s, 'args', s.args );
-        if (s.where)
-          standard( s, 'where', s.where );
+        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();
       }
     } );
@@ -1047,7 +1225,7 @@ function setDependencies( csn ) {
  * @returns {boolean}
  */
 function isPersistedOnDatabase(art) {
-  return !([ 'entity', 'view' ].includes(art.kind) && (art.abstract || hasBoolAnnotation(art, '@cds.persistence.skip')));
+  return !([ 'entity', 'view' ].includes(art.kind) && (art.abstract || hasAnnotationValue(art, '@cds.persistence.skip')));
 }
 
 /**
@@ -1160,6 +1338,7 @@ function mergeOptions(...optionsObjects) {
 // 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('.');
@@ -1267,22 +1446,13 @@ function copyAnnotations(fromNode, toNode, overwrite=false) {
     if (!Object.hasOwnProperty.call( fromNode, prop ))
       continue;
     if (prop.startsWith('@')) {
-      if (toNode[prop] == undefined || overwrite) {
+      if (toNode[prop] === undefined || overwrite) {
         toNode[prop] = fromNode[prop];
       }
     }
   }
 }
 
-// Return true if 'type' is a composition type
-function isComposition(type) {
-  if (!type)
-    return type;
-  if (type._artifact)
-    type = type._artifact.name;
-  return type.absolute === 'cds.Composition';
-}
-
 function isAspect(node) {
   return node && node.kind === 'aspect';
 }
@@ -1305,59 +1475,7 @@ function forEachPath(node, callback) {
   }
 }
 
-// Add an annotation with absolute name 'absoluteName' (including '@') and string value 'theValue' to 'node'
-function addBoolAnnotationTo(absoluteName, theValue, node) {
-  // Sanity check
-  if (!absoluteName.startsWith('@')) {
-    throw Error('Annotation name should start with "@": ' + absoluteName);
-  }
-  // Assemble the annotation
-  if(isAnnotationAssignable(node, absoluteName)) {
-    node[absoluteName] = {
-      name: {
-        absolute: absoluteName.substring(1),
-        location: node.location, // inherit location from main element
-      },
-      val: theValue,
-      literal: 'boolean',
-      location: node.location, // inherit location from main element
-    };
-  }
-}
 
-// Add an annotation with absolute name 'absoluteName' (including '@') and array 'theValue' to 'node'
-function addArrayAnnotationTo(absoluteName, theValue, node) {
-  // Sanity check
-  if (!absoluteName.startsWith('@')) {
-    throw Error(`Annotation name should start with "@": ${  absoluteName}`);
-  }
-  // Assemble the annotation
-  if(isAnnotationAssignable(node, absoluteName)) {
-    node[absoluteName] = {
-      name: {
-        absolute: absoluteName.substring(1),
-        location: node.location, // inherit location from main element
-      },
-      val: theValue,
-      literal: 'array',
-      location: node.location, // inherit location from main element
-    };
-  }
-}
-
-/**
- * Check wether an annotation can be assigned or not
- * (must be either undefined or null value)
- * @param {object} node Assignee
- * @param {string} name Annotation name
- * @returns {boolean}
- */
-function isAnnotationAssignable(node, name) {
-  if (!name.startsWith('@')) {
-    throw Error(`Annotation name should start with "@": ${  name}`);
-  }
-  return (node[name] === undefined || node[name] && node[name].val === null);
-}
 /**
  * Return true if the artifact has a valid, truthy persistence.exists/skip annotation
  *
@@ -1366,7 +1484,7 @@ function isAnnotationAssignable(node, name) {
  */
 function hasValidSkipOrExists(artifact) {
   return (artifact.kind === 'entity' || artifact.kind === 'view') &&
-         (hasBoolAnnotation(artifact, '@cds.persistence.exists', true) || hasBoolAnnotation(artifact, '@cds.persistence.skip', true))
+         (hasAnnotationValue(artifact, '@cds.persistence.exists', true) || hasAnnotationValue(artifact, '@cds.persistence.skip', true))
 
 }
 
@@ -1420,7 +1538,7 @@ function sortCsnDefinitionsForTests(csn, options) {
 /**
  * Return an array of non-abstract service names contained in CSN
  *
- * @param {CSN.Model} csn 
+ * @param {CSN.Model} csn
  * @returns {CSN.Service[]}
  */
 function getServiceNames(csn) {
@@ -1433,10 +1551,37 @@ function getServiceNames(csn) {
   return result;
 }
 
+/**
+ * Check wether the artifact is @cds.persistence.skip
+ * 
+ * @param {CSN.Artifact} artifact 
+ * @returns {Boolean}
+ */
+function isSkipped(artifact) {
+  return hasAnnotationValue(artifact, '@cds.persistence.skip', true)
+}
+
+/**
+ * Walk path in the CSN and return the result.
+ * 
+ * @param {CSN.Model} csn 
+ * @param {CSN.Path} path 
+ * @returns {object} Whatever is at the end of path
+ */
+function walkCsnPath(csn, path) {
+  /** @type {object} */
+  let obj = csn;
+  for(let i = 0; i < path.length; i++){
+    obj = obj[path[i]];
+  }
+
+  return obj;
+}
 
 module.exports = {
   getUtils,
   cloneCsn,
+  cloneCsnDictionary,
   isBuiltinType,
   assignAll,
   forEachGeneric,
@@ -1446,7 +1591,7 @@ module.exports = {
   forEachRef,
   forAllQueries,
   forAllElements,
-  hasBoolAnnotation,
+  hasAnnotationValue,
   isEdmPropertyRendered,
   getArtifactDatabaseNameOf,
   getResultingName,
@@ -1465,13 +1610,12 @@ module.exports = {
   getParentNameOf,
   getLastPartOf,
   copyAnnotations,
-  isComposition,
   isAspect,
   forEachPath,
-  addBoolAnnotationTo,
-  addArrayAnnotationTo,
   hasValidSkipOrExists,
   getNamespace,
   sortCsnDefinitionsForTests,
   getServiceNames,
+  isSkipped,
+  walkCsnPath,
 };