@sap/cds-compiler 5.2.0 → 5.3.0

package/lib/compiler/tweak-assocs.js

@@ -41,10 +41,13 @@ function tweakAssocs( model ) {
     extendForeignKeys,
     createRemainingAnnotateStatements,
     mergeSpecifiedForeignKeys,
+    navigationEnv,
+    redirectionChain,
   } = model.$functions;
 
   Object.assign(model.$functions, {
-    firstProjectionForPath,
+    findRewriteTarget,
+    cachedRedirectionChain,
   });
 
   // Phase 5: rewrite associations
@@ -125,7 +128,7 @@ function tweakAssocs( model ) {
       // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
       info( 'assoc-outside-service', loc, { '#': text, target, service: main._service }, {
         std: 'Association target $(TARGET) is outside any service',
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/js/max-len
         exposed: 'If association is published in service $(SERVICE), its target $(TARGET) is outside any service',
       } );
     }
@@ -142,7 +145,7 @@ function tweakAssocs( model ) {
       if (assoc && assoc.foreignKeys) {
         error( 'rewrite-key-for-unmanaged', [ elem.on.location, elem ],
                { keyword: 'on', art: assocWithExplicitSpec( assoc ) },
-               // eslint-disable-next-line max-len
+               // eslint-disable-next-line @stylistic/js/max-len
                'Do not specify an $(KEYWORD) condition when redirecting the managed association $(ART)' );
       }
       checkIgnoredFilter( elem );
@@ -398,11 +401,18 @@ function tweakAssocs( model ) {
     // same (TODO later: set status whether rewrite changes anything),
     // especially problematic are refs starting with $self:
     setExpandStatus( elem, 'target' );
+
+    // There were previous issues in resolving the target artifact.
+    // Avoid further compiler messages.
+    if (!elem.target._artifact)
+      return;
+
     if (elem._parent?.kind === 'element') {
       // managed association as sub element not supported yet
       // TODO: Only report once for multi-include chains, see
       //       Associations/SubElements/UnmanagedInSubElement.err.cds
       error( 'type-unsupported-rewrite', [ elem.location, elem ], { '#': 'sub-element' } );
+      removeArtifactLinks();
       return;
     }
     const nav = (elem._main?.query && elem.value)
@@ -415,18 +425,11 @@ function tweakAssocs( model ) {
 
     const { navigation } = nav;
     if (!navigation) { // TODO: what about $projection.assoc as myAssoc ?
-      if (elem._columnParent)
+      if (elem._columnParent) {
         error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
-      return;                 // should not happen: $projection, $magic, or ref to const
-    }
-    const isAssocInStruct = (navigation !== assoc && navigation._origin !== assoc);
-    if (isAssocInStruct) {
-      // For "[sub.]assoc1.assoc2": not supported, yet (#3977)
-      const multipleAssoc = elem.value.path.slice(0, -1).some(segment => segment._artifact?.target);
-      if (multipleAssoc && elem._redirected !== null) { // null = already reported
-        error('rewrite-not-supported', [ elem.target.location, elem ], { '#': 'secondary' });
-        return;
+        removeArtifactLinks();
       }
+      return;                 // should not happen: $projection, $magic, or ref to const
     }
 
     if (!nav.tableAlias || nav.tableAlias.path) {
@@ -436,17 +439,30 @@ function tweakAssocs( model ) {
     }
     else if (elem._columnParent) {
       error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
+      removeArtifactLinks();
       return;
     }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
+      removeArtifactLinks();
       return;
     }
 
     addConditionFromAssocPublishing( elem, assoc, nav );
     elem.on.$inferred = 'rewrite';
+
+    /**
+     * Clear all `_artifact` links in the ON-condition to avoid follow-up
+     * issues during ON-condition rewriting of associations that inherit
+     * the ON-condition.
+     */
+    function removeArtifactLinks() {
+      traverseExpr( elem.on, 'rewrite-on', elem, (expr) => {
+        setArtifactLink( expr, null );
+      } );
+    }
   }
 
   /**
@@ -537,6 +553,7 @@ function tweakAssocs( model ) {
   function filterToCondition( assocPathStep, elem, nav ) {
     const cond = copyExpr( assocPathStep.where );
     cond.$parens = [ assocPathStep.location ];
+    const navEnv = nav && followNavigationPath( elem.value?.path, nav ) || nav?.tableAlias;
     traverseExpr( cond, 'rewrite-filter', elem, (expr) => {
       if (!expr.path || expr.path.length === 0)
         return;
@@ -560,7 +577,7 @@ function tweakAssocs( model ) {
           setLink( expr.path[0], '_navigation', assocPathStep._navigation );
         }
         // up to here, filter is relative to original association
-        rewriteExpr( expr, elem, nav?.tableAlias );
+        rewriteExpr( expr, elem, nav?.tableAlias, navEnv );
       }
     } );
 
@@ -664,28 +681,21 @@ function tweakAssocs( model ) {
     // element in included structure / element in source ref/d by table alias.
 
     // TODO: complain about $self (unclear semantics)
-    // console.log( info(null, [assoc.name.location, assoc],
-    //       { art: expr._artifact, names: expr.path.map(i=>i.id) }, 'A').toString(), expr.path)
 
     if (!expr.path || !expr._artifact)
       return;
     if (!assoc._main)
       return;
     if (navEnv) { // 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;
-      if (!root || root._main !== source)
-        return;                 // not $self or source element
+      if (!root || root.kind === 'builtin')
+        return; // not $self or source element, e.g. builtin
+
+      // parameters are not allowed in ON-conditions; error emitted elsewhere already
       if (expr.scope === 'param' || root.kind === '$parameters')
-        return;                 // are not allowed anyway - there was an error before
-      const startIndex = (root.kind === '$self' ? 1 : 0);
-      const exprNavigation = (root.kind === '$self' ? tableAlias : navEnv);
-      const result = firstProjectionForPath( expr.path, startIndex, exprNavigation, assoc );
-      // For `assoc[…]`, ensure that we don't rewrite to another projection on `assoc`.
-      if (result.item && assoc._origin === result.item._artifact)
-        result.elem = assoc;
+        return;
 
-      rewritePath( expr, result.item, assoc, result.elem, assoc.value.location );
+      rewritePathForEnv( expr, navEnv, assoc );
     }
     else if (assoc._main.query) { // from ON cond of mixin element in query
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
@@ -693,7 +703,7 @@ function tweakAssocs( model ) {
         if (assoc.$errorReported !== 'assoc-unexpected-scope') {
           error( 'assoc-unexpected-scope', [ assoc.value.location, assoc ],
                  { id: assoc.value._artifact.name.id },
-                 // eslint-disable-next-line max-len
+                 // eslint-disable-next-line @stylistic/js/max-len
                  'Association $(ID) can\'t be projected because its ON-condition refers to a parameter' );
           assoc.$errorReported = 'assoc-unexpected-scope';
         }
@@ -702,6 +712,7 @@ function tweakAssocs( model ) {
       if (expr.path[0]._navigation) { // rewrite src elem, mixin, $self[.elem]
         const nav = pathNavigation( expr );
         const elem = (assoc._origin === root) ? assoc : navProjection( nav.navigation, assoc );
+        // TODO: Use rewritePathForEnv(); make it handle mixins
         rewritePath( expr, nav.item, assoc, elem,
                      nav.item ? nav.item.location : expr.path[0].location );
       }
@@ -725,11 +736,11 @@ function tweakAssocs( model ) {
       if (!(elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {
         const art = assoc._origin;
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/js/max-len
         warning( 'rewrite-shadowed', [ elem.name.location, elem ], { art: art && effectiveType( art ) }, {
-          // eslint-disable-next-line max-len
+          // eslint-disable-next-line @stylistic/js/max-len
           std: 'This element is not originally referred to in the ON-condition of association $(ART)',
-          // eslint-disable-next-line max-len
+          // eslint-disable-next-line @stylistic/js/max-len
           element: 'This element is not originally referred to in the ON-condition of association $(MEMBER) of $(ART)',
         } );
       }
@@ -737,6 +748,138 @@ function tweakAssocs( model ) {
     }
   }
 
+  /**
+   * Rewrite the given reference by using projected elements of the given
+   * navigation environment.
+   *
+   * @param {XSN.Expression} ref
+   * @param {object} navEnv
+   * @param {XSN.Artifact} user
+   */
+  function rewritePathForEnv( ref, navEnv, user ) {
+    // TODO: combine with rewriteGenericAnnoPath() of xpr-rewrite
+
+    // reset artifact link; we'll set it again if there are no errors
+    setArtifactLink( ref, null );
+
+    const rootItem = ref.path[0];
+    const root = ref.path[0]._navigation || ref.path[0]._artifact;
+    const startIndex = (root.kind === '$self' ? 1 : 0);
+
+    if (root.kind === '$self') {
+      let rootEnv = navEnv;
+      while (rootEnv?.kind === '$navElement') {
+        if (rootEnv._origin?.target?._artifact === root._origin)
+          break;
+        rootEnv = rootEnv._parent;
+      }
+      navEnv = rootEnv;
+    }
+
+    // Store the original artifact, so that we can use it to
+    // calculate a redirection chain later on.
+    ref.path.forEach((item) => {
+      if (item._artifact)
+        setLink( item, '_originalArtifact', item._artifact );
+    });
+
+    let env = navEnv;
+    let art = rootItem._artifact;
+    let isTargetSide = null;
+
+    for (let i = startIndex; i < ref.path.length; ++i) {
+      if (i > startIndex && art.target) {
+        // if the current artifact is an association, we need to respect the redirection
+        // chain from original target to new one.
+        // FIXME: Won't work with associations in projected structures.
+        const origTarget = ref.path[i - 1]?._originalArtifact?.target?._artifact;
+        const chain = cachedRedirectionChain( art, origTarget );
+        if (!chain) {
+          missingProjection( ref, i, user, false );
+          return;
+        }
+        for (const alias of chain) {
+          art = rewritePathItemForEnv( ref, alias, i, user );
+          isTargetSide ??= (art === user);
+          if (!art) {
+            missingProjection( ref, i, user, isTargetSide );
+            return;
+          }
+        }
+      }
+
+      art = rewritePathItemForEnv( ref, env, i, user );
+      isTargetSide ??= (art === user);
+      if (!art) {
+        missingProjection( ref, i, user, isTargetSide );
+        return;
+      }
+      env = navigationEnv( art, null, null, 'nav' );
+    }
+    setArtifactLink( ref, art );
+
+    if (startIndex === 0 && rootItem.id.startsWith('$')) {
+      // TODO: What about filters? Also rewritten there?
+      // After rewriting, if an element starts with `$` -> add root prefix
+      // FIXME: "user" not correct for association inside sub-element,
+      //        because `user._parent` is assumed to be the query
+      prependSelfToPath( ref.path, user );
+    }
+  }
+
+  function rewritePathItemForEnv( ref, navEnv, index, user ) {
+    const rewriteTarget = findRewriteTarget( ref, index, navEnv, user );
+    const found = rewriteTarget[0];
+    if (!found) {
+      setArtifactLink( ref.path[index], found );
+      return found;
+    }
+
+    if (rewriteTarget[1] > index) {
+      // we keep the last segment, in case it has non-enumerable properties
+      ref.path[index] = ref.path[rewriteTarget[1]];
+      ref.path.splice(index + 1, rewriteTarget[1] - index);
+    }
+
+    const item = ref.path[index];
+    if (item.id !== found.name.id || (rewriteTarget[1] - index) !== 0)
+      item.id = found.name.id;
+
+    return setArtifactLink( ref.path[index], found );
+  }
+
+  /**
+   * @param {XSN.Path} ref
+   * @param {number} index
+   * @param {XSN.Artifact} user
+   * @param {boolean} isTargetSide
+   */
+  function missingProjection( ref, index, user, isTargetSide ) {
+    const item = ref.path[index];
+    if (!isTargetSide) {
+      const { location } = user.value;
+      const rootItem = ref.path[0];
+      const elemref = rootItem._navigation?.kind === '$self' ? ref.path.slice(1) : ref.path;
+      // TODO: Fix message for sub-elements: `s: { a: Association on x=1, x: Integer};` for x
+      error( 'rewrite-not-projected', [ location, user ], {
+        name: user.name.id,
+        art: item._artifact || item._originalArtifact,
+        elemref: { ref: elemref },
+      } );
+    }
+    else {
+      const isExplicit = user.target && !user.target.$inferred;
+      const loc = isExplicit ? user.target.location : item.location;
+      error( 'query-undefined-element', [ loc, user ], {
+        '#': isExplicit ? 'redirected' : 'std',
+        id: item.id,
+        name: user.name.id,
+        target: user.target._artifact,
+        keyword: 'redirected to',
+      } );
+    }
+  }
+
   function rewritePath( ref, item, assoc, elem, location ) {
     const { path } = ref;
     const root = path[0];
@@ -746,9 +889,6 @@ function tweakAssocs( model ) {
         // TODO: Fix message for sub-elements: `s: { a: Association on x=1, x: Integer};` for x
         error( 'rewrite-not-projected', [ location, assoc ], {
           name: assoc.name.id, art: elemref[0]._artifact, elemref: { ref: elemref },
-        }, {
-          std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
-          element: 'Projected association $(NAME) uses non-projected element $(ELEMREF) of $(ART)',
         } );
       }
       delete root._navigation;
@@ -841,6 +981,38 @@ function tweakAssocs( model ) {
     } );
     return null;
   }
+
+  /**
+   * Get the redirection chain between the element's target and the original target.
+   * Returns `null` if there is no valid chain.
+   * Uses `_redirected` if valid.
+   *
+   * @param {XSN.Artifact} elem
+   * @param {XSN.Artifact} origTarget
+   * @returns {null|XSN.Artifact[]}
+   */
+  function cachedRedirectionChain( elem, origTarget ) {
+    const target = elem.target?._artifact;
+    if (!target || !origTarget)
+      return null;
+    if (target === origTarget)
+      return [];
+
+    if (elem._redirected === null) {
+      // means: "don't touch paths after assoc"
+      // TODO: figure out if we can assume that here as well
+      return [];
+    }
+
+    if (elem._redirected) {
+      // No need to recalculate if the original target is already in '_redirected'.
+      const i = elem._redirected.findIndex(ta => ta._origin === origTarget);
+      if (i > -1)
+        return elem._redirected.slice(i); // TODO: check if it is always "i===0".
+    }
+
+    return redirectionChain( elem, target, origTarget, true );
+  }
 }
 
 function navProjection( navigation, preferred ) {
@@ -861,6 +1033,46 @@ function navProjection( navigation, preferred ) {
   return navigation._projections?.[0] || null;
 }
 
+function findRewriteTarget( expr, index, env, user ) {
+  if (env.kind === '$navElement' || env.kind === '$tableAlias') {
+    const r = firstProjectionForPath( expr.path, index, env, user );
+    return [ r.elem, r.index ];
+  }
+
+  const item = expr.path[index];
+  // If the artifact is already in the same definition, we must not check the query.
+  // Or if it is not a query -> no $navElement -> use `elements`
+  if (item._artifact?._main === env || !env.query && env.kind !== 'select') {
+    if (env.elements?.[item.id])
+      return [ env.elements[item.id], index ];
+    return [ null, expr.path.length ];
+  }
+  const items = (env._leadingQuery || env)._combined?.[item.id];
+  const allNavs = !items || Array.isArray(items) ? items : [ items ];
+
+  // If the annotation target itself has a table alias, require projections of that
+  // table alias. Of course, that only works if we're talking about the same query.
+  const tableAlias = (user._main?._origin === item._artifact?._main &&
+    user.value?.path[0]?._navigation?.kind === '$tableAlias')
+    ? user.value.path[0]._navigation : null;
+
+  // Look at all table aliase that could project `item` and only select
+  // those that have actual projections.
+  const navs = allNavs?.filter(p => p._origin === item._artifact &&
+    (!tableAlias || tableAlias === p._parent));
+  if (!navs || navs.length === 0)
+    return [ null, expr.path.length ];
+
+  // If there are multiple navigations for the element, just use the first that matches.
+  // In case of table aliases, it's just one.
+  for (const nav of navs) {
+    const r = firstProjectionForPath( expr.path, index, nav._parent, user );
+    if (r.elem)
+      return [ r.elem, r.index ];
+  }
+
+  return [ null, expr.path.length ];
+}
 
 /**
  * For a path `a.b.c.d`, return a projection for the first path item that is projected,
@@ -961,6 +1173,7 @@ function followNavigationPath( path, nav ) {
   return navItem;
 }
 
+
 /**
  * Return condensed info about reference in select item
  * - tableAlias.elem       -> { navigation: navElem, item: path[1], tableAlias }

package/lib/compiler/utils.js

@@ -212,9 +212,11 @@ function storeExtension( elem, name, prop, parent, block ) {
 /** @type {(a: any, b: any) => boolean} */
 const testFunctionPlaceholder = () => true;
 
-// Return path step if the path navigates along an association whose final type
-// satisfies function `test`; "navigates along" = last path item not considered
-// without truthy optional argument `alsoTestLast`.
+/**
+ * Return path step if the path navigates along an association whose final type
+ * satisfies function `test`; "navigates along" = last path item not considered
+ * without truthy optional argument `alsoTestLast`.
+ */
 function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
   for (const item of ref.path || []) {
     const art = item && item._artifact; // item can be null with parse error
@@ -435,7 +437,7 @@ function forEachJoinOn( query, from, callback ) {
 }
 
 function forEachExprArray( query, array, refContext, exprContext, callback ) {
-  for (const expr of array ) {
+  for (const expr of array) {
     if (expr)
       callback( expr, (expr.path ? refContext : exprContext), query );
   }
@@ -512,8 +514,10 @@ function traverseQueryExtra( main, callback ) {
   }
 }
 
-// Returns what was available at view._from[0] before:
-// (think first whether to really use this function)
+/**
+ * Returns what was available at view._from[0] before:
+ * (think first whether to really use this function)
+ */
 function viewFromPrimary( view ) {
   let query = view.$queries?.[0];
   while (query?._origin?.kind === 'select') // sub query in from
@@ -521,24 +525,26 @@ function viewFromPrimary( view ) {
   return dictFirst( query?.$tableAliases );
 }
 
-// About Helper property $expand for faster the XSN-to-CSN transformation
-// - null/undefined: artifact, member, items does not contain expanded members
-// - 'origin': all expanded (sub) elements have no new target/on and no new annotations
-//             that value is only on elements, types, and params -> no other members
-//             when set, only on elem/art with expanded elements
-// - 'target': all expanded (sub) elements might only have new target/on, but
-//             no individual annotations on any (sub) member
-//             when set, traverse all parents where the value has been 'origin' before
-// - 'annotate': at least one inferred (sub) member has an individual annotation,
-//               not counting propagated ones; set up to the definition (main artifact)
-//               (only set with anno on $inferred elem), annotate “beats” target
-// Usage according to CSN flavor:
-// - gensrc: do not render inferred elements (including expanded elements),
-//           collect annotate statements with value 'annotate'
-// - client: do not render expanded sub elements if artifact/member is no type, has a type,
-//           has $expand = 'origin', and all its _origin also have $expand = 'origin'
-//           (might sometimes render the elements unnecessarily, which is not wrong)
-// - universal: do not render expanded sub elements if $expand = 'origin'
+/**
+ * About Helper property $expand for faster the XSN-to-CSN transformation
+ * - null/undefined: artifact, member, items does not contain expanded members
+ * - 'origin': all expanded (sub) elements have no new target/on and no new annotations
+ *             that value is only on elements, types, and params -> no other members
+ *             when set, only on elem/art with expanded elements
+ * - 'target': all expanded (sub) elements might only have new target/on, but
+ *             no individual annotations on any (sub) member
+ *             when set, traverse all parents where the value has been 'origin' before
+ * - 'annotate': at least one inferred (sub) member has an individual annotation,
+ *               not counting propagated ones; set up to the definition (main artifact)
+ *               (only set with anno on $inferred elem), annotate “beats” target
+ * Usage according to CSN flavor:
+ * - gensrc: do not render inferred elements (including expanded elements),
+ *           collect annotate statements with value 'annotate'
+ * - client: do not render expanded sub elements if artifact/member is no type, has a type,
+ *           has $expand = 'origin', and all its _origin also have $expand = 'origin'
+ *           (might sometimes render the elements unnecessarily, which is not wrong)
+ * - universal: do not render expanded sub elements if $expand = 'origin'
+ */
 function setExpandStatus( elem, status ) {
   // set on element
   while (elem._main) {
@@ -618,12 +624,14 @@ function columnRefStartsWithSelf( col ) {
   return false;
 }
 
-// Remark: this function is based on an early check that no target element is
-// covered more than once by a foreign key: then…
-// we only need to check that all foreign key references are primary keys and
-// that the number of foreign and primary keys are the same.
+/**
+ * Remark: this function is based on an early check that no target element is
+ * covered more than once by a foreign key: then…
+ * we only need to check that all foreign key references are primary keys and
+ * that the number of foreign and primary keys are the same.
+ */
 function isAssocToPrimaryKeys( assoc ) {
-  let fkeys = 0;
+  let keyCount = 0;
   const { foreignKeys } = assoc;
   if (!foreignKeys)
     return undefined;
@@ -634,7 +642,7 @@ function isAssocToPrimaryKeys( assoc ) {
       return undefined;
     if (!elem.key?.val)
       return false;
-    ++fkeys;
+    ++keyCount;
   }
 
   const elements = assoc.target._artifact?.elements;
@@ -642,9 +650,9 @@ function isAssocToPrimaryKeys( assoc ) {
     return undefined;
   for (const name in elements) {
     if (elements[name].key?.val)
-      --fkeys;
+      --keyCount;
   }
-  return fkeys === 0;
+  return keyCount === 0;
 }
 
 // only if _effectiveType has been computed: