@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/model/csnRefs.js

@@ -59,6 +59,13 @@
 // delete `s` and then still expects inspectRef() to be able to resolve a
 // reference `['s', 'x']`.
 
+// There are currently 3 (SQL) backend issues for which we provide a workaround:
+//
+// - function `resolvePath`: issue with argument `arg` being falsy
+// - function `artifactRef`: issue with non-string ref without definition
+// - function `initColumnElement`: issue with column which is neither `*` nor
+//   a `ref` with sibling `inline`, but still has no corresponding element
+
 // The functions in this module also use an internal cache.  The second call of
 // inspectRef() in the following example might lead to a wrong result or an
 // exception if the assignment to `inspectRef` is not uncommented:
@@ -164,8 +171,8 @@
 // - _effectiveType on def/member/items: cached result of effectiveType()
 // - _origin on def/member/items: the "prototype"
 // - $origin on def/member/items: whether implicit _origin refs have been set for direct members
-// - _parent: not yet used (for debugging)
-//
+// - _parent: currently just use to allow ref to `up_` in anonymous aspect
+//   for managed compositions
 // - _env on non-string path item: environment provided by the ref so far,
 //    next path item is element in it
 // - _ref on non-string `type` or `from` ref, or on alias: the referred def/elem
@@ -181,7 +188,7 @@
 
 const BUILTIN_TYPE = {};
 const { locationString } = require('../base/location');
-const { ModelError, CompilerAssertion } = require("../base/error");
+const { ModelError, CompilerAssertion } = require('../base/error');
 
 // Properties in which artifact or members are defined - next property in the
 // "csnPath" is the name or index of that property; 'args' (its value can be a
@@ -207,7 +214,7 @@ const referenceSemantics = {
   excluding: { lexical: false, dynamic: 'source' },
   expand: { lexical: justDollar, dynamic: 'expand' },   // ...using baseEnv
   inline: { lexical: justDollar, dynamic: 'inline' },   // ...using baseEnv
-  ref_where: { lexical: justDollar , dynamic: 'ref-target'}, // ...using baseEnv
+  ref_where: { lexical: justDollar, dynamic: 'ref-target' }, // ...using baseEnv
   on: { lexical: justDollar, dynamic: 'query' }, // assoc defs, redirected to
   // there are also 'on_join' and 'on_mixin' with default semantics
   orderBy_ref: { lexical: query => query, dynamic: 'query' },
@@ -216,7 +223,7 @@ const referenceSemantics = {
   // refs in ORDER BY expr in UNION not really allowed - only with table alias (of outer queries) or $self
   orderBy_set_expr: { lexical: query => query.$next, dynamic: false },
   // default: { lexical: query => query, dynamic: 'source' }
-}
+};
 
 function justDollar() {
   return null;
@@ -234,23 +241,23 @@ function csnRefs( csn, universalReady ) {
       initDefinition( art );
   }
   // Functions which set the new `baseEnv`:
-  resolveRef.expandInline = function resolve_expandInline( ref, ...args ) {
+  resolveRef.expandInline = function resolveExpandInline( ref, ...args ) {
     return cached( ref, '_env', () => navigationEnv( resolveRef( ref, ...args ).art ) );
-  }
-  resolveRef.ref_where = function resolve_ref_where( pathItem, baseRef, ...args ) {
+  };
+  resolveRef.ref_where = function resolveRefWhere( pathItem, baseRef, ...args ) {
     return cached( pathItem, '_env', () => {
       resolveRef( baseRef, ...args ); // sets _env cache for non-string ref items
       return getCache( pathItem, '_env' );
     } );
-  }
+  };
   return {
     effectiveType,
     artifactRef,
     getOrigin,
     inspectRef,
     queryOrMain,
-    getColumn: ( elem ) => getCache( elem, '_column' ),
-    getElement: ( col ) => getCache( col, '_element' ),
+    getColumn: elem => getCache( elem, '_column' ),
+    getElement: col => getCache( col, '_element' ),
     initDefinition,
     targetAspect,
     __getCache_forEnrichCsnDebugging: obj => cache.get( obj ),
@@ -330,7 +337,7 @@ function csnRefs( csn, universalReady ) {
     // Backend bug workaround, TODO: delete next 2 lines
     if (notFound !== undefined)
       return notFound;
-    throw new ModelError( `Unknown artifact reference: ${typeof ref !== 'string' ? JSON.stringify(ref.ref) : ref}` );
+    throw new ModelError( `Unknown artifact reference: ${ typeof ref !== 'string' ? JSON.stringify(ref.ref) : ref }` );
   }
 
   function artifactPathRef( ref ) {
@@ -364,9 +371,9 @@ function csnRefs( csn, universalReady ) {
     // 3. user-induced redirection (in 'cast') with explicit foreign keys
     // 4. original provided association def inside $origin with explicit foreign keys
     //    (outside $origin like 2)
-    const targetName = refCtx !== 'keys_origin' && art.target
-                    || art.$origin && art.$origin.target
-                    || art.cast.target;
+    const targetName = refCtx !== 'keys_origin' && art.target ||
+                    art.$origin && art.$origin.target ||
+                    art.cast.target;
     const target = csn.definitions[targetName];
     initDefinition( target );
     return target;
@@ -387,8 +394,8 @@ function csnRefs( csn, universalReady ) {
       const { $location } = art;
       const location = $location &&
             (typeof $location === 'string' ? $location : locationString( $location ));
-      const def = Object.keys( art ).join('+') + (location ? ':' + location : '');
-      throw new Error( `Inspecting non-initialized CSN node {${def}}` );
+      const def = Object.keys( art ).join('+') + (location ? `:${ location }` : '');
+      throw new Error( `Inspecting non-initialized CSN node {${ def }}` );
     }
     const step = getCache( art, '$origin$step' );
     if (!step)
@@ -428,7 +435,7 @@ function csnRefs( csn, universalReady ) {
       return effectiveType( art ).items;
     if (step.target)
       return targetAspect( effectiveType( art ) );
-    throw Error( `Illegal navigation step ${ Object.keys(step)[0]}` );
+    throw Error( `Illegal navigation step ${ Object.keys(step)[0] }` );
   }
 
   function effectiveArtFor( art, property ) {
@@ -529,16 +536,17 @@ function csnRefs( csn, universalReady ) {
       return resolvePath( path, csn.definitions[head], null, 'global', semantics.assoc );
 
 
-    let qcache = query && cache.get( query.projection || query );
+    const qcache = query && cache.get( query.projection || query );
     // first the lexical scopes (due to query hierarchy) and $magic: ---------
     if (semantics.lexical !== false) {
       const tryAlias = path.length > 1 || ref.expand || ref.inline;
       let ncache = qcache && (semantics.lexical ? semantics.lexical( qcache ) : qcache);
       while (ncache) {
         const alias = tryAlias && ncache.$aliases[head];
-        if (alias)
+        if (alias) {
           return resolvePath( path, alias._select || alias._ref, null,
                               'alias', ncache.$queryNumber );
+        }
         const mixin = ncache._select.mixin && ncache._select.mixin[head];
         if (mixin && {}.hasOwnProperty.call( ncache._select.mixin, head )) {
           setCache( mixin, '_parent', qcache._select );
@@ -559,8 +567,14 @@ function csnRefs( csn, universalReady ) {
         const target = assocTarget( parent, refCtx );
         return resolvePath( path, target.elements[head], target, 'target' );
       }
-      if (baseEnv)                // ref-target (filter condition), expand, inline
-        return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
+      if (baseEnv) {               // ref-target (filter condition), expand, inline
+        if (semantics.dynamic !== 'query')
+          return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
+        // in an ON condition of an association inside inner expand/inline:
+        const elemParent = getCache( parent, '_element' );
+        if (elemParent)         // expand in expand
+          return resolvePath( path, elemParent.elements[head], null, 'query' );
+      }
       if (!query) {                // outside queries - TODO: items?
         let art = parent.elements[head];
         // Ref to up_ in anonymous aspect
@@ -582,11 +596,11 @@ function csnRefs( csn, universalReady ) {
         const alias = qcache.$aliases[name];
         const found = alias.elements[head];
         if (found)
-          return resolvePath( path, found, alias._ref, 'source', name )
+          return resolvePath( path, found, alias._ref, 'source', name );
       }
     }
     // console.log(query.SELECT,qcache,qcache.$next,main)
-    throw new ModelError ( `Path item 0=${ head } refers to nothing, refCtx: ${ refCtx }` );
+    throw new ModelError( `Path item 0=${ head } refers to nothing, refCtx: ${ refCtx }` );
   }
 
   /**
@@ -601,7 +615,7 @@ function csnRefs( csn, universalReady ) {
     const links = path.map( (_v, idx) => ({ idx }) );
     // TODO: backends should be changed to enable uncommenting:
     // if (!art)    // does not work with test3/Associations/KeylessManagedAssociation/
-    //   throw new ModelError ( `Path item ${ 0 }=${ pathId( path[0] ) } refers to nothing, scope: ${ scope }`);
+    //   throw new ModelError( `Path item 0=${ pathId( path[0] ) } refers to nothing, scope: ${ scope }`);
     links[0].art = art;
     for (let i = 1; i < links.length; ++i) { // yes, starting at 1, links[0] is set above
       parent = navigationEnv( art, staticAssoc );
@@ -610,9 +624,9 @@ function csnRefs( csn, universalReady ) {
         setCache( path[i - 1], '_env', parent );
       art = parent.elements[pathId( path[i] )];
       if (!art) {
-        const env = links[i - 1].env;
+        const { env } = links[i - 1];
         const loc = env.name && env.name.$location || env.$location;
-        throw new ModelError ( `Path item ${ i }=${ pathId( path[i] ) } on ${ locationString( loc ) } refers to nothing` );
+        throw new ModelError( `Path item ${ i }=${ pathId( path[i] ) } on ${ locationString( loc ) } refers to nothing` );
       }
       links[i].art = art;
     }
@@ -626,11 +640,15 @@ function csnRefs( csn, universalReady ) {
         parent = null;
       }
       if (typeof last !== 'string')
-        setCache( last, '_env', env )
+        setCache( last, '_env', env );
     }
     return (extraInfo && scope !== 'global')
-      ? { links, art, parent, scope, $env: extraInfo }
-      : { links, art, parent, scope };
+      ? {
+        links, art, parent, scope, $env: extraInfo,
+      }
+      : {
+        links, art, parent, scope,
+      };
   }
 
   /**
@@ -649,7 +667,7 @@ function csnRefs( csn, universalReady ) {
       if (query.ref) {          // ref in from
         // console.log('SQ:',query,cache.get(query))
         const as = query.as || implicitAs( query.ref );
-        const _ref = cached( query, '_from', artifactFromRef )
+        const _ref = cached( query, '_from', artifactFromRef );
         getCache( fromSelect, '$aliases' )[as] = { _ref, elements: _ref.elements, _parent: query };
       }
       else {
@@ -749,8 +767,9 @@ function csnRefs( csn, universalReady ) {
       hidden = {};
       cache.set( obj, hidden );
     }
-    else if (hidden[prop] !== undefined)
+    else if (hidden[prop] !== undefined) {
       return hidden[prop];
+    }
     const val = calc( obj );
     hidden[prop] = val;
     return val;
@@ -759,7 +778,7 @@ function csnRefs( csn, universalReady ) {
 
 // Return value of a query SELECT for the query node, or the main artifact,
 // i.e. a value with an `elements` property.
-// TODO: only used in forHanaNew - move somewhere else
+// TODO: only used in forRelationalDB - move somewhere else
 /**
  * @param {object} query node (object with SET or SELECT property)
  * @param {object} main definition
@@ -830,7 +849,7 @@ function traverseFrom( from, fromSelect, parentQuery, callback ) {
 
 function traverseExpr( expr, parentQuery, callback ) {
   if (expr.SELECT || expr.SET)
-    traverseQuery( expr, null, parentQuery, callback )
+    traverseQuery( expr, null, parentQuery, callback );
   for (const prop of [ 'args', 'xpr' ]) {
     // all properties which could have sub queries (directly or indirectly),
     const val = expr[prop];
@@ -842,7 +861,7 @@ function traverseExpr( expr, parentQuery, callback ) {
 }
 
 function traverseDef( node, parent, kind, name, callback ) {
-  callback ( node, parent, kind, name );
+  callback( node, parent, kind, name );
   if (node.params) {
     for (const n of Object.keys( node.params ))
       traverseType( node.params[n], node, 'param', n, callback );
@@ -852,32 +871,32 @@ function traverseDef( node, parent, kind, name, callback ) {
   traverseType( node, true, kind, name, callback );
   if (node.actions) {
     for (const n of Object.keys( node.actions ))
-      traverseDef( node.actions[n], node, 'action', n, callback )
+      traverseDef( node.actions[n], node, 'action', n, callback );
   }
 }
 
 function traverseType( node, parent, kind, name, callback ) {
   if (parent !== true)
-    callback ( node, parent, kind, name );
+    callback( node, parent, kind, name );
   const target = targetAspect( node );
   if (target && typeof target === 'object' && target.elements) {
-    callback ( target, node, 'target', true );
+    callback( target, node, 'target', true );
     node = target;
   }
   else if (node.items) {
     let items = 0;
     while (node.items) {
-      callback ( node.items, node, 'items', ++items );
+      callback( node.items, node, 'items', ++items );
       node = node.items;
     }
   }
   if (node.elements) {
     for (const n of Object.keys( node.elements ))
-      traverseDef( node.elements[n], node, 'element', n, callback )
+      traverseDef( node.elements[n], node, 'element', n, callback );
   }
   if (node.enum) {
     for (const n of Object.keys( node.enum ))
-      traverseDef( node.enum[n], node, 'enum', n, callback )
+      traverseDef( node.enum[n], node, 'enum', n, callback );
   }
 }
 
@@ -901,14 +920,19 @@ function startCsnPath( csnPath, csn ) {
   const head = csnPath[0];
   if (typeof head !== 'string') {
     const { main, parent, art } = head;
-    return { index: 1, main, parent, art };
+    return {
+      index: 1, main, parent, art,
+    };
   }
-  if (csnPath.length < 2 || csnPath[0] !== 'definitions')
-    throw new CompilerAssertion( 'References outside definitions not supported yet');
-  const art = csn.definitions[csnPath[1]];
-  return { index: 2, main: art, parent: null, art };
+  if (csnPath.length < 2 || csnPath[0] !== 'definitions' && csnPath[0] !== 'vocabularies')
+    throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet');
+  const art = csn[csnPath[0]][csnPath[1]];
+  return {
+    index: 2, main: art, parent: null, art,
+  };
 }
 
+
 /**
  * @param {CSN.Path} csnPath
  * @param {CSN.Model} csn
@@ -917,12 +941,15 @@ function startCsnPath( csnPath, csn ) {
 function analyseCsnPath( csnPath, csn, resolve ) {
   /** @type {object} */
   let query = null;
+  /** @type {any} */
   let refCtx = null;
   /** @type {boolean|string|number} */
   let isName = false;
   let baseRef = null;
   let baseEnv = null;
-  let { index, main, parent, art } = startCsnPath( csnPath, csn );
+  let {
+    index, main, parent, art,
+  } = startCsnPath( csnPath, csn );
   let obj = art;
 
   for (; index < csnPath.length; index++) {
@@ -951,7 +978,9 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     }
     else if (artifactProperties.includes( String(prop) )) {
       if (refCtx === 'target' || refCtx === 'targetAspect') { // with 'elements'
-        main = art = obj;       // $self refers to the anonymous aspect
+        // $self refers to the anonymous aspect
+        main = obj;
+        art = obj;
         parent = null;
       }
       isName = prop;
@@ -981,8 +1010,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
           baseEnv = resolve.expandInline( obj, refCtx, main, query, parent, baseEnv );
         refCtx = prop;
       }
-      if (prop === 'expand')
-        isName = prop;
+      isName = prop;
     }
     else if (prop === 'on') {
       if (refCtx === 'from')