@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/tweak-assocs.js

@@ -14,14 +14,16 @@ const {
   setArtifactLink,
   linkToOrigin,
   copyExpr,
+  forEachUserArtifact,
+  forEachQueryExpr,
   traverseQueryPost,
   traverseQueryExtra,
   setExpandStatus,
-  traverseExpr,
 } = require('./utils');
+const { CsnLocation } = require('./classes');
 
-const $location = Symbol.for('cds.$location');
-const $inferred = Symbol.for('cds.$inferred');
+const $location = Symbol.for( 'cds.$location' );
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 // Export function of this file.
 function tweakAssocs( model ) {
@@ -30,9 +32,11 @@ function tweakAssocs( model ) {
     info, warning, error,
   } = model.$messageFunctions;
   const {
+    traverseExpr,
+    checkExpr,
+    checkOnCondition,
     effectiveType,
     getOrigin,
-    navigationEnv,
   } = model.$functions;
 
   // Phase 5: rewrite associations
@@ -40,6 +44,13 @@ function tweakAssocs( model ) {
   // Think hard whether an on condition rewrite can lead to a new cyclic
   // dependency.  If so, we need other messages anyway.  TODO: probably do
   // another cyclic check with testMode.js
+  forEachUserArtifact( model, 'definitions', function check( art ) {
+    checkOnCondition( art.on, (art.kind !== 'mixin' ? 'on' : 'mixin-on'), art );
+    checkExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
+
+    if (art.kind === 'select')
+      forEachQueryExpr( art, checkExpr );
+  } );
   return;
 
 
@@ -107,7 +118,7 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociationCheck( element ) {
-    const elem = element.items || element; // TODO v2: nested items
+    const elem = element.items || element; // TODO v5: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociationCheck );
     if (!elem.target)
@@ -166,13 +177,9 @@ function tweakAssocs( model ) {
     }
     if (names.length) {
       const loc = otherAssoc.foreignKeys[$location] || dictLocation( otherAssoc.foreignKeys );
-      const location = loc && (!loc.endCol ? loc : {
-        file: loc.file,
-        line: loc.endLine,
-        col: loc.endCol - 1,
-        endLine: loc.endLine,
-        endCol: loc.endCol,
-      } );
+      const location = loc && (!loc.endCol
+        ? loc
+        : new CsnLocation( loc.file, loc.endLine, loc.endCol - 1, loc.endLine, loc.endCol ));
       const baseAssoc = assocWithExplicitSpec( thisAssoc );
       if (inferredForeignKeys( baseAssoc.foreignKeys )) { // still inferred = via target keys
         error( 'rewrite-key-not-covered-implicit', [ location, otherAssoc ],
@@ -194,7 +201,7 @@ function tweakAssocs( model ) {
   }
 
   function assocWithExplicitSpec( assoc ) {
-    while (assoc.foreignKeys && inferredForeignKeys( assoc.foreignKeys, 'keys') ||
+    while (assoc.foreignKeys && inferredForeignKeys( assoc.foreignKeys, 'keys' ) ||
            assoc.on && assoc.on.$inferred)
       assoc = getOrigin( assoc );
     return assoc;
@@ -257,7 +264,7 @@ function tweakAssocs( model ) {
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
       // TODO: re-check for case that foreign key is managed association
       if (orig._effectiveType !== undefined)
-        setLink( fk, '_effectiveType', orig._effectiveType);
+        setLink( fk, '_effectiveType', orig._effectiveType );
       const te = copyExpr( orig.targetElement, elem.location );
       if (elem._redirected) {
         const i = te.path[0];   // TODO: or also follow path like for ON?
@@ -266,7 +273,7 @@ function tweakAssocs( model ) {
           setArtifactLink( te, state );
       }
       fk.targetElement = te;
-    });
+    } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
   }
@@ -281,14 +288,14 @@ function tweakAssocs( model ) {
     // same (TODO later: set status whether rewrite changes anything),
     // especially problematic are refs starting with $self:
     setExpandStatus( elem, 'target' );
-    if (elem._parent && elem._parent.kind === 'element') {
+    if (elem._parent?.kind === 'element') {
       // managed association as sub element not supported yet
       error( null, [ elem.location, elem ], {},
         // eslint-disable-next-line max-len
              'Rewriting the ON-condition of unmanaged association in sub element is not supported' );
       return;
     }
-    const nav = (elem._main && elem._main.query && elem.value)
+    const nav = (elem._main?.query && elem.value)
       ? pathNavigation( elem.value ) // redirected source elem or mixin
       : { navigation: assoc };       // redirected user-provided
     const cond = copyExpr( assoc.on,
@@ -340,15 +347,13 @@ function tweakAssocs( model ) {
     if (tableAlias) { // from ON cond of element in source ref/d by table alias
       const source = tableAlias._origin;
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
-      // console.log( info(null, [assoc.name.location, assoc],
-      //                   { names: expr.path.map(i=>i.id), art: root }, 'TA').toString())
+      // console.log( info(null, [ assoc.name.location, assoc ],
+      //                   { names: expr.path.map(i => i.id), art: root }, 'TA').toString());
       if (!root || root._main !== source)
         return;                 // not $self or source element
       if (expr.scope === 'param' || root.kind === '$parameters')
         return;                 // are not allowed anyway - there was an error before
-      const item = expr.path[root.kind === '$self' ? 1 : 0];
-      // console.log('YE', assoc.name, item, root.name, expr.path)
-      const elem = navProjection( item && tableAlias.elements[item.id], assoc );
+      const { item, elem } = firstProjectionForPath( expr.path, tableAlias, assoc );
       rewritePath( expr, item, assoc, elem, assoc.value.location );
     }
     else if (assoc._main.query) { // from ON cond of mixin element in query
@@ -379,7 +384,7 @@ function tweakAssocs( model ) {
         return;                                   // just $self
       // corresponding elem in including structure
       const elem = (assoc._main.items || assoc._main).elements[item.id];
-      if (!(Array.isArray(elem) ||              // no msg for redefs
+      if (!(Array.isArray( elem ) ||            // no msg for redefs
             elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {
         const art = assoc._origin;
@@ -392,7 +397,7 @@ function tweakAssocs( model ) {
                    element: 'This element is not originally referred to in the ON-condition of association $(MEMBER) of $(ART)',
                  } );
       }
-      rewritePath( expr, item, assoc, (Array.isArray(elem) ? false : elem), null );
+      rewritePath( expr, item, assoc, (Array.isArray( elem ) ? false : elem), null );
     }
   }
 
@@ -401,13 +406,12 @@ function tweakAssocs( model ) {
     let root = path[0];
     if (!elem) {
       if (location) {
-        error( 'rewrite-not-projected', [ location, assoc ],
-               { name: assoc.name.id, art: item._artifact }, {
-                 // eslint-disable-next-line max-len
-                 std: 'Projected association $(NAME) uses non-projected element $(ART)',
-                 // eslint-disable-next-line max-len
-                 element: 'Projected association $(NAME) uses non-projected element $(MEMBER) of $(ART)',
-               } );
+        error( 'rewrite-not-projected', [ location, assoc ], {
+          name: assoc.name.id, art: item._artifact, elemref: { ref: path },
+        }, {
+          std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
+          element: 'Projected association $(NAME) uses non-projected element $(MEMBER) of $(ART)',
+        } );
       }
       delete root._navigation;
       setArtifactLink( root, elem );
@@ -415,9 +419,15 @@ function tweakAssocs( model ) {
       return;
     }
     if (item !== root) {
+      // e.g. mixin ON-condition: Base.foo -> $self.foo or multi-path projection,
+      // $projection -> $self
       root.id = '$self';
       setLink( root, '_navigation', assoc._parent.$tableAliases.$self );
       setArtifactLink( root, assoc._parent );
+      if (item) {
+        const i = path.indexOf(item);
+        ref.path = [ root, ...path.slice( i, path.length ) ];
+      }
     }
     else if (elem.name.id.charAt(0) === '$') {
       root = { id: '$self', location: item.location };
@@ -463,14 +473,13 @@ function tweakAssocs( model ) {
         // consider intermediate "preferred" elements - not just `assoc`,
         // but its origins, too.
         const proj = navProjection( alias.elements[name], assoc );
-        name = proj && proj.name && proj.name.id;
+        name = proj?.name?.id;
         if (!name) {
           if (!forKeys)
             break;
           setArtifactLink( item, null );
           const culprit = elem.target && !elem.target.$inferred && elem.target ||
-                          (elem.value && elem.value.path &&
-                           elem.value.path[elem.value.path.length - 1]) ||
+                          elem.value?.path?.[elem.value.path.length - 1] ||
                           elem;
           // TODO: probably better to collect the non-projected foreign keys
           // and have one message for all
@@ -482,9 +491,13 @@ function tweakAssocs( model ) {
         item.id = name;
       }
     }
-    const env = name && navigationEnv(elem);
+    let env = name && elem._effectiveType; //  should have been computed
+    // refs in ON cannot navigate along `items`, no need to consider `items` here
+    if (env?.target)
+      env = env.target._artifact?._effectiveType;
     elem = setArtifactLink( item, env?.elements?.[name] );
-    if (elem && !Array.isArray(elem))
+
+    if (elem && !Array.isArray( elem ))
       return elem;
     // TODO: better (extra message), TODO: do it
     error( 'query-undefined-element', [ item.location, assoc ],
@@ -505,20 +518,71 @@ function navProjection( navigation, preferred ) {
     : navigation._projections[0] || null;
 }
 
-// Return condensed info about reference in select item
-// - tableAlias.elem       -> { navigation: navElem, item: path[1], tableAlias }
-// - sourceElem (in query) -> { navigation: navElem, item: path[0], tableAlias }
-// - mixinElem             -> { navigation: mixinElement, item: path[0] }
-// - $projection.elem      -> also $self.item -> { item: path[1], tableAlias: $self }
-// - $self                 -> { item: undefined, tableAlias: $self }
-// - $parameters.P, :P     -> {}
-// - $now, current_date    -> {}
-// - undef, redef          -> {}
-// With 'navigation': store that navigation._artifact is projected
-// With 'navigation': rewrite its ON condition
-// With navigation: Do KEY propagation
-//
-// TODO: re-think this function, copied in populate.js and tweak-assocs.js
+
+/**
+ * For a path `a.b.c.d`, return a projection for the first path item that is projected.
+ * For example, if a query has multiple projections such as `a.b, a, a.b.c`, the
+ * _first_ possible projection will be used and the caller can rewrite `a.b.c.d` to `b.c.d`.
+ * This avoids that `extend`s affect the ON-condition.
+ *
+ * The returned object `ret` has `ret.item`, which is the path item that is projected.
+ * `ret.elem` is the element projection.
+ *
+ * @param {any[]} path
+ * @param {object} tableAlias
+ * @param {object} assoc Preferred association that should be used if projected.
+ * @return {{elem: object, item: object}|null}
+ */
+function firstProjectionForPath( path, tableAlias, assoc ) {
+  const viaSelf = (path[0]._navigation || path[0]._artifact).kind === '$self';
+  const root = viaSelf ? 1 : 0;
+  if (root >= path.length) // e.g. just `$self` path item
+    return { item: undefined, elem: {} };
+
+  // We want to use the _first_ valid projection that is written by the user (if the preferred
+  // `assoc` is not directly projected).  To achieve that, look into the table alias' elements.
+  const selectedElements = Object.values(tableAlias._parent.elements);
+  const proj = [];
+  let navItem = tableAlias;
+  for (const item of path.slice(root)) {
+    navItem = item?.id && navItem.elements?.[item.id];
+    if (!navItem) {
+      break;
+    }
+    else if (navItem._projections) {
+      const elem = navProjection( navItem, assoc );
+      if (elem && elem === assoc) {
+        // in case the specified association is found, _always_ use it.
+        return { item, elem };
+      }
+      else if (elem) {
+        const index = selectedElements.indexOf(elem);
+        proj.push({ item, elem, index });
+      }
+    }
+  }
+
+  return (proj.length === 0)
+    ? { item: path[root], elem: null }
+    : proj.reduce( (acc, curr) => (acc.index > curr.index ? curr : acc), proj[0] ); // first
+}
+
+/**
+ * Return condensed info about reference in select item
+ * - tableAlias.elem       -> { navigation: navElem, item: path[1], tableAlias }
+ * - sourceElem (in query) -> { navigation: navElem, item: path[0], tableAlias }
+ * - mixinElem             -> { navigation: mixinElement, item: path[0] }
+ * - $projection.elem      -> also $self.item -> { item: path[1], tableAlias: $self }
+ * - $self                 -> { item: undefined, tableAlias: $self }
+ * - $parameters.P, :P     -> {}
+ * - $now, current_date    -> {}
+ * - undef, redef          -> {}
+ * With 'navigation': store that navigation._artifact is projected
+ * With 'navigation': rewrite its ON condition
+ * With navigation: Do KEY propagation
+ *
+ * TODO: re-think this function, copied in populate.js and tweak-assocs.js
+ */
 function pathNavigation( ref ) {
   // currently, indirectly projectable elements are not included - we might
   // keep it this way!  If we want them to be included - be aware: cycles