@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/model/csnUtils.js

@@ -2,6 +2,7 @@
 
 const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
+const { isBuiltinType } = require('../compiler/builtins.js')
 const { sortCsn, cloneCsnDictionary: _cloneCsnDictionary } = require('../json/to-csn');
 const version = require('../../package.json').version;
 
@@ -11,8 +12,8 @@ const version = require('../../package.json').version;
  * Generic Callback
  *
  * @callback genericCallback
- * @param {CSN.Artifact} art
- * @param {CSN.FQN} name Artifact Name
+ * @param {any} art
+ * @param {string} name Artifact Name
  * @param {string} prop Dictionary Property
  * @param {CSN.Path} path Location
  * @param {CSN.Artifact} [dictionary]
@@ -36,7 +37,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,
@@ -58,8 +59,137 @@ function getUtils(model) {
     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 )
+    }
+  }
 
 
   /**
@@ -329,44 +459,53 @@ function getUtils(model) {
     }
   }
 
-  // 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 +523,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
@@ -414,16 +553,6 @@ function getUtils(model) {
   }
 }
 
-// Tell if a type is (directly) a builtin type
-// Note that in CSN builtins are not in the definition of the model, so we can only check against their absolute names.
-// Builtin types are "cds.<something>", i.e. they are directly in 'cds', but not for example
-// in 'cds.foundation'. Also note, that a type might be a ref object, that refers to something else,
-// so if you consider type chains don't forget first to resolve to the final type before
-function isBuiltinType(type) {
-  return typeof(type) === 'string' && type.startsWith('cds.') && !type.startsWith('cds.foundation.')
-}
-
-
 /**
  * Deeply clone the given CSN model and return it.
  * In testMode (or with testSortCsn), definitions are sorted.
@@ -493,12 +622,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 ));
 }
 
@@ -679,11 +808,25 @@ function forAllQueries(query, callback, path = []){
   }
 }
 
-function forAllElements(artifact, artifactName, cb){
+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;
@@ -733,7 +876,7 @@ function hasAnnotationValue(artifact, annotationName, expected = true) {
  * function accepts EDM internal and external options
  *
  * @param {CSN.Element} elementCsn
- * @param {CSN.Options & CSN.ODataOptions} options EDM specific options
+ * @param {ODataOptions} options EDM specific options
  */
 function isEdmPropertyRendered(elementCsn, options) {
   if(options.toOdata)
@@ -783,10 +926,10 @@ function getArtifactDatabaseNameOf(artifactName, namingConvention, csn) {
       throw new Error('Unknown naming convention: ' + namingConvention);
     }
   else {
-    const namespace = csn;
     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 (namespace) {
+      if (csn) {
+        const namespace = String(csn);
         return `${namespace}::${artifactName.substring(namespace.length + 1)}`;
       }
       return artifactName;
@@ -922,11 +1065,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,
@@ -959,7 +1103,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 );
       }
@@ -968,6 +1112,9 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
   }
 
   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] );
@@ -980,8 +1127,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);
@@ -994,10 +1144,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();
       }
     } );
@@ -1383,7 +1537,7 @@ function sortCsnDefinitionsForTests(csn, options) {
   if (!options.testMode)
     return;
   const sorted = Object.create(null);
-  Object.keys(csn.definitions).sort().forEach((name) => {
+  Object.keys(csn.definitions || {}).sort().forEach((name) => {
     sorted[name] = csn.definitions[name];
   });
   csn.definitions = sorted;
@@ -1393,7 +1547,7 @@ function sortCsnDefinitionsForTests(csn, options) {
  * Return an array of non-abstract service names contained in CSN
  *
  * @param {CSN.Model} csn
- * @returns {CSN.Service[]}
+ * @returns {string[]}
  */
 function getServiceNames(csn) {
   let result = [];
@@ -1405,6 +1559,60 @@ 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;
+}
+
+/**
+ * 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} 
+ */
+function getVariableReplacement(ref, options) {
+  if(options && options.variableReplacements) {
+    let replacement = options.variableReplacements;
+    for(let i = 0; i < ref.length; i++) {
+      replacement = replacement[ref[i]];
+      if(replacement === undefined)
+        return null;
+    }
+
+    if(replacement === undefined)
+      return null; // no valid replacement found
+    else if(typeof replacement === 'string')
+      return replacement; // valid replacement
+    else
+      return null; // $user.foo, but we only have configured $user.foo.bar -> error
+  } else {
+    return null;
+  }
+}
 
 module.exports = {
   getUtils,
@@ -1444,4 +1652,7 @@ module.exports = {
   getNamespace,
   sortCsnDefinitionsForTests,
   getServiceNames,
+  isSkipped,
+  walkCsnPath,
+  getVariableReplacement
 };

package/lib/model/enrichCsn.js

@@ -39,16 +39,20 @@ function enrichCsn( csn, options = {} ) {
     params: dictionary,
     enum: dictionary,
     mixin: dictionary,
+    returns: definition,
+    items: definition,
     ref: pathRef,
     type: simpleRef,
     targetAspect: simpleRef,
     target: simpleRef,
     includes: simpleRef,
+    $origin,
     // TODO: excluding
     '@': () => { /* ignore annotations */ },
   }
   setLocations( csn, false, null );
-  const { inspectRef, artifactRef, __getCache_forEnrichCsnDebugging } = csnRefs( csn );
+  const { inspectRef, artifactRef, getOrigin, __getCache_forEnrichCsnDebugging } =
+      csnRefs( csn );
   let $$cacheObjectNumber = 0;   // for debugging
   const csnPath = [];
   if (csn.definitions)
@@ -79,10 +83,19 @@ function enrichCsn( csn, options = {} ) {
     csnPath.pop();
   }
 
+  function definition( parent, prop, obj ) {
+    const origin = getOrigin( obj ); // before standard for implicit protos inside
+    standard( parent, prop, obj );
+    if (obj.$origin === undefined && origin != null)
+      obj._origin = refLocation( origin );
+  }
+
   function dictionary( parent, prop, dict ) {
+    if (!dict)                  // value null for inheritance interruption
+      return;
     csnPath.push( prop );
     for (let name of Object.getOwnPropertyNames( dict )) {
-      standard( dict, name, dict[name] );
+      definition( dict, name, dict[name] );
     }
     if (!Object.prototype.propertyIsEnumerable.call( parent, prop ))
       parent['$'+prop] = dict;
@@ -119,6 +132,25 @@ function enrichCsn( csn, options = {} ) {
     //   parent['_' + prop] = e.toString(); }
   }
 
+  function $origin( parent, prop, ref ) {
+    if (options.testMode) {
+      if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […], not $origin: {…}
+        parent._origin = refLocation( getOrigin( parent, true ) );
+      else if ( ref )
+        standard( parent, prop, ref )
+    }
+    else {
+      try {
+        if (Array.isArray( ref ) || typeof ref === 'string')  // $origin: […], not $origin: {…}
+          parent._origin = refLocation( getOrigin( parent, true ) );
+        else if ( ref )
+          standard( parent, prop, ref )
+      } catch (e) {
+        parent._origin = e.toString();
+      }
+    }
+  }
+
   function pathRef( parent, prop, path ) {
     const { links, art, scope, $env } = (() => {
       if (options.testMode)
@@ -154,10 +186,10 @@ function enrichCsn( csn, options = {} ) {
     csnPath.pop();
   }
 
-  function _cache_debug( obj ) {
+  function _cache_debug( obj, subCache ) {
     if (options.enrichCsn !== 'DEBUG')
       return;
-    const cache = __getCache_forEnrichCsnDebugging( obj );
+    const cache = subCache || __getCache_forEnrichCsnDebugging( obj );
     if (!cache)
       return;
     if (cache.$$objectNumber > 0) {
@@ -180,8 +212,20 @@ function enrichCsn( csn, options = {} ) {
         }
         else if (name[0] !== '$' || !Object.getPrototypeOf( val )) {
           // ‹name›: dictionary of CSN nodes,
-          // ‹$name›: dictionary of cache values if no prototype,
-          obj.$$cacheObject[name] = Object.keys( val ); // TODO: or dict?
+          // ‹$name›: dictionary of cache values if no prototype
+          if (name !== '$aliases') {
+            obj.$$cacheObject[name] = Object.keys( val ); // TODO: or dict?
+          }
+          else {
+            const sub = Object.create(null);
+            for (const n in val) {
+              const alias = val[n];
+              const c = {};
+              _cache_debug( c, alias );
+              sub[n] = c.$$cacheObject;
+            }
+            obj.$$cacheObject[name] = sub;
+          }
         }
         else if (Array.isArray( val )) {
           obj.$$cacheObject[name] = val.map( item => {