@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/compiler/propagator.js

@@ -5,10 +5,10 @@
 const {
   forEachDefinition,
   forEachMember,
-  setProp,
+  forEachGeneric,
   isDeprecatedEnabled,
 } = require( '../base/model');
-const { linkToOrigin, withAssociation } = require('./utils');
+const { setLink, linkToOrigin, withAssociation } = require('./utils');
 // const { refString } = require( '../base/messages')
 
 function propagate( model ) {
@@ -19,37 +19,36 @@ function propagate( model ) {
     '@cds.persistence.calcview': never,
     '@cds.persistence.udf': never,
     '@cds.persistence.skip': notWithPersistenceTable,
-    '@sql.prepend': never,
     '@sql.append': never,
+    '@sql.prepend': never,
+    '@sql.replace': never,
     '@Analytics.hidden': never,
     '@Analytics.visible': never,
     '@cds.autoexpose': onlyViaArtifact,
     '@cds.autoexposed': never,  // in case people set it themselves
     '@cds.redirection.target': never,
     '@fiori.draft.enabled': onlyViaArtifact,
-    '@': withKind,              // always except in 'returns' and 'items'
-    doc: withKind,              // always except in 'returns' and 'items'
+    '@': annotation,            // always except in 'returns' and 'items'
+    doc: annotation,            // always except in 'returns' and 'items'
     default: withKind,          // always except in 'returns' and 'items'
-    virtual: notViaType,
-    notNull,                    // a variant of notViaType()
+    virtual,
+    notNull,
     targetElement: onlyViaParent, // in foreign keys
     value: onlyViaParent,      // enum symbol value
     // masked: special = done in definer
     // key: special = done in resolver
     // actions: struct includes & primary source = in definer/resolver
-    type: always,
+    type: notWithExpand,
     length: always,
     precision: always,
     scale: always,
     srid: always,
     localized: always,
-    target: always,
-    targetAspect: always,
-    cardinality: always,
-    on: ( prop, target, source ) => {
-      target[prop] = source[prop];
-    }, // TODO: get rid of this soon!
-    foreignKeys: expensive,    // actually always, but dictionary copy
+    target: notWithExpand,
+    targetAspect: notWithExpand,
+    cardinality: notWithExpand,
+    on: notWithExpand,
+    foreignKeys: expensive,    // includes "notWithExpand", dictionary copy
     items,
     elements: expensive,
     enum: expensive,
@@ -58,8 +57,17 @@ function propagate( model ) {
   };
   const { options } = model;
   const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  // eslint-disable-next-line max-len
+  const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, 'oldVirtualNotNullPropagation' );
 
   forEachDefinition( model, run );
+
+  const { warning, throwWithError } = model.$messageFunctions;
+  // TODO: move 'virtual' handling/checks to resolver if
+  //       'deprecated.oldVirtualNotNullPropagation' is gone
+  if (!oldVirtualNotNullPropagation) // check would always be right, but to be ultra compatible…
+    forEachDefinition( model, checkVirtual );
+  throwWithError();
   return model;
 
   function run( art ) {
@@ -109,6 +117,9 @@ function propagate( model ) {
   function runMembers( art ) {
     // console.log('MEMBERS:',refString(art), art.elements ? Object.keys(art.elements) : 0)
     forEachMember( art, run ); // after propagation in parent!
+    // propagate to sub query elements even if not requested:
+    if (art.$queries)
+      art.$queries.forEach( run );
     let obj = art;
     if (art.returns) {
       obj = art.returns;
@@ -116,12 +127,13 @@ function propagate( model ) {
     }
     if (obj.items)
       run( obj.items );
-    setProp( art, '_status', 'propagated' );
+    setLink( art, '_status', 'propagated' );
   }
 
   function step({ target, source }) {
-    // console.log('PROPS:',source&&refString(source),'->',refString(target))
-    const viaType = target.type && !target.type.$inferred;
+    // console.log('PROPS:',source&&source.name,'->',target.name)
+    const viaType = target.type && // TODO: falsy $inferred value instead 'cast'?
+          (!target.type.$inferred || target.type.$inferred === 'cast');
     const keys = Object.keys( source );
     for (const prop of keys) {
       if (prop in target)       // TODO: warning with competing props from multi-includes
@@ -130,8 +142,10 @@ function propagate( model ) {
       if (transformer)
         transformer( prop, target, source, viaType );
     }
-    // propagate NOT NULL and VIRTUAL from sub elements:
-    if (target.$inferred !== 'proxy' &&
+    // propagate NOT NULL and VIRTUAL from sub elements with
+    // 'deprecated.oldVirtualNotNullPropagation':
+    if (oldVirtualNotNullPropagation &&
+        target.$inferred !== 'proxy' &&
         target.kind === 'element' && source.kind === 'element') {
       let elem = source;        // the outer element
       while (elem._parent.kind === 'element')
@@ -143,7 +157,7 @@ function propagate( model ) {
           props.virtual( 'virtual', target, elem );
       }
     }
-    // setProp( target, '_status', 'shallow-propagated' );
+    // setLink( target, '_status', 'shallow-propagated' );
   }
 
   function never() { /* no-op: don't propagate */ }
@@ -154,12 +168,16 @@ function propagate( model ) {
       target[prop] = [ ...val ];
       target[prop].$inferred = 'prop';
     }
-    else if ('_artifact' in val) {
-      target[prop] = Object.assign( { $inferred: 'prop' }, val );
-      setProp( target[prop], '_artifact', val._artifact );
-    }
     else {
-      target[prop] = Object.assign( { $inferred: 'prop' }, val );
+      target[prop] = Object.assign( {}, val, { $inferred: 'prop' } );
+      if ('_artifact' in val)
+        setLink( target[prop], '_artifact', val._artifact );
+      if ('_outer' in val)
+        setLink( target[prop], '_outer', val._outer );
+      if ('_parent' in val)
+        setLink( target[prop], '_parent', val._parent );
+      if ('_main' in val)
+        setLink( target[prop], '_main', val._main );
     }
   }
 
@@ -178,10 +196,18 @@ function propagate( model ) {
 
   // Expensive properties are not really propagated if they can be directly
   // accessed at their type being a main artifact
+  // Expensive properties are also not propagated with `expand`:
+  // * `elements`: the compiler calculates its own `elements` for a structure
+  //   ref with `expand`.
+  // * `params`: no element has parameters
+  // * `enum`: an enum cannot be used with `expand`
+  // * `keys`: should also not be propagated with `expand`
   function expensive( prop, target, source ) {
     // console.log(prop,source.name,'->',target.kind,target.name);
     if (source.kind === 'builtin')
       return;
+    if (target.expand)          // do not propagate `keys` with expand
+      return;
     if (prop !== 'foreignKeys' && availableAtType( prop, target, source ))
       // foreignKeys must always be copied with target to avoid any confusion
       // whether we have to generated implicit keys
@@ -200,47 +226,88 @@ function propagate( model ) {
     }
   }
 
-  function notViaType( prop, target, source, viaType ) {
-    if (!viaType)
-      always( prop, target, source );
-  }
-
-  function onlyViaArtifact( prop, target, source ) {
-    if (target.kind) {           // not in 'returns' and 'items'
-      const from = target._from && target._from[0].path;
-      if (!(from ? from[from.length - 1]._artifact : source)._main)
-        always( prop, target, source );
-    }
-  }
-
   function onlyViaParent( prop, target, source ) {
     if (target.$inferred === 'proxy' || target.$inferred === 'expand-element')
       // assocs and enums do not have 'include'
       always( prop, target, source );
   }
 
+  function notWithExpand( prop, target, source ) {
+    if (!target.expand || prop === 'type' && source.elements)
+      always( prop, target, source );
+  }
+
   function notWithPersistenceTable( prop, target, source ) {
     const tableAnno = target['@cds.persistence.table'];
     if (!tableAnno || tableAnno.val === null)
+      annotation( prop, target, source );
+  }
+
+  function annotation( prop, target, source ) {
+    const anno = source[prop];
+    if (anno.val !== null)
       withKind( prop, target, source );
   }
 
+  function onlyViaArtifact( prop, target, source ) {
+    const from = target._from && target._from[0].path;
+    if (!(from ? from[from.length - 1]._artifact : source)._main)
+      annotation( prop, target, source );
+  }
+
   function withKind( prop, target, source ) {
     if (target.kind && (!target._parent || target._parent.returns !== target))
       always( prop, target, source ); // not in 'returns' and 'items'
   }
 
   function notNull( prop, target, source, viaType ) {
-    if (!(viaType || target.value && withAssociation( target.value, targetMinZero )))
+    // Really "reset" NOT NULL when ref has assoc with cardinality min: 0 (TODO: Universal CSN)
+    if (oldVirtualNotNullPropagation && viaType)
+      return;                   // strange propagation not supported with Universal CSN
+    if (target.value && withAssociation( target.value, targetMinZero ))
+      target[prop] = { $inferred: 'NULL', val: undefined }; // set null value in Universal CSN
+    // $inferred: 'NULL' is only an issue for sub elements with a 'value' property;
+    // it only exists with nested projections, i.e. never with deprecated option enabled
+    else
+      always( prop, target, source );
+  }
+
+  function virtual( prop, target, source, viaType ) {
+    if (!viaType)
       always( prop, target, source );
+    else if (!oldVirtualNotNullPropagation) // NULL would block strange propagation to sub element
+      target[prop] = { $inferred: 'NULL', val: undefined }; // set null value in Univeral CSN
+  }
+
+  function checkVirtual( view ) {
+    if (view.query)
+      forEachGeneric( view, 'elements', checkNonVirtualElement );
+  }
+
+  function checkNonVirtualElement( elem ) {
+    // Not enough at all, but so are the current checks - a complete expression
+    // must be checked.  Here we just check what might have worked before.
+    // TODO: Propagate 'virtual' in resolver if 'deprecated.oldVirtualNotNullPropagation' is gone.
+    const path = !elem.virtual && elem.value && elem.value.path;
+    if (!path || path.broken)
+      return;
+    for (const item of path) {
+      const art = item && item._artifact;
+      if (art && art.virtual && art.virtual.val) {
+        warning( 'def-missing-virtual', [ item.location, elem ], { art, keyword: 'virtual' },
+                 // eslint-disable-next-line max-len
+                 'Prepend $(KEYWORD) to current select item - referred element $(ART) is virtual which is not inherited' );
+        return;
+      }
+    }
   }
 
   function returns( prop, target, source, ok ) {
     if (ok || target.$inferred === 'proxy' || target.$inferred === 'include' ) {
       target[prop] = { $inferred: 'proxy' };
       setEffectiveType( target[prop], source[prop] );
-      setProp( target[prop], '_origin', source[prop] );
-      setProp( target[prop], '_outer', target._outer || target ); // for setMemberParent
+      setLink( target[prop], '_origin', source[prop] );
+      setLink( target[prop], '_outer', target._outer || target ); // for setMemberParent
     }
   }
 
@@ -262,7 +329,8 @@ function targetMinZero( art ) {
 
 function getOrigin( art ) {
   if (art._origin)
-    return !art.expand && art._origin;
+    // Do not consider _origin if due to expand of table alias ref
+    return (!art.expand || art._origin.kind === 'element') && art._origin;
   // Remark: a column with an 'inline' is never an element -> no need to check
   // art.inline
   if (art._from && art._from.length) { // query
@@ -273,7 +341,7 @@ function getOrigin( art ) {
       : tabref;
   }
 
-  return (art.type && !art.type.$inferred)
+  return (art.type && (!art.type.$inferred || art.type.$inferred === 'cast'))
     ? art.type._artifact
     : art._origin;
 }
@@ -281,13 +349,13 @@ function getOrigin( art ) {
 function checkAndSetStatus( art ) {
   if (art._status === 'propagated' || art._status === 'propagating')
     return false;
-  setProp( art, '_status', 'propagating' );
+  setLink( art, '_status', 'propagating' );
   return true;
 }
 
 function setEffectiveType( target, source ) {
   if ('_effectiveType' in source)
-    setProp( target, '_effectiveType', source._effectiveType);
+    setLink( target, '_effectiveType', source._effectiveType);
 }
 
 module.exports = {