@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/model/csnUtils.js

@@ -1,7 +1,8 @@
 'use strict';
 
-const { setProp } = require('../base/model');
 const { csnRefs } = 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 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]
@@ -60,6 +61,7 @@ function getUtils(model) {
     effectiveType,
     get$combined,
     getOrigin,
+    getQueryPrimarySource,
   };
 
   /**
@@ -175,10 +177,10 @@ function getUtils(model) {
       }
     }
 
-      /**
-   * Return the name part of the artifact name - no namespace etc.
-   * @param {string|object} name Absolute name of the artifact
-   */
+    /**
+     * 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;
@@ -190,6 +192,27 @@ function getUtils(model) {
     }
   }
 
+  /**
+   * Return the left-most, primary source of the given query.
+   * @param {*} query Definition's query object
+   */
+  function getQueryPrimarySource(query) {
+    if (!query)
+      return undefined;
+    else if (query.SELECT) {
+      return getQueryPrimarySource(query.SELECT);
+    } else if (query.SET) {
+      return getQueryPrimarySource(query.SET);
+    } else if (query.from) {
+      return getQueryPrimarySource(query.from);
+    } else if (query.ref) {
+      return query;
+    } else if (query.args) {
+      return getQueryPrimarySource(query.args[0]);
+    }
+    return undefined;
+  }
+
 
   /**
    * Create an object to track visited objects identified by a unique string.
@@ -229,7 +252,7 @@ function getUtils(model) {
    * Returns true if an artifact is a structured type
    * or a typedef of a structured type.
    *
-   * @param {CSN.Artifact} obj
+   * @param {object} obj
    */
   function isStructured(obj) {
     return obj.elements ||
@@ -396,7 +419,7 @@ function getUtils(model) {
   function getServiceName(artifactName) {
     for(;;) {
       let idx = artifactName.lastIndexOf('.');
-      if (idx == -1) return null;
+      if (idx === -1) return null;
       artifactName = artifactName.substring(0, idx);
       let artifact = model.definitions[artifactName];
       if (artifact && artifact.kind === 'service') {
@@ -457,8 +480,8 @@ 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
@@ -497,12 +520,12 @@ function getUtils(model) {
    * 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 {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 
+   * @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)
@@ -552,16 +575,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.
@@ -817,11 +830,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;
@@ -854,11 +881,14 @@ function forAllElements(artifact, artifactName, cb){
  * @param {CSN.Artifact} artifact
  * @param {string} annotationName Name of the annotation (including the at-sign)
  * @param {any} expected
+ * @param {boolean} caseInsensitive
  * @returns {boolean}
  */
-function hasAnnotationValue(artifact, annotationName, expected = true) {
+function hasAnnotationValue(artifact, annotationName, expected = true, caseInsensitive = false) {
   if(expected === false)
     return artifact[annotationName] === expected || artifact[annotationName] === null;
+  else if (typeof artifact[annotationName] === 'string' && caseInsensitive === true)
+    return artifact[annotationName].toLowerCase() === expected.toLowerCase();
   else
     return artifact[annotationName] === expected;
 }
@@ -871,7 +901,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)
@@ -921,10 +951,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;
@@ -1048,112 +1078,6 @@ function getElementDatabaseNameOf(elemName, namingConvention) {
   }
 }
 
-
-/**
- * Loop through the model, applying the custom transformations on the node's matching.
- *
- * Each transformer gets:
- * - the parent having the property
- * - the name of the property
- * - the value of the property
- * - the path to the property
- *
- * @param {object} csn CSN to enrich in-place
- * @param {object} customTransformers Map of prop to transform and function to apply
- * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {Boolean} [skipIgnore=true] Wether to skip _ignore elements or not
- * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
- * @returns {object} CSN with transformations applied
- */
-function applyTransformations( csn, customTransformers={}, artifactTransformers=[], skipIgnore = true, options = {} ) {
-  const transformers = {
-    elements: dictionary,
-    definitions: dictionary,
-    actions: dictionary,
-    params: dictionary,
-    enum: dictionary,
-    mixin: dictionary,
-    ref: pathRef,
-    //type: simpleRef,
-    //target: simpleRef,
-    //includes: simpleRef,
-  }
-
-  const csnPath = [];
-  if (csn.definitions)
-    definitions( csn, 'definitions', csn.definitions );
-  return csn;
-
-  function standard( parent, prop, node ) {
-    if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ) || (typeof prop === 'string' && prop.startsWith('@')) || (skipIgnore && node._ignore))
-      return;
-
-    csnPath.push( prop );
-
-    if (Array.isArray(node)) {
-      node.forEach( (n, i) => standard( node, i, n ) );
-    }
-
-    else {
-      for (let name of Object.getOwnPropertyNames( node )) {
-        const trans = transformers[name] || standard;
-        if(customTransformers[name])
-          customTransformers[name](node, name, node[name], csnPath, parent, prop);
-
-        trans( node, name, node[name], csnPath );
-      }
-    }
-    csnPath.pop();
-  }
-
-  function dictionary( node, prop, dict ) {
-    // Allow skipping dicts like actions in forHanaNew
-    if(options.skipDict && options.skipDict[prop])
-      return;
-    csnPath.push( prop );
-    for (let name of Object.getOwnPropertyNames( dict )) {
-      standard( dict, name, dict[name] );
-    }
-    if (!Object.prototype.propertyIsEnumerable.call( node, prop ))
-      setProp(node, '$' + prop, dict);
-    csnPath.pop();
-  }
-
-  function definitions( node, prop, dict ) {
-    csnPath.push( prop );
-    for (let name of Object.getOwnPropertyNames( dict )) {
-      const skip = options && options.skipArtifact && options.skipArtifact(dict[name], name) || false;
-      if(!skip) {
-        artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-        standard( dict, name, dict[name] );
-      }
-    }
-    if (!Object.prototype.propertyIsEnumerable.call( node, prop ))
-      setProp(node, '$' + prop, dict);
-    csnPath.pop();
-  }
-
-  //Keep looping through the pathRef
-  function pathRef( node, prop, path ) {
-    csnPath.push( prop );
-    path.forEach( function step( s, i ) {
-      if (s && typeof s === 'object') {
-        csnPath.push( i );
-        if(options.drillRef) {
-          standard(path, i, s);
-        } else {
-          if (s.args)
-            standard( s, 'args', s.args );
-          if (s.where)
-            standard( s, 'where', s.where );
-        }
-        csnPath.pop();
-      }
-    } );
-    csnPath.pop();
-  }
-}
-
 const _dependencies = Symbol('_dependencies');
 const _dependents = Symbol('_dependents');
 
@@ -1333,38 +1257,6 @@ function mergeOptions(...optionsObjects) {
   }
 }
 
-// Return the name of the top-level artifact surrounding the artifact 'name'
-// in 'model'.
-// We define "top-level artifact" to be an artifact that has either no parent or only
-// ancestors of kind 'namespace'. Note that it is possible for a non-top-level artifact
-// to have a namespace as parent and e.g. a context as grandparent (weird but true).
-// Will return the artifact 'name' if it is a top-level artifact itself, and 'undefined'
-// if there is no artifact surrounding 'name' in the model
-// TODO: to be checked by author: still intended behaviour with 'cds' prefix?
-// TODO: Can this be replaced by getRootArtifactName? Or maybe not rely on namespace-hacking...
-// FIXME: This only works with namespace-hacking, i.e. adding them as artifacts...
-function getTopLevelArtifactNameOf(name, model) {
-  let dotIdx = name.indexOf('.');
-  if (dotIdx == -1) {
-    // No '.' in the name, i.e. no parent - this is a top-level artifact (if it exists)
-    return model.definitions[name] ? name : undefined;
-  }
-  // If the first name part is not in the model, there is nothing to find
-  if (!model.definitions[name.substring(0, dotIdx)]) {
-    return undefined;
-  }
-  // Skip forward through '.'s until finding a non-namespace
-  while (dotIdx != -1 && (!model.definitions[name.substring(0, dotIdx)] || model.definitions[name.substring(0, dotIdx)].kind === 'namespace')) {
-    dotIdx = name.indexOf('.', dotIdx + 1);
-  }
-  if (dotIdx == -1) {
-    // This is a top-level artifact
-    return name;
-  }
-  // The skipped part of 'name' is the top-level artifact name
-  return name.substring(0, dotIdx);
-}
-
 /**
 * If the artifact with the name given is part of a context (or multiple), return the top-most context.
 * Else, return the artifact itself. Namespaces are not of concern here.
@@ -1532,7 +1424,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;
@@ -1542,7 +1434,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 = [];
@@ -1556,8 +1448,8 @@ function getServiceNames(csn) {
 
 /**
  * Check wether the artifact is @cds.persistence.skip
- * 
- * @param {CSN.Artifact} artifact 
+ *
+ * @param {CSN.Artifact} artifact
  * @returns {Boolean}
  */
 function isSkipped(artifact) {
@@ -1566,21 +1458,49 @@ function isSkipped(artifact) {
 
 /**
  * Walk path in the CSN and return the result.
- * 
- * @param {CSN.Model} csn 
- * @param {CSN.Path} path 
+ *
+ * @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]];
+  for(const segment of path){
+    obj = obj[segment];
   }
 
   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(const segment of ref) {
+      replacement = replacement[segment];
+      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,
   cloneCsn,
@@ -1601,12 +1521,12 @@ module.exports = {
   getUnderscoredName,
   getElementDatabaseNameOf,
   applyTransformations,
+  applyTransformationsOnNonDictionary,
   setDependencies,
   isPersistedOnDatabase,
   generatedByCompilerVersion,
   getNormalizedQuery,
   mergeOptions,
-  getTopLevelArtifactNameOf,
   getRootArtifactName,
   getLastPartOfRef,
   getParentNamesOf,
@@ -1621,4 +1541,5 @@ module.exports = {
   getServiceNames,
   isSkipped,
   walkCsnPath,
+  getVariableReplacement
 };

package/lib/model/enrichCsn.js

@@ -7,23 +7,35 @@
 
 // * `File.cds:3:5` if the original CSN has a non-enumerable `$location` property
 //   with value `{file: "File.cds", line: 3, col: 5}`.
-// * `File.cds:3:5-1` if the original CSN has _no_ `$location` property, for an
+// * `File.cds:3:5^` if the original CSN has _no_ `$location` property, for an
 //   inferred member of a main artifact or member with `$location: `File.cds:3:5`;
-//   the number of digits in the `-1` suffix is the member depth.
+//   the number of `^`s in the suffix is the member depth.
 
 // Other enumerable properties in the JSON for non-enumerable properties in the
 // original CSN:
 
-// * `$env` for the non-enumerable `$env` property in the original CSN.
-// * `$elements` for a non-enumerable `elements` property for sub queries.
+// * `$parens`: the number of parentheses provided by the user around an expression
+//   or query if the number is different to the usual (mostly 0, sometimes 1).
+// * `$elements` (in client-style CSN only) for a non-enumerable `elements` property
+//   for sub queries.
 
 // The following properties in the JSON represent the result of the CSN API
 // functions:
 
-// * `_type`, `_includes` and `_targets` have as values the `$locations` of the
+// * `_type`, `_includes` and `_targets` have as values the `$location`s of the
 //   referred artifacts which are returned by function `artifactRef`.
-// * `_links`, `_art` and `_scope` as sibling properties of `ref` have as values
-//   the `$locations` of the artifacts/members returned by function `inspectRef`.
+// * `_links` and `_art` as sibling properties of `ref` have as values the
+//   `$locations` of the artifacts/members returned by function `inspectRef` (`_art`
+//   for ref in `from` only, where it is different to the last item of `_links`).
+// * `_scope` and `_env` as sibling properties of `ref` have (string) values,
+//   returned by function `inspectRef`, giving add/ info about the “ref base”.
+// * `_origin` (in Universal CSN only) has as value the `$location` of the
+//   prototype returned by function getOrigin().
+// * `_test.inspect.csnpath` as sibling property of `ref` has an object value
+//   with properties `_links` and `_scope` of a further `inspectRef` call;
+//   it is only called, with `[‹art›, ...‹csnpath›]` as argument, if `‹art›`,
+//   which is the referred artifact returned by the first `inspectRef` call,
+//   has an annotation `@$test.inspect.csnpath` with array value `‹csnpath›`.
 
 'use strict';
 
@@ -32,13 +44,14 @@ const { locationString } = require('../base/location');
 
 function enrichCsn( csn, options = {} ) {
   const transformers = {
-    // $env: reveal,
     elements: dictionary,
     definitions: dictionary,
     actions: dictionary,
     params: dictionary,
     enum: dictionary,
     mixin: dictionary,
+    returns: definition,
+    items: definition,
     ref: pathRef,
     type: simpleRef,
     targetAspect: simpleRef,
@@ -81,10 +94,20 @@ function enrichCsn( csn, options = {} ) {
     csnPath.pop();
   }
 
+  function definition( parent, prop, obj ) {
+    // call getOrigin() before standard() to set implicit protos inside standard():
+    const origin = handleError( err => err ? err.toString() : getOrigin( obj ) );
+    standard( parent, prop, obj );
+    if (obj.$origin === undefined && !obj.type && 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;
@@ -92,10 +115,10 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function refLocation( art ) {
-    if (art)
+    if (art && typeof art === 'object')
       return art.$location || '<no location>';
     if (!options.testMode)
-      return '<illegal link>';
+      return art || '<illegal link>';
     throw new Error( 'Undefined reference' );
   }
 
@@ -122,33 +145,21 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function $origin( parent, prop, ref ) {
-    if (options.testMode) {
-      if (Array.isArray( ref ))  // $origin: […], not $origin: {…}
+    handleError( err => {
+      if (err)
+        parent._origin = err.toString();
+      else if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […] / "short-ref"
         parent._origin = refLocation( getOrigin( parent ) );
-    }
-    else {
-      try {
-        if (Array.isArray( ref ))  // $origin: […], not $origin: {…}
-          parent._origin = refLocation( getOrigin( parent ) );
-      } catch (e) {
-        parent._origin = e.toString();
-      }
-    }
+      else if ( ref )                                           // $origin: {…}
+        standard( parent, prop, ref );
+    } );
   }
 
-  function pathRef( parent, prop, path ) {
-    const { links, art, scope, $env } = (() => {
-      if (options.testMode)
-        return inspectRef( csnPath );
-      else {
-        try {
-          return inspectRef( csnPath );
-        }
-        catch (e) {
-          return { scope: e.toString() };
-        }
-      }
-    } )();
+  function pathRef( parent, prop, path, inspectionPath = csnPath ) {
+    const inspection = handleError( (err) => {
+      return (err) ? { scope: err.toString() } : inspectRef( inspectionPath );
+    });
+    const { links, art, scope, $env } = inspection;
     if (links)
       parent._links = links.map( l => refLocation( l.art ) );
     if (links && links[links.length-1].art !== art)
@@ -157,6 +168,15 @@ function enrichCsn( csn, options = {} ) {
     if ($env)
       parent._env = $env;
 
+    if (!prop)                  // recursive call for @$test.inspect.csnpath
+      return;
+    const testPath = art && art['@$test.inspect.csnpath'];
+    if (testPath && parent.ref) {
+      const further = {};
+      pathRef( further, null, null, [ inspection, ...testPath ] );
+      parent['_test.inspect.csnpath'] = further;
+    }
+
     csnPath.push( prop );
     path.forEach( function step( s, i ) {
       if (s && typeof s === 'object') {
@@ -171,10 +191,20 @@ function enrichCsn( csn, options = {} ) {
     csnPath.pop();
   }
 
-  function _cache_debug( obj ) {
+  function handleError( callback ) {
+    if (options.testMode)
+      return callback();
+    try {
+      return callback();
+    } catch (err) {
+      return callback( err );
+    }
+  }
+
+  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) {
@@ -197,8 +227,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 => {
@@ -231,12 +273,11 @@ function setLocations( node, prop, loc ) {
     return;
   const isMember = artifactProperties.includes( prop );
   if (!isMember && node.$location) {
-    const value = locationString( node.$location, true );
-    reveal( node, '$location', value );
-    loc = value + '-';
+    loc = locationString( node.$location, true );
+    reveal( node, '$location', loc );
   }
   else if (prop === true) {
-    loc += '1';
+    loc += '^';
     node.$location = loc;
   }
   if (Array.isArray( node )) {