@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/transform/odata/flattening.js

@@ -1,10 +1,11 @@
 'use strict';
 
-const { isBuiltinType, isMagicVariable, forEachDefinition,
+const { forEachDefinition,
   copyAnnotations, forEachMemberRecursively,
   transformExpression, findAnnotationExpression } = require('../../model/csnUtils');
+const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { applyTransformationsOnDictionary,
   applyTransformationsOnNonDictionary } = require('../db/applyTransformations.js');
 const { linkForeignKeyAnnotationExtensionsToAssociation,
@@ -13,46 +14,48 @@ const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { forEach } = require('../../utils/objectUtils');
 
 function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options) {
-
-  const isExprAnno = (obj, pn) => {
-    return isBetaEnabled(options, 'odataPathsInAnnotationExpressions') && findAnnotationExpression(obj, pn);
-  }
-
   forEachDefinition(csn, (def, defName) => {
-    if(def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
+    if (def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
       ['elements', 'params'].forEach(dictName => {
         const dict = def[dictName];
-        if(dict) {
+        if (dict) {
           const csnPath = ['definitions', defName, dictName];
           const orderedElementList = [];
 
-          forEach(dict, (eltName, elt) => {
-            const location = [ ...csnPath, eltName ];
-            const resolvedElt = (elt.type && !elt.elements) ? csnUtils.getFinalTypeInfo(elt.type) : elt;
-            if(resolvedElt.elements) {
-              const flattenedSubTree = recurseIntoElement(dictName, elt, resolvedElt,
-                !!elt.notNull, location, [ defName, eltName ]);
+          forEach(dict, (childName, child) => {
+            const location = [ ...csnPath, childName ];
+            const rootPrefix = [ defName ];
+            let resolvedElt = child;
+            let typeIdx = 0;
+            if (child.type && !child.elements) {
+              resolvedElt = csnUtils.getFinalTypeInfo(child.type);
+              if (resolvedElt.elements)
+                typeIdx = rootPrefix.length + 1;
+            }
+            if (resolvedElt.elements) {
+              const flattenedSubTree = recurseIntoElement(dictName, child, resolvedElt,
+                !!child.notNull, location, [ ...rootPrefix, childName ], typeIdx);
 
               flattenedSubTree.forEach(([flatEltName, flatElt]) => {
                 if (dict[flatEltName] || orderedElementList.some(elt => elt[0] === flatEltName))
                   error('name-duplicate-element', location,
                         { '#': 'flatten-element-exist', name: flatEltName });
-                propagateToFlatElem(elt, flatElt);
+                propagateToFlatElem(child, flatElt);
                 rewriteOnCondition(flatElt, flattenedSubTree);
                 orderedElementList.push([flatEltName, flatElt]);
               });
             }
             else {
-              const flatElt = cloneElt(dictName, elt, location, [ defName, eltName ]);
-              orderedElementList.push([eltName, flatElt]);
+              const flatElt = cloneElt(dictName, child, location, [ defName, childName ]);
+              orderedElementList.push([childName, flatElt]);
             }
           });
 
           const flatDict = orderedElementList.reduce((elements, [ flatEltName, flatElt ]) => {
-            if(flatElt.items) {
+            if (flatElt.items) {
               // rewrite annotation paths inside items.elements
               forEachMemberRecursively(flatElt.items, (elt, _eltName, _prop, path) => {
-                const exprAnnos = Object.keys(elt).filter(pn => isExprAnno(elt, pn));
+                const exprAnnos = Object.keys(elt).filter(pn => findAnnotationExpression(elt, pn));
                 flattenAndPrefixExprPaths(elt, exprAnnos, elt.$path, path, 0, true);
               }, [ flatEltName ], true, { pathWithoutProp: true } );
             }
@@ -60,21 +63,77 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             elements[flatEltName] = flatElt;
             return elements;
           }, Object.create(null));
-          setProp(def, `$${dictName}`, flatDict);
+          setProp(def, `$flat${dictName}`, flatDict);
         }
       });
+      // entity annotations
       const flatAnnos = Object.create(null);
-      const annoNames = copyAnnotations(def, flatAnnos).filter(an => isExprAnno(def, an));
+      const annoNames = copyAnnotations(def, flatAnnos).filter(an => findAnnotationExpression(def, an));
       flattenAndPrefixExprPaths(flatAnnos, annoNames, [ 'definitions', defName ], [ defName ], 0);
       setProp(def, '$flatAnnotations', flatAnnos);
+      // explicit binding parameter of bound action
+      if (def.actions) {
+        const special$self = !csn?.definitions?.$self && '$self';
+        Object.entries(def.actions).forEach(([actionName, action]) => {
+          if (action.params) {
+            const params = Object.entries(action.params);
+            const firstParam = params[0][1];
+            const type = firstParam?.items?.type || firstParam?.type;
+            if (type === special$self) {
+
+              const bindingParamName = params[0][0];
+              const markBindingParam = {
+                ref: (parent, prop, xpr) => {
+                  if ((xpr[0].id || xpr[0]) === bindingParamName)
+                    setProp(parent, '$bparam', true)
+                },
+              };
+              const refCheck = {
+                ref: (elemref, prop, xpr, path) => {
+                  const { art, scope } = inspectRef(path);
+                  if (scope !== '$magic' && art) {
+                    const ft = csnUtils.getFinalTypeInfo(art.type);
+                    if (!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+                      error('odata-anno-xpr-ref', path, { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
+                    }
+                  }
+                }
+              };
+
+              const flatAnnos = Object.create(null);
+              const annoNames = copyAnnotations(action, flatAnnos).filter(an => findAnnotationExpression(action, an));
+              annoNames.forEach((an) => {
+                refCheck.anno = an;
+                transformExpression(flatAnnos, an,
+                  [ markBindingParam, refCheck, refFlattener ],
+                  [ 'definitions', defName, 'actions',  actionName ]);
+                adaptRefs.forEach(fn => fn(true, 1, (parent) => parent.$bparam));
+                adaptRefs.length = 0;
+              });
+              setProp(action, '$flatAnnotations', flatAnnos);
+
+              forEachMemberRecursively(action, (member, memberName, prop, path, _parent) => {
+                const exprAnnos = Object.keys(member).filter(pn => findAnnotationExpression(member, pn));
+                exprAnnos.forEach((pn) => {
+                  refCheck.anno = pn;
+                  transformExpression(member, pn, [ markBindingParam, refCheck, refFlattener ], path);
+                  adaptRefs.forEach(fn => fn(true, 1, (parent) => parent.$bparam));
+                  adaptRefs.length = 0;
+                });
+              },
+              [ 'definitions', defName, 'actions',  actionName ]);
+            }
+          }
+        });
+      }
     }
   });
 
   function recurseIntoElement(scope, elt, resolvedElt, rootPathIsNotNull, location, rootPrefix = [], typeIdx = 0) {
     const eltName = rootPrefix[rootPrefix.length-1];
-    if(!resolvedElt.elements) {
+    if (!resolvedElt.elements) {
       const flatElt = cloneElt(scope, elt, location, rootPrefix, typeIdx);
-      if(rootPathIsNotNull)
+      if (rootPathIsNotNull)
         flatElt.notNull = true;
       else
         delete flatElt.notNull;
@@ -84,14 +143,14 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       let flattenedSubTree = [];
       forEach(resolvedElt.elements, (childName, child) => {
         resolvedElt = child;
-        if(child.type && !child.elements) {
+        if (child.type && !child.elements) {
           resolvedElt = csnUtils.getFinalTypeInfo(child.type);
-          if(resolvedElt.elements)
+          if (resolvedElt.elements)
             typeIdx = rootPrefix.length + 1;
         }
         flattenedSubTree = flattenedSubTree.concat(recurseIntoElement(scope, child, resolvedElt,
           !!(child.notNull && rootPathIsNotNull),
-          [... location, 'elements', childName], 
+          [... location, 'elements', childName],
           [ ...rootPrefix, childName ], typeIdx));
       });
       // 1) rename, 2) filter duplicates and finalize new elements
@@ -99,7 +158,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       return flattenedSubTree.map(([flatEltName, flatElt]) => {
         return [ `${eltName}_${flatEltName}`, flatElt ];
       }).filter(([name, flatElt]) =>{
-        if(duplicateDict[name]) {
+        if (duplicateDict[name]) {
           error('name-duplicate-element', location,
           { '#': 'flatten-element-gen', name });
           return false;
@@ -135,7 +194,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
     };
     // TODO: copy only those expression annotations that have no path into unreachable subtree, starting
     // of typePathRoot (which could be some completely different path)
-    const exprAnnoNames = copyAnnotations(elt, flatElt, false, excludes).filter(pn => isExprAnno(flatElt, pn));
+    const exprAnnoNames = copyAnnotations(elt, flatElt, false, excludes).filter(pn => findAnnotationExpression(flatElt, pn));
     flattenAndPrefixExprPaths(flatElt, exprAnnoNames, elt.$path, rootPrefix, typeIdx);
     // Copy selected type properties
     ['key', 'virtual', 'masked', 'viaAll', 'localized'].forEach(p => {
@@ -157,9 +216,9 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
     retypeCloneWithFinalBaseType(flatElt, location);
 
     const [ nonAnnoProps, exprAnnoProps ] = Object.keys(flatElt).reduce((acc, pn) => {
-      if(pn[0] !== '@' && pn !== 'value')
+      if (pn[0] !== '@' && pn !== 'value')
         acc[0].push(pn);
-      if(isExprAnno(flatElt, pn) || pn === 'value')
+      if (findAnnotationExpression(flatElt, pn) || pn === 'value')
         acc[1].push(pn);
       return acc;
     }, [[],[]]);
@@ -173,18 +232,18 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
     return flatElt;
 
     function retypeCloneWithFinalBaseType(elt, location) {
-      if(elt.type &&
+      if (elt.type &&
            !isBuiltinType(elt.type) &&
            !isODataV4BuiltinFromService(elt.type, location)
            && !isItemsType(elt.type)) {
-        let resolvedType = csnUtils.getFinalTypeInfo(elt);
-  
+        const resolvedType = csnUtils.getFinalTypeInfo(elt);
+
         delete resolvedType.kind;
-        if(resolvedType.items)
+        if (resolvedType.items)
           delete resolvedType.type;
-  
-        if(elt.items) {
-          if(resolvedType.items) {
+
+        if (elt.items) {
+          if (resolvedType.items) {
             elt.items = resolvedType;
             delete elt.items.type;
           }
@@ -192,7 +251,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             elt.items.type = resolvedType;
         }
         else {
-          if(resolvedType.items) {
+          if (resolvedType.items) {
             elt.items = resolvedType.items;
             delete elt.type;
           }
@@ -200,19 +259,19 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             elt.type = resolvedType;
         }
       }
-  
+
       function isItemsType(typeName) {
-        let typeDef = csn.definitions[typeName];
+        const typeDef = csn.definitions[typeName];
         return !!typeDef?.items;
       }
-  
+
       function isODataV4BuiltinFromService( typeName, path ) {
         if (options.odataVersion === 'v2' || typeof typeName !== 'string')
           return false;
-      
+
         const typeServiceName = csnUtils.getServiceName(typeName);
         let finalBaseType = csnUtils.getFinalTypeInfo(typeName).type;
-        if(!isBuiltinType(finalBaseType)) {
+        if (!isBuiltinType(finalBaseType)) {
           const typeDef = csn.definitions[finalBaseType];
           finalBaseType = typeDef?.items?.type || typeDef?.type;
         }
@@ -224,61 +283,83 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
   }
 
   // The path rewriting must be done with the current CSN  path of that exact annotation location
-  // in the element tree and done exactly after the initial copy, (otherwise, csnRefs is not able 
+  // in the element tree and done exactly after the initial copy, (otherwise, csnRefs is not able
   // to locate the relative location of the path expression in this element).
   // At this time both annotations and values must be rewritten.
   //
   // Later, the query can/must be rewritten as long as a flat OData CSN is published
   // but this then operates on the entity/view which has all struct infos available
   function flattenAndPrefixExprPaths(carrier, propNames, csnPath, rootPrefix, typeIdx, refParentIsItems = false) {
-    refFlattener.$refParentIsItems = refParentIsItems;
     const refCheck = {
-      ref: (parent, prop, xpr, path) => {
-        const { art } = inspectRef(path);
-        const ft = csnUtils.getFinalTypeInfo(art?.type);
-        if(!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
-          error('odata-anno-xpr-ref', path, { elemref: parent, name: refCheck.eltLocationStr, anno: refCheck.anno, '#': 'flatten_builtin' });
+      ref: (elemref, prop, xpr, path) => {
+        const { art, scope } = inspectRef(path);
+        if (scope !== '$magic' && art) {
+          const ft = csnUtils.getFinalTypeInfo(art.type);
+          if (!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+            error('odata-anno-xpr-ref', path,
+              {
+                anno: refCheck.anno,
+                elemref,
+                name: refCheck.eltLocationStr,
+                '#': 'flatten_builtin'
+              });
+          }
         }
       }
     }
 
     refCheck.eltLocationStr = (function() {
       const [head, ...tail ] = rootPrefix;
-      return `${head}:${tail.join('.')}`;
+      if(tail.length)
+        return `${head}:${tail.join('.')}`;
+      else
+        return `${head}`;
     })();
 
     const absolutifier = {
       ref : (parent, prop, xpr) => {
         const head = xpr[0].id || xpr[0];
-        if(typeIdx > 0 && head === '$self' && !isMagicVariable(head)) {
+        if (typeIdx < rootPrefix.length && head === '$self' && !isMagicVariable(head)) {
           const [xprHead, ...xprTail] = xpr.slice(1, xpr.length);
-          parent[prop] = [ rootPrefix.slice(1, typeIdx).concat(xprHead).join('_'), ...xprTail];
-          if(carrier.$scope === 'params')
-            parent.param = true;
-          else
-            parent[prop].unshift('$self');
+          if(xprHead) {
+            if (xprHead.id) {
+              xprHead.id = rootPrefix.slice(1, typeIdx).concat(xprHead.id).join('_');
+              parent[prop] = [ xprHead, ...xprTail ];
+            }
+            else
+              parent[prop] = [ rootPrefix.slice(1, typeIdx).concat(xprHead).join('_'), ...xprTail];
+            if (carrier.$scope === 'params')
+              parent.param = true;
+            else
+              parent[prop].unshift('$self');
+          }
         }
-        else if(rootPrefix.length > 2 && head !== '$self' && !parent.param && !isMagicVariable(head)) {
+        else if (rootPrefix.length > 2 && head !== '$self' && !parent.param && !isMagicVariable(head)) {
           const [xprHead, ...xprTail] = xpr;
-          if(!refParentIsItems)
-            parent[prop] = [ rootPrefix.slice(1, -1).concat(xprHead).join('_'), ...xprTail];
+          if (!refParentIsItems) {
+            if (xprHead.id) {
+              xprHead.id = rootPrefix.slice(1, -1).concat(xprHead.id).join('_');
+              parent[prop] = [ xprHead, ...xprTail ];
+            }
+            else
+              parent[prop] = [ rootPrefix.slice(1, -1).concat(xprHead).join('_'), ...xprTail];
+          }
           else
             parent[prop] = [ ...rootPrefix.slice(0, rootPrefix.length-1), ...xpr];
-          if(carrier.$scope === 'params')
+          if (carrier.$scope === 'params')
             parent.param = true;
           else
             parent[prop].unshift('$self');
         }
       }
     }
-    
+
     propNames.forEach(pn => {
       refCheck.anno = pn;
       transformExpression(carrier, pn, [ refCheck, refFlattener ], csnPath);
     });
-    adaptRefs.forEach(fn => fn());
+    adaptRefs.forEach(fn => fn(refParentIsItems));
     adaptRefs.length = 0;
-    refFlattener.$refParentIsItems = false;
     propNames.forEach(pn => {
       transformExpression(carrier, pn, absolutifier, csnPath)
     })
@@ -303,35 +384,66 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
   }
 }
 
-/**
- * Rewrite all structured references in the model such that it matches their flat counterparts
- * @param {CSN.Model} csn
- * @param {CSN.Options} options
- * @param {WeakMap} resolved Cache for resolved refs
- * @param {string} pathDelimiter
- * @param {object} iterateOptions
- */
-function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, iterateOptions = {} ) {
+function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef, effectiveType,
+    csnUtils, error, options, iterateOptions = {} ) {
 
   // All anno path flattening is already done, don't do it on locations where we don't want it!
+  const typeNames = [];
   forEachDefinition(csn, (def, defName) => {
-    if(def.kind === 'entity') {
+    if (def.kind === 'entity') {
       ['query', 'projection'].forEach(dictName => {
-        applyTransformationsOnNonDictionary(csn.definitions[defName], dictName, refFlattener, iterateOptions, [ 'definitions', defName ]);
+        applyTransformationsOnNonDictionary(csn.definitions[defName],
+            dictName, refFlattener, iterateOptions,
+            [ 'definitions', defName ]);
       })
-      if(csn.definitions[defName].actions)
-        applyTransformationsOnDictionary(csn.definitions[defName].actions, refFlattener, iterateOptions, [ 'definitions', defName, 'actions' ]);
+      if (csn.definitions[defName].actions)
+        applyTransformationsOnDictionary(csn.definitions[defName].actions,
+          refFlattener, iterateOptions,
+          [ 'definitions', defName, 'actions' ]);
     }
-      /*
-        TODO: In real hybrid flat/struct OData transformation, ref rewriting in types must not be done
-              together with non-rewriting ON condition refs during foreign key creation
-      */
-    if(['type'].includes(def.kind)) {
-      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, iterateOptions, [ 'definitions' ]);
+
+    if (['type'].includes(def.kind)) {
+      typeNames.push(defName);
+      applyTransformationsOnNonDictionary(csn.definitions,
+        defName, refFlattener, iterateOptions, [ 'definitions' ]);
     }
   });
   adaptRefs.forEach(fn => fn());
   adaptRefs.length = 0;
+
+  const refCheck = {
+    ref: (elemref, prop, xpr, path) => {
+      const { links, art } = (elemref._links && elemref._art
+        ? { links: elemref._links, art: elemref._art }
+        : inspectRef(path) );
+
+      let i = links.length-2;
+      const getProp = (propName) =>
+        (links[i].art?.[propName] ||
+        effectiveType(links[i].art)[propName]);
+
+      const ft = csnUtils.getFinalTypeInfo(art?.type);
+      let target = undefined;
+      for(; i >= 0 && !getProp('items') && !target; i--) {
+        target = getProp('target');
+      }
+      if (target && csn.definitions[target].$flatelements
+          && !isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+        error('odata-anno-xpr-ref', path,
+        { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
+      }
+    }
+  }
+  typeNames.forEach(tn => {
+    forEachMemberRecursively(csn.definitions[tn], (member, memberName, prop, csnPath) => {
+      Object.keys(member).filter(pn => pn[0] === '@').forEach(pn => {
+        refCheck.anno = pn;
+        transformExpression(member, pn, [ refCheck, refFlattener ], csnPath);
+      });
+    }, [ 'definitions', tn ]);
+  })
+  adaptRefs.forEach(fn => fn(true, 1));
+  adaptRefs.length = 0;
 }
 
 function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, pathDelimiter) {
@@ -355,32 +467,36 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
   }
   const adaptRefs = [];
   const transformer = {
-    $refParentIsItems: false,
     ref: (parent, prop, ref, path) => {
       const { links, art, scope } = inspectRef(path);
       const resolvedLinkTypes = resolveLinkTypes(links);
       setProp(parent, '$path', [ ...path ]);
       const lastRef = ref[ref.length - 1];
-      const fn = () => {
-        const scopedPath = [ ...parent.$path ];
-        // TODO: If foreign key annotations should be assigned via
-        //       full path into target, uncomment this line and
-        //       comment/remove setProp in expansion.js
-        // setProp(parent, '$structRef', parent.ref);
-        parent.ref = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, transformer.$refParentIsItems);
-        resolved.set(parent, { links, art, scope });
-        // Explicitly set implicit alias for things that are now flattened - but only in columns
-        // TODO: Can this be done elegantly during expand phase already?
-        if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
-          if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
-            delete parent.as;
-          delete parent.$implicitAlias;
-        }
-        // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
-        else if (parent.ref[parent.ref.length - 1] !== lastRef &&
-                    (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
-                    !parent.as) {
-          parent.as = lastRef;
+      const fn = (suspend = false, suspendPos = 0, 
+                    refFilter = (_parent) => true) => {
+        if (refFilter(parent)) {
+          const scopedPath = [ ...parent.$path ];
+          // TODO: If foreign key annotations should be assigned via
+          //       full path into target, uncomment this line and
+          //       comment/remove setProp in expansion.js
+          // setProp(parent, '$structRef', parent.ref);
+          parent.ref = flattenStructStepsInRef(ref,
+              scopedPath, links, scope, resolvedLinkTypes,
+              suspend, suspendPos, parent.$bparam);
+          resolved.set(parent, { links, art, scope });
+          // Explicitly set implicit alias for things that are now flattened - but only in columns
+          // TODO: Can this be done elegantly during expand phase already?
+          if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
+            if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+              delete parent.as;
+            delete parent.$implicitAlias;
+          }
+          // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
+          else if (parent.ref[parent.ref.length - 1] !== lastRef &&
+                      (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
+                      !parent.as) {
+            parent.as = lastRef;
+          }  
         }
 
         /**
@@ -390,7 +506,10 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
          * @returns {boolean}
          */
         function insideColumns( path ) {
-          return path.length >= 3 && (path[path.length - 3] === 'SELECT' || path[path.length - 3] === 'projection') && path[path.length - 2] === 'columns';
+          return path.length >= 3
+            && (path[path.length - 3] === 'SELECT'
+            || path[path.length - 3] === 'projection')
+            && path[path.length - 2] === 'columns';
         }
         /**
          * Return true if the path points inside keys
@@ -399,7 +518,9 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
          * @returns {boolean}
          */
         function insideKeys( path ) {
-          return path.length >= 3 && path[path.length - 2] === 'keys' && typeof path[path.length - 1] === 'number';
+          return path.length >= 3
+            && path[path.length - 2] === 'keys'
+            && typeof path[path.length - 1] === 'number';
         }
       };
       // adapt queries later

package/lib/transform/odata/toFinalBaseType.js

@@ -6,9 +6,9 @@ const {
   forEachDefinition,
   forEachGeneric,
   forEachMemberRecursively,
-  isBuiltinType,
-  findAnnotationExpression, 
+  findAnnotationExpression,
 } = require('../../model/csnUtils');
+const { isBuiltinType } = require('../../base/builtins');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
 
@@ -88,7 +88,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
   // type Foo: array of { qux: Integer };
   function expandFirstLevelOfArrayed(def) {
     if (def.items.type && !isBuiltinType(def.items.type)) {
-      let finalBaseType = csnUtils.getFinalTypeInfo(def.items.type);
+      const finalBaseType = csnUtils.getFinalTypeInfo(def.items.type);
       if (finalBaseType?.elements) {
         def.items.elements = cloneCsnDict(finalBaseType.elements, options);
         delete def.items.type;
@@ -98,12 +98,6 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
 
   function expandToFinalBaseType(node, defName) {
     if (!node) return;
-    // TODO: Clarify how should events be handled?
-    // They are not treated by the transformUtils::toFinalBaseType function
-    // in the same manner as named types, because the elements of structured events are not
-    // propagated as it is with types.
-    // It is ok to skip the expansion to the final base type for now as events are not rendered in
-    // EDMX at the moment and the reference in the OData CSN is fulfilled.
     if (node.kind === 'event') return;
 
     if(node.type && !isBuiltinType(node.type)) {
@@ -199,7 +193,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       // do the clone only if really needed
       if((finalBaseType.items && !node.items) ||
          (finalBaseType.elements && !node.elements)) {
-        // use the 'real' type, don't clone a clone
+        // clone the definition not another clone
         let _type = node._type;
         while(_type._type && !_type.items && !_type.elements)
           _type = _type._type;
@@ -227,15 +221,10 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       const typeRefStr = f(node.type.ref);
       const typeRefRootPath = $path2path(typeRefCsnPath);
       forEachMemberRecursively(clone, (elt, eltName, prop, location) => {
-        const [ xprANames /*nxprANames */ ] = Object.keys(elt).reduce((acc, pn) => {
-          if (pn[0] === '@')
-            acc[findAnnotationExpression(elt, pn) ? 0 : 1].push(pn);
-          return acc;
-        }, [ [], [] ]);
         const usingPositionStr = f($path2path(location));
         const eltRootPath = $path2path(elt.$path);
-        xprANames.forEach(xprAName => {
-          //let isSubTreeSpan = true;
+
+        Object.keys(elt).filter(pn => pn[0] === '@' && findAnnotationExpression(elt, pn)).forEach(xprAName => {
           transformExpression(elt, xprAName, {
             ref: (parent, prop, xpr, csnPath) => {
               let prefixMatch = true;
@@ -245,23 +234,18 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
                   prefixMatch = (xpr[i].id || xpr[i]) === typeRefRootPath[i];
                 }
                 if(prefixMatch && xpr.length > typeRefRootPath.length) {
-                  parent[prop] = [ ...xpr.slice(eltRootPath.length-1)];
+                  if(xpr.length >= eltRootPath.length)
+                    parent[prop] = [ ...xpr.slice(eltRootPath.length-1)];
+                  else
+                    parent[prop] = [ '$self', ...xpr.slice(typeRefRootPath.length)];
                 }
                 else {
                   error('odata-anno-xpr-ref', csnPath,
                   { anno: xprAName, elemref: xpr.join('.'), name: usingPositionStr, code: typeRefStr });
-                  //isSubTreeSpan = false;
                 }              
               }
             },
           }, elt.$path);
-          // if(!isSubTreeSpan) {
-          //   // remove annotation and sub annotations from cloned element
-          //   delete elt[xprAName];
-          //   nxprANames.filter(an => an.startsWith(`${xprAName}.`)).forEach((nxprAName) => {
-          //     delete elt[nxprAName];
-          //   });
-          // }
         });
         setProp(elt, '$path', location);
       }, node.$path);