@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/model/api.js

@@ -15,7 +15,7 @@
  * - the ‹property name› (might be useful if the same function is used for several props)
  */
 const defaultFunctions = {
-  '@': () => {},                // do not traverse annotation assignments
+  '@': () => { /* do not traverse annotation assignments */ },
   args: dictionary,
   elements: dictionary,
   enum: dictionary,
@@ -23,7 +23,7 @@ const defaultFunctions = {
   actions: dictionary,
   mixin: dictionary,
   definitions: dictionary,
-  '$': () => {},                // do not traverse properties starting with '$'
+  '$': () => { /*  do not traverse properties starting with '$' */},
 }
 
 /**

package/lib/model/csnRefs.js

@@ -225,17 +225,19 @@ function csnRefs( csn ) {
     const cachedType = getCache( art, '_effectiveType' );
     if (cachedType !== undefined)
       return cachedType;
-    else if (!art.type && !art.$origin ||
-             art.elements || art.target || art.targetAspect || art.enum)
-      return setCache( art, '_effectiveType', art );
 
     const chain = [];
-    while (getCache( art, '_effectiveType' ) === undefined && (art.type || art.$origin) &&
+    let origin;
+    while (getCache( art, '_effectiveType' ) === undefined &&
+           (origin = cached( art, '_origin', getOriginRaw )) &&
            !art.elements && !art.target && !art.targetAspect && !art.enum && !art.items) {
       chain.push( art );
       setCache( art, '_effectiveType', 0 ); // initial setting in case of cycles
-      art = (art.$origin) ? getOrigin( art ) : artifactRef( art.type, BUILTIN_TYPE );
+      art = origin;
     }
+    if (!chain.length)
+      return setCache( art, '_effectiveType', art );
+
     if (getCache( art, '_effectiveType' ) === 0)
       throw new Error( 'Circular type reference');
     const type = getCache( art, '_effectiveType' ) || art;
@@ -251,10 +253,16 @@ function csnRefs( csn ) {
     // here, we do not care whether it is semantically ok to navigate into sub
     // elements of array items (that is the task of the core compiler /
     // semantic check)
-    while (type.items)
+    while (type.items) {
+      cached( type, '$origin', _a => setImplicitOrigin( type, origin ) );
       type = effectiveType( type.items );
+    }
     // cannot navigate along targetAspect!
-    return (type.target) ? csn.definitions[type.target] : type;
+    const env = (type.target) ? csn.definitions[type.target] : type;
+    const origin = cached( env, '_origin', getOriginRaw );
+    if (origin && origin !== BUILTIN_TYPE)
+      cached( env, '$origin', _a => setImplicitOrigin( env, origin ) );
+    return env;
   }
 
   /**
@@ -279,38 +287,109 @@ function csnRefs( csn ) {
   function artifactPathRef( ref ) {
     const [ head, ...tail ] = ref.ref;
     let art = csn.definitions[pathId( head )];
-    for (const elem of tail)
-      art = navigationEnv( art ).elements[pathId( elem )];
+    for (const elem of tail) {
+      const env = navigationEnv( art );
+      art = env.elements[pathId( elem )];
+    }
     return art;
   }
 
-  function getOrigin( def ) {
-    const art = cached( def, '_origin', originPathRef );
-    if (art)
-      return art;
-    throw new Error( 'Undefined origin reference' );
+  function getOrigin( art, alsoType ) {
+    const origin = cached( art, '_origin', getOriginRaw );
+    if (origin && origin !== BUILTIN_TYPE)
+      cached( art, '$origin', _a => setImplicitOrigin( art, origin ) );
+    return art.type && !alsoType ? undefined : origin;
   }
 
-  function originPathRef( def ) {
-    const [ head, ...tail ] = def.$origin;
-    let art = csn.definitions[head];
-    for (const elem of tail)
-      art = originNavigation( art, elem );
-    return art;
+  function getOriginRaw( art ) {
+    if (art.type)               // TODO: make robust against "linked" = only direct
+      return artifactRef( art.type, BUILTIN_TYPE );
+    if (!art.$origin)           // implicit $origin should have been set
+      return null;
+    // art.$origin must not be a string here - shortened refs should already
+    // have been used to set the _origin cache
+    if (!Array.isArray( art.$origin )) // anonymous prototype in $origin
+      return cached( art.$origin, '_origin', getOriginRaw );
+    const [ head, ...tail ] = art.$origin;
+    let origin = csn.definitions[head];
+    // allow shorter $origin ref for actions/functions, just using a string:
+    let isAction = art.kind === 'action' || art.kind === 'function';
+    for (const elem of tail) {
+      origin = originNavigation( origin, elem, isAction );
+      isAction = false;
+    }
+    return origin;
   }
 
-  function originNavigation( art, elem ) {
+  function originNavigation( art, elem, isAction ) {
     if (typeof elem !== 'string') {
       if (elem.action)
-        return art.actions[elem.action]
+        return art.actions[elem.action];
       if (elem.param)
-        return (elem.param ? art.params[elem.param] : art.returns);
+        return art.params[elem.param];
+      if (elem.returns)
+        return art.returns;
     }
-    if (art.returns)
+    if (isAction)
+      return art.actions[elem];
+    // TODO: if we use effectiveType(), we might have more implicit prototypes
+    // we might then need a function like effectiveArtifact,
+    // which cares about actions/params
+    // let origin = cached( art, '_origin', getOriginRaw );
+    // while (art.items) {
+    //   cached( art, '$origin', _a => setImplicitOrigin( art, origin ) );
+    //   art = art.items;
+    //   origin = cached( art, '_origin', getOriginRaw );
+    // }
+    // if (origin)
+    //   cached( art, '$origin', _a => setImplicitOrigin( art, origin ) );
+    // console.log(art)
+    return (art.elements || art.enum || targetAspect( art ).elements)[elem];
+  }
+
+  function targetAspect( art ) {
+    const { $origin } = art;
+    return art.targetAspect ||
+      $origin && typeof $origin === 'object' && !Array.isArray( $origin ) && $origin.target ||
+      art.target;
+  }
+
+  // From the current CSN object, set implicit origin for the next navigation step
+  function setImplicitOrigin( art, origin ) {
+    setMembersImplicit( art.actions, origin.actions );
+    setMembersImplicit( art.params, origin.params );
+    if (art.returns) {
       art = art.returns;
-    while (art.items)
+      if (art.type || typeof art.$origin === 'object') // null, […], {…}
+        return true;            // not implicit or shortened
+      origin = effectiveType( origin.returns );
+      setCache( art, '_origin', origin );
+      return true;
+    }
+    while (art.items) {
       art = art.items;
-    return (art.elements || art.enum || (art.targetAspect || art.target).elements)[elem];
+      if (art.type || typeof art.$origin === 'object') // null, […], {…}
+        return true;            // not implicit or shortened
+      origin = effectiveType( origin.items );
+      setCache( art, '_origin', origin );
+    }
+    setMembersImplicit( art.elements, origin.elements );
+    // The enum base type is _not_ where we find the origins of the enum symbols.
+    // A derived type of an enum type with individual annotations on a symbol
+    // has both 'type' and '$origin'.
+    if (!art.type || art.$origin)
+      setMembersImplicit( art.enum, origin.enum );
+    return true;
+  }
+
+  function setMembersImplicit( members, originMembers ) {
+    if (!members)
+      return;
+    for (const name in members) {
+      const elem = members[name];
+      if (!elem.type && typeof elem.$origin !== 'object') // undefined or string
+        setCache( elem, '_origin', originMembers[elem.$origin || name] || false );
+    }
   }
 
   /**
@@ -371,6 +450,9 @@ function csnRefs( csn ) {
     if (semantics.dynamic === 'global' || ref.global)
       return resolvePath( path, csn.definitions[head], 'global', refCtx === 'from' );
 
+    const origin = cached( main, '_origin', getOriginRaw )
+    if (origin)
+      cached( main, '$origin', _a => setImplicitOrigin( main, origin ) );
     cached( main, '$queries', allQueries );
     let qcache = query && cache.get( query.projection || query );
     // BACKEND ISSUE: you cannot call csnRefs(), inspect some refs, change the
@@ -387,7 +469,7 @@ function csnRefs( csn ) {
       while (cache) {
         const alias = tryAlias && cache.$aliases[head];
         if (alias)
-          return resolvePath( path, alias._select || alias, 'alias', cache.$queryNumber );
+          return resolvePath( path, alias._select || alias._ref, 'alias', cache.$queryNumber );
         const mixin = cache._select.mixin && cache._select.mixin[head];
         if (mixin && {}.hasOwnProperty.call( cache._select.mixin, head ))
           return resolvePath( path, mixin, 'mixin', cache.$queryNumber );
@@ -405,7 +487,7 @@ function csnRefs( csn ) {
       // not selecting the corresponding element for a select column works,
       // because explicit keys can only be provided with explicit redirection
       // target
-      const target = csn.definitions[parent.target || parent.cast.target];
+      const target = csn.definitions[parent.target || parent.$origin && parent.$origin.target || parent.cast.target];
       return resolvePath( path, target.elements[head], 'target' );
     }
     if (baseEnv)                // ref-target (filter condition), expand, inline
@@ -481,7 +563,8 @@ function csnRefs( csn ) {
       if (query.ref) {          // ref in from
         // console.log('SQ:',query,cache.get(query))
         const as = query.as || implicitAs( query.ref );
-        getCache( fromSelect, '$aliases' )[as] = fromRef( query );
+        const _ref = fromRef( query );
+        getCache( fromSelect, '$aliases' )[as] = { _ref, elements: _ref.elements };
       }
       else {
         const qcache = getQueryCache( parentQuery );
@@ -517,7 +600,7 @@ function csnRefs( csn ) {
   function getQueryCache( parentQuery ) {
     if (!parentQuery)
       return { $aliases: Object.create(null) };
-    const pcache = cache.get( parentQuery );
+    const pcache = cache.get( parentQuery.projection || parentQuery );
     if (!parentQuery.SET)       // SELECT / projection: real sub query
       return { $aliases: Object.create(null), $next: pcache };
     // the parent query is a SET: that is not a sub query
@@ -607,7 +690,7 @@ function queryOrMain( query, main ) {
  *
  * @param {CSN.Query} query
  * @param {CSN.QuerySelect} fromSelect
- * @param {CSN.Query} parentQuery 
+ * @param {CSN.Query} parentQuery
  * @param {(query: CSN.Query&CSN.QueryFrom, select: CSN.QuerySelectEnriched) => void} callback
  */
 function traverseQuery( query, fromSelect, parentQuery, callback ) {
@@ -632,8 +715,9 @@ function traverseQuery( query, fromSelect, parentQuery, callback ) {
 
 /**
  * @param {CSN.QueryFrom} from
- * @param {CSN.QuerySelect} select
- * @param {(from: CSN.QueryFrom, select: CSN.QuerySelect) => void} callback
+ * @param {CSN.QuerySelect} fromSelect
+ * @param {CSN.Query} parentQuery
+ * @param {(from: CSN.QueryFrom, select: CSN.QuerySelect, parentQuery: CSN.Query) => void} callback
  */
 function traverseFrom( from, fromSelect, parentQuery, callback ) {
   if (from.ref) {

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]
@@ -457,8 +458,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 +498,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 +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.
@@ -817,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;
@@ -871,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)
@@ -921,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;
@@ -1048,109 +1053,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 ) {
-    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');
 
@@ -1529,7 +1431,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;
@@ -1539,7 +1441,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 = [];
@@ -1553,8 +1455,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) {
@@ -1563,9 +1465,9 @@ 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) {
@@ -1578,6 +1480,34 @@ function walkCsnPath(csn, path) {
   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,
   cloneCsn,
@@ -1598,6 +1528,7 @@ module.exports = {
   getUnderscoredName,
   getElementDatabaseNameOf,
   applyTransformations,
+  applyTransformationsOnNonDictionary,
   setDependencies,
   isPersistedOnDatabase,
   generatedByCompilerVersion,
@@ -1618,4 +1549,5 @@ module.exports = {
   getServiceNames,
   isSkipped,
   walkCsnPath,
+  getVariableReplacement
 };