@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/transform/db/expansion.js

@@ -239,15 +239,14 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {CSN.Artifact} root All elements visible fromt he query source ($combined)
      * @param {CSN.Column[]} columns
      * @param {string[]} excluding
-     * @returns {{columns: Array, toManys: Array}} Object with rewritten columns (.expand/.inline) and with any .expand + to-many
+     * @returns {{columns: Array, toMany: Array}} Object with rewritten columns (.expand/.inline) and with any .expand + to-many
      */
     function rewrite(root, columns, excluding) {
       const allToMany = [];
       const newThing = [];
       // Replace stars - needs to happen here since the .expand/.inline first path step affects the root *
       columns = replaceStar(root, columns, excluding);
-      for (let i = 0; i < columns.length; i++) {
-        const col = columns[i];
+      for (const col of columns) {
         if (col.expand) {
           // TODO: Can col.ref be empty without an as? Assumption is it cannot - if it has, it's an error, we throw, compiler checks.
           const { expanded, toManys } = expandInline(root, col, col.ref || [], [ dbName(col) ]);
@@ -451,7 +450,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         else
           newThing.push(col);
       }
-      else if (col.ref && col.$scope === '$magic' && col.ref[0] === '$user' && !col.as) {
+      else if (col.ref && col.$scope === '$magic' && ( col.ref[0] === '$user' || col.ref[0] === '$session' ) && !col.as) {
         col.as = implicitAs(col.ref);
         newThing.push(col);
       }
@@ -477,6 +476,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    */
   function expandRef(art, ref, alias, isKey, withAlias) {
     const expanded = [];
+    /** @type {Array<[CSN.Element, any[], any[]]>} */
     const stack = [ [ art, ref, [ alias || ref[ref.length - 1] ] ] ];
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
@@ -552,9 +552,11 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       for (const part of Object.keys(base)) {
         if (excluding.indexOf(part) === -1) {
           // The thing is shadowed - ignore names present because of .inline, as those "disappear"
-          if (names[part] !== undefined && !subs[names[part]].inline) {
-            replaced[part] = true;
-            star.push(subs[names[part]]);
+          if (names[part] !== undefined && !subs[names[part]].inline) { // Only works for a single * - but a second is forbidden anyway
+            if (names[part] > stars[0]) { // explicit definitions BEFORE the star should stay "infront" of the star
+              replaced[part] = true;
+              star.push(subs[names[part]]);
+            }
           }
           else { // the thing is not shadowed - use the name from the base
             star.push({ ref: [ part ] });
@@ -562,8 +564,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         }
       }
       // Finally: Replace the stars and leave out the shadowed things
-      for (let i = 0; i < subs.length; i++) {
-        const sub = subs[i];
+      for (const sub of subs) {
         if (sub !== '*' && !replaced[dbName(sub)])
           final.push(sub);
         else if (sub === '*')

package/lib/transform/db/flattening.js

@@ -14,7 +14,7 @@ const { setProp } = require('../../base/model');
  * @param {CSN.Model} csn
  */
 function removeLeadingSelf(csn) {
-  const magicVars = [ '$now' ];
+  const magicVars = [ '$now', '$self', '$projection', '$user', '$session', '$at' ];
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.kind === 'entity' || artifact.kind === 'view') {
       forAllElements(artifact, artifactName, (parent, elements) => {
@@ -79,6 +79,22 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter) {
       if (!isBuiltinType(type)) {
         const directLocalized = parent.localized || false;
         toFinalBaseType(parent, resolved);
+        // structured types might not have the child-types replaced.
+        // Drill down to ensure this.
+        if (parent.elements) {
+          const stack = [ parent.elements ];
+          while (stack.length > 0) {
+            const elements = stack.pop();
+            for (const e of Object.values(elements)) {
+              if (e.type && !isBuiltinType(e.type))
+                toFinalBaseType(e, resolved);
+
+              if (e.elements)
+                stack.push(e.elements);
+            }
+          }
+        }
+
         if (!directLocalized)
           removeLocalized(parent);
       }
@@ -233,10 +249,9 @@ function flattenElements(csn, options, pathDelimiter, error) {
 
             if (flatElement.type && isAssocOrComposition(flatElement.type) && flatElement.on) {
               // Make refs resolvable by fixing the first ref step
-              for (let i = 0; i < flatElement.on.length; i++) {
-                const onPart = flatElement.on[i];
+              for (const onPart of flatElement.on) {
                 if (onPart.ref) {
-                  const firstRef = flatElement.on[i].ref[0];
+                  const firstRef = onPart.ref[0];
 
                   /*
                       when element is defined in the current name resolution scope, like
@@ -253,7 +268,7 @@ function flattenElements(csn, options, pathDelimiter, error) {
                   const possibleFlatName = prefix + pathDelimiter + firstRef;
 
                   if (flatElems[possibleFlatName])
-                    flatElement.on[i].ref[0] = possibleFlatName;
+                    onPart.ref[0] = possibleFlatName;
                 }
               }
             }
@@ -271,7 +286,7 @@ function flattenElements(csn, options, pathDelimiter, error) {
         previous[name] = element;
         return previous;
       }, Object.create(null));
-    });
+    }, true);
   }
 
   /**
@@ -289,11 +304,11 @@ function flattenElements(csn, options, pathDelimiter, error) {
     /**
      * Walk the element chain
      *
-     * @param {CSN.Element} e
+     * @param {object} e
      * @param {string} name
      */
     function walkElements(e, name) {
-      if (isBuiltinType(e)) {
+      if (isBuiltinType(e.type)) {
         branches[subbranchNames.concat(name).join(pathDelimiter)] = subbranchElements.concat(e);
       }
       else {

package/lib/transform/db/temporal.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const {
+  getUtils, getNormalizedQuery, hasAnnotationValue, forEachMember,
+} = require('../../model/csnUtils');
+const { implicitAs } = require('../../model/csnRefs');
+const { setProp } = require('../../base/model');
+const { getTransformers } = require('../transformUtilsNew');
+
+const validToString = '@cds.valid.to';
+const validFromString = '@cds.valid.from';
+/**
+ * Get the forEachDefinition callback function that adds a where condition to views that
+ * - are annotated with @cds.valid.from and @cds.valid.to,
+ * - have only one @cds.valid.from and @cds.valid.to,
+ * - and both annotations come from the same entity
+ *
+ * If the view has one of the annotations but the other conditions are not met, an error will be raised.
+ *
+ * @param {CSN.Model} csn
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.info
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition applying the where-condition to views.
+ */
+function getViewDecorator(csn, messageFunctions) {
+  const { info } = messageFunctions;
+  const { get$combined } = getUtils(csn);
+  return addTemporalWhereConditionToView;
+  /**
+   * Add a where condition to views that
+   * - are annotated with @cds.valid.from and @cds.valid.to,
+   * - have only one @cds.valid.from and @cds.valid.to,
+   * - and both annotations come from the same entity
+   *
+   * If the view has one of the annotations but the other conditions are not met, an error will be raised.
+   *
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   */
+  function addTemporalWhereConditionToView(artifact, artifactName) {
+    const normalizedQuery = getNormalizedQuery(artifact);
+    if (normalizedQuery && normalizedQuery.query && normalizedQuery.query.SELECT) {
+      // BLOCKER: We need information to handle $combined
+      // What we are trying to achieve by this:
+      // Forbid joining/selecting from two or more temporal entities
+      // Idea: Follow the query-tree and check each from
+      // Collect all source-entities and compute our own $combined
+      const $combined = get$combined(normalizedQuery.query);
+      const [ from, to ] = getFromToElements($combined);
+      // exactly one validFrom & validTo
+      if (from.length === 1 && to.length === 1) {
+        // and both are from the same origin
+        if (from[0].source === to[0].source && from[0].parent === to[0].parent) {
+          if (!hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0])) {
+            const fromPath = {
+              ref: [
+                from[0].parent,
+                from[0].name,
+              ],
+            };
+
+            const toPath = {
+              ref: [
+                to[0].parent,
+                to[0].name,
+              ],
+            };
+
+
+            const atFrom = { ref: [ '$at', 'from' ] };
+            const atTo = { ref: [ '$at', 'to' ] };
+
+            const cond = [ '(', fromPath, '<', atTo, 'and', toPath, '>', atFrom, ')' ];
+
+            if (normalizedQuery.query.SELECT.where) { // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
+              normalizedQuery.query.SELECT.where = [ '(', ...normalizedQuery.query.SELECT.where, ')', 'and', ...cond ];
+            }
+            else {
+              normalizedQuery.query.SELECT.where = cond;
+            }
+          }
+        }
+        else {
+          info(null, [ 'definitions', artifactName ], `No temporal WHERE clause added as "${from[0].error_parent}"."${from[0].name}" and "${to[0].error_parent}"."${to[0].name}" are not of same origin`);
+        }
+      }
+      else if (from.length > 0 || to.length > 0) {
+        const missingAnnotation = from.length > to.length ? validToString : validFromString;
+        info(null, [ 'definitions', artifactName ],
+             { anno: missingAnnotation },
+             'No temporal WHERE clause added because $(ANNO) is missing');
+      }
+    }
+  }
+
+  /**
+   * Get all elements tagged with @cds.valid.from/to from the union of all entities of the from-clause.
+   *
+   * @param {any} combined union of all entities of the from-clause
+   * @returns {Array[]} Array where first field is array of elements with @cds.valid.from, second field is array of elements with @cds.valid.to.
+   */
+  function getFromToElements(combined) {
+    const from = [];
+    const to = [];
+    for (const name in combined) {
+      let elt = combined[name];
+      if (!Array.isArray(elt))
+        elt = [ elt ];
+      elt.forEach((e) => {
+        if (hasAnnotationValue(e.element, validFromString))
+          from.push(e);
+
+        if (hasAnnotationValue(e.element, validToString))
+          to.push(e);
+      });
+    }
+
+    return [ from, to ];
+  }
+
+  /**
+   * Check if the given SELECT has a falsy @cds.valid.from and a falsy @cds.valid.to
+   *
+   * @param {CSN.QuerySelect} SELECT
+   * @param {CSN.Elements} elements
+   * @param {object} from
+   * @param {object} to
+   * @returns {boolean} True if both are present and false.
+   */
+  function hasFalsyTemporalAnnotations(SELECT, elements, from, to) {
+    let fromElement = elements[from.name];
+    let toElement = elements[to.name];
+
+    if (SELECT.columns) {
+      for (const col of SELECT.columns) {
+        if (col.ref) {
+          const implicitAlias = implicitAs(col.ref);
+          if (implicitAlias === from.name)
+            fromElement = elements[col.as || implicitAlias];
+          else if (implicitAlias === to.name)
+            toElement = elements[col.as || implicitAlias];
+        }
+      }
+    }
+    return fromElement && toElement &&
+          hasAnnotationValue(fromElement, validFromString, false) &&
+          hasAnnotationValue(toElement, validToString, false);
+  }
+}
+
+/**
+ * Get the forEachDefinition callback function that collects all usages of @cds.valid.from/to/key and checks that
+ * - the assignment is on a valid element
+ * - the annotation is only assigned once
+ * - key is only used in conjunction with from and to
+ *
+ * Furthermore, @cds.valid.from and @cds.valid.key is processed - @cds.valid.from is marked as key or marked as unique if @cds.valid.key is used.
+ * If @cds.valid.key is used, the real key-elements have their key-property removed (set non-enumerable as $key) and instead the @cds.valid.key-marked elements have it added.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {string} pathDelimiter
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.error
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition processing the annotations.
+ */
+function getAnnotationHandler(csn, options, pathDelimiter, messageFunctions) {
+  const { error } = messageFunctions;
+  const {
+    extractValidFromToKeyElement, checkAssignment, checkMultipleAssignments, recurseElements,
+  } = getTransformers(csn, options, pathDelimiter);
+
+  return handleTemporalAnnotations;
+  /**
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   */
+  function handleTemporalAnnotations(artifact, artifactName) {
+    const validFrom = [];
+    const validTo = [];
+    const validKey = [];
+
+    recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
+      const [ f, t, k ] = extractValidFromToKeyElement(member, path);
+      validFrom.push(...f);
+      validTo.push(...t);
+      validKey.push(...k);
+    });
+
+    if (artifact.kind === 'entity' && !artifact.query) {
+      validFrom.forEach(obj => checkAssignment(validFromString, obj.element, obj.path, artifact));
+      validTo.forEach(obj => checkAssignment(validToString, obj.element, obj.path, artifact));
+      validKey.forEach(obj => checkAssignment('@cds.valid.key', obj.element, obj.path, artifact));
+      checkMultipleAssignments(validFrom, validFromString, artifact, artifactName);
+      checkMultipleAssignments(validTo, validToString, artifact, artifactName, true);
+      checkMultipleAssignments(validKey, '@cds.valid.key', artifact, artifactName);
+    }
+
+    // if there is an cds.valid.key, make this the only primary key
+    // otherwise add all cds.valid.from to primary key tuple
+    if (validKey.length) {
+      if (!validFrom.length || !validTo.length) {
+        error(null, [ 'definitions', artifactName ],
+              'Expecting “@cds.valid.from” and “@cds.valid.to” if “@cds.valid.key” is used');
+      }
+
+      forEachMember(artifact, (member) => {
+        if (member.key) {
+          member.unique = true;
+          delete member.key;
+          // Remember that this element was a key in the original artifact.
+          // This is needed for localized convenience view generation.
+          setProp(member, '$key', true);
+        }
+      });
+      validKey.forEach((member) => {
+        member.element.key = true;
+      });
+
+      validFrom.forEach((member) => {
+        member.element.unique = true;
+      });
+    }
+    else {
+      validFrom.forEach((member) => {
+        member.element.key = true;
+      });
+    }
+  }
+}
+
+
+module.exports = {
+  getViewDecorator,
+  getAnnotationHandler,
+};

package/lib/transform/db/transformExists.js

@@ -49,10 +49,14 @@ const { csnRefs } = require('../../model/csnRefs');
  */
 function handleExists(csn, options, error) {
   const { inspectRef } = csnRefs(csn);
+  const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
+    if (artifact.projection) // do the same hack we do for the other stuff...
+      artifact.query = { SELECT: artifact.projection };
+
     if (artifact.query) {
       forAllQueries(artifact.query, (query, path) => {
-        if (!query.$generatedExists) {
+        if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
           if (query.SELECT && query.SELECT.where && query.SELECT.where.length > 1)
             toProcess.push([ path.slice(0, -1), path.concat('where') ]);
@@ -66,6 +70,7 @@ function handleExists(csn, options, error) {
             toProcess.push([ path.slice(0, -1), path.concat([ 'from', 'on' ]) ]);
 
           for (const [ , exprPath ] of toProcess) {
+            forbidAssocInExists(exprPath);
             const expr = nestExists(exprPath);
             walkCsnPath(csn, exprPath.slice(0, -1))[exprPath[exprPath.length - 1]] = expr;
           }
@@ -81,6 +86,12 @@ function handleExists(csn, options, error) {
         }
       }, [ 'definitions', artifactName, 'query' ]);
     }
+
+    if (artifact.projection) { // undo our hack
+      artifact.projection = artifact.query.SELECT;
+
+      delete artifact.query;
+    }
   });
 
   /**
@@ -233,6 +244,63 @@ function handleExists(csn, options, error) {
     return startAssoc;
   }
 
+  /**
+   * Check that associations in filters (in an exists expression) are only fk-accesses. Everything else is forbidden.
+   *
+   * @param {CSN.Path} exprPath
+   * @returns {void}
+   */
+  function forbidAssocInExists(exprPath) {
+    const expr = walkCsnPath(csn, exprPath);
+    for (let i = 0; i < expr.length; i++) {
+      if (i < expr.length - 1 && expr[i] === 'exists' && expr[i + 1].ref) {
+        i++;
+        const current = expr[i];
+
+        const { links } = inspectRef(exprPath.concat(i));
+
+        const assocs = links.filter(link => link.art && link.art.target).map(link => current.ref[link.idx]);
+
+        checkForInvalidAssoc(assocs);
+      }
+    }
+  }
+
+  /**
+   * @param {object[]} assocs Array of refs of assocs - possibly with a .where to check
+   */
+  function checkForInvalidAssoc(assocs) {
+    for (const assoc of assocs) {
+      if (assoc.where) {
+        for (let i = 0; i < assoc.where.length; i++) {
+          const part = assoc.where[i];
+
+          if (part._links && !(assoc.where[i - 1] && assoc.where[i - 1] === 'exists')) {
+            for (const link of part._links) {
+              if (link.art && link.art.target) {
+                if (link.art.keys) { // managed - allow FK access
+                  if (part._links[link.idx + 1] !== undefined) { // there is a next path step - check if it is a fk
+                    if (!(part._links[link.idx + 1] && link.art.keys.some(fk => fk._art === part._links[link.idx + 1].art)))
+                      error(null, part.$path, { id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] }, 'Unexpected non foreign key access after managed association $(NAME) in filter expression of $(ID)');
+                  }
+                  else { // no traversal, ends on managed
+                    error(null, part.$path, { id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] }, 'Unexpected managed association $(NAME) in filter expression of $(ID)');
+                  }
+                }
+                else { // unmanaged - always wrong
+                  error(null, part.$path, { id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] }, 'Unexpected unmanaged association $(NAME) in filter expression of $(ID)');
+                }
+                // Recursively drill down if the assoc-step has a filter
+                if (part.ref[link.idx].where)
+                  checkForInvalidAssoc([ part.ref[link.idx] ]);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
   /**
    * Walk to the expr using the given path and scan it for the "exists" + "ref" pattern.
    * If such a pattern is found, nest association steps therein into filters.
@@ -297,16 +365,23 @@ function handleExists(csn, options, error) {
         const subselect = getSubselect(root.target, ref, sources);
 
         const target = subselect.SELECT.from.as; // use subquery alias as target - prevent shadowing
-        if (root.keys) { // managed assoc
-          translateManagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current);
-        }
-        else { // unmanaged assoc
-          translateUnmanagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current);
-        }
+        const extension = root.keys ? translateManagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) : translateUnmanagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current);
+        if (extension.length > 3)
+          subselect.SELECT.where.push('('); // add braces around the on-condition part to ensure precedence is kept
+
+        subselect.SELECT.where.push(...extension);
+
+        if (extension.length > 3)
+          subselect.SELECT.where.push(')');
 
         newExpr.push('exists');
-        if (ref && ref.where)
-          subselect.SELECT.where.push(...[ 'and', ...remapExistingWhere(target, ref.where) ]);
+        if (ref && ref.where) {
+          const remappedWhere = remapExistingWhere(target, ref.where);
+          if (remappedWhere.length > 3)
+            subselect.SELECT.where.push(...[ 'and', '(', ...remappedWhere, ')' ]);
+          else
+            subselect.SELECT.where.push(...[ 'and', ...remappedWhere ]);
+        }
 
         newExpr.push(subselect);
         toContinue.push([ exprPath.concat(newExpr.length - 1), exprPath.concat([ newExpr.length - 1, 'SELECT', 'where' ]) ]);
@@ -344,21 +419,24 @@ function handleExists(csn, options, error) {
    *
    * @param {CSN.Element} root
    * @param {string} target
-   * @param {CSN.Query} subselect This subselect will in the end replace <assoc> in EXISTS <assoc>
    * @param {boolean} isPrefixedWithTableAlias
    * @param {string} base
    * @param {Token} current
+   * @returns {object[]} The stuff to add to the where
    */
-  function translateManagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current) {
+  function translateManagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) {
+    const whereExtension = [];
     for (let j = 0; j < root.keys.length; j++) {
       const lop = { ref: [ target, ...root.keys[j].ref ] }; // target side
       const rop = { ref: (isPrefixedWithTableAlias ? [] : [ base ]).concat([ ...toRawRef(current.ref), ...root.keys[j].ref ]) }; // source side
 
       if (j > 0)
-        subselect.SELECT.where.push('and');
+        whereExtension.push('and');
 
-      subselect.SELECT.where.push(...[ lop, '=', rop ]);
+      whereExtension.push(...[ lop, '=', rop ]);
     }
+
+    return whereExtension;
   }
 
   /**
@@ -384,12 +462,13 @@ function handleExists(csn, options, error) {
    *
    * @param {CSN.Element} root
    * @param {string} target
-   * @param {CSN.Query} subselect This subselect will in the end replace <assoc> in EXISTS <assoc>
    * @param {boolean} isPrefixedWithTableAlias
    * @param {string} base
    * @param {Token} current
+   * @returns {object[]} The stuff to add to the where
    */
-  function translateUnmanagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current) {
+  function translateUnmanagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) {
+    const whereExtension = [];
     for (let j = 0; j < root.on.length; j++) {
       const part = root.on[j];
 
@@ -397,7 +476,7 @@ function handleExists(csn, options, error) {
       // but also keep along stuff like null and undefined, so compiler
       // can have a chance to complain/ we can fail later nicely maybe
       if (!(part && part.ref)) {
-        subselect.SELECT.where.push(part);
+        whereExtension.push(part);
         continue;
       }
 
@@ -407,30 +486,32 @@ function handleExists(csn, options, error) {
       // Dollar Self Backlink
       if (isValidDollarSelf(root.on[j], root.$path.concat([ 'on', j ]), root.on[j + 1], root.on[j + 2], root.$path.concat([ 'on', j + 2 ]))) {
         if (root.on[j].ref[0] === '$self' && root.on[j].ref.length === 1)
-          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
+          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
         else
-          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
+          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
 
         j += 2;
       }
       else if (links && links[0].art === root) { // target side
-        subselect.SELECT.where.push({ ref: [ target, ...part.ref.slice(1) ] });
+        whereExtension.push({ ref: [ target, ...part.ref.slice(1) ] });
       }
       else if (part.$scope === '$self') { // source side - "absolute" scope
         // cut off the $self, as we prefix the entity name now
-        subselect.SELECT.where.push({ ref: [ base, ...part.ref.slice(1) ] });
+        whereExtension.push({ ref: [ base, ...part.ref.slice(1) ] });
       }
       else if (art) { // source side - with local scope
         if (isPrefixedWithTableAlias)
-          subselect.SELECT.where.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
+          whereExtension.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
         else
-          subselect.SELECT.where.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
+          whereExtension.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
       }
       else { // operator - or any other leftover
-        subselect.SELECT.where.push(part);
+        whereExtension.push(part);
       }
     }
 
+    return whereExtension;
+
     /**
      * Check that an expression triple is a valid $self
      *
@@ -581,7 +662,7 @@ function handleExists(csn, options, error) {
     };
     // Because the generated things don't have _links, _art etc. set
     // We could also make getParent more robust to calculate the links JIT if they are missing
-    setProp(subselect, '$generatedExists', true);
+    generatedExists.set(subselect, true);
 
     const nonEnumElements = Object.create(null);
     nonEnumElements.dummy = {
@@ -638,7 +719,7 @@ function handleExists(csn, options, error) {
    *
    * @param {string} base The source entity/query source name
    * @param {string} target The target entity/query source name
-   * @param {CSN.Element} assoc The association element - the "not-$self" side of the comparison
+   * @param {object} assoc The association element - the "not-$self" side of the comparison
    * @param {CSN.Path} path
    * @returns {TokenStream} The WHERE representing the $self comparison
    */