@sap/cds-compiler 2.5.0 → 2.10.4

package/lib/transform/forOdataNew.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { isDeprecatedEnabled } = require('../base/model');
+const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtilsNew');
 const { getUtils,
         cloneCsn,
@@ -24,8 +24,9 @@ const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssoci
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const timetrace = require('../utils/timetrace');
 const { attachPath } = require('./odata/attachPath');
+const enrichUniversalCsn = require('./universalCsnEnricher');
 
-const { addLocalizationViews, hasLocalizedConvenienceView, isInLocalizedNamespace } = require('./localized');
+const { addLocalizationViews } = require('./localized');
 
 // Transformation for ODATA. Expects a CSN 'inputModel', processes it for ODATA.
 // The result should be suitable for consumption by EDMX processors (annotations and metadata)
@@ -89,7 +90,7 @@ function transform4odataWithCsn(inputModel, options) {
     addElement, createAction, assignAction,
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
-    recurseElements, setAnnotation, renameAnnotation,
+    recurseElements, setAnnotation, resetAnnotation, renameAnnotation,
     expandStructsInExpression
   } = transformers;
 
@@ -119,16 +120,17 @@ function transform4odataWithCsn(inputModel, options) {
   // @ts-ignore
   const isExternalServiceMember = (_art, name) => externalServices.includes(getServiceName(name));
 
+  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
+    enrichUniversalCsn(csn, options);
 
-  addLocalizationViews(csn, options);
   const keepLocalizedViews = isDeprecatedEnabled(options, 'createLocalizedViews');
-  forEachDefinition(csn, (artifact, artifactName) => {
-    if (hasLocalizedConvenienceView(csn, artifactName))
-      artifact.$localized = true;
-    else if (!keepLocalizedViews && isInLocalizedNamespace(artifactName))
-      delete csn.definitions[artifactName];
-  }, { skipArtifact: isExternalServiceMember });
 
+  function acceptLocalizedView(_name, parent) {
+    csn.definitions[parent].$localized = true;
+    return keepLocalizedViews && !isExternalServiceMember(undefined, parent);
+  }
+
+  addLocalizationViews(csn, options, acceptLocalizedView);
 
   validate.forOdata(csn, {
     error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
@@ -159,7 +161,7 @@ function transform4odataWithCsn(inputModel, options) {
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
   // If errors are detected, throwWithError() will return from further processing
-  forEachDefinition(csn, expandStructsInExpression, { skipArtifact: isExternalServiceMember });
+  expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
   // handles reference flattening
   let referenceFlattener = new ReferenceFlattener();
@@ -227,16 +229,13 @@ function transform4odataWithCsn(inputModel, options) {
     if (options.toOdata.names && !['service', 'context', 'namespace', 'annotation', 'action', 'function'].includes(def.kind))
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.toOdata.names, csn);
 
-    forEachMemberRecursively(def, (member, memberName, propertyName) => {
+    forEachMemberRecursively(def, (member, memberName, propertyName, path) => {
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested
       // Only these are actually required and don't annotate virtual elements in entities or types
       // as they have no DB representation (although in views)
       if (options.toOdata.names && typeof member === 'object' && !['action', 'function'].includes(member.kind) && propertyName !== 'enum' && (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
-        if (member._flatElementNameWithDots) {
-          memberName = member._flatElementNameWithDots;
-        }
-        member['@cds.persistence.name'] = getElementDatabaseNameOf(memberName, options.toOdata.names);
+        member['@cds.persistence.name'] = getElementDatabaseNameOf(referenceFlattener.getElementNameWithDots(path) || memberName, options.toOdata.names);
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -331,7 +330,7 @@ function transform4odataWithCsn(inputModel, options) {
         renameAnnotation(node, name, '@UI.Importance');
         let annotation = node['@UI.Importance'];
         if (annotation !== null)
-          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' }
+          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' };
       }
 
       // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
@@ -462,11 +461,11 @@ function transform4odataWithCsn(inputModel, options) {
     }
     // Generate the annotations describing the draft actions (only draft roots can be activated/edited)
     if (artifact == rootArtifact) {
-      artifact['@Common.DraftRoot.ActivationAction'] = 'draftActivate';
-      artifact['@Common.DraftRoot.EditAction'] = 'draftEdit';
-      artifact['@Common.DraftRoot.PreparationAction'] = 'draftPrepare';
+      resetAnnotation(artifact, '@Common.DraftRoot.ActivationAction', 'draftActivate', info, ['definitions', draftAdminDataProjectionName]);
+      resetAnnotation(artifact, '@Common.DraftRoot.EditAction', 'draftEdit', info, ['definitions', draftAdminDataProjectionName]);
+      resetAnnotation(artifact, '@Common.DraftRoot.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
     } else {
-      artifact['@Common.DraftNode.PreparationAction'] = 'draftPrepare';
+      resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
     }
 
     artifact.elements && Object.values(artifact.elements).forEach( elem => {
@@ -534,7 +533,7 @@ function transform4odataWithCsn(inputModel, options) {
 
         // Ignore if that is our own draft root
         if (draftNode != rootArtifact) {
-          // Barf if the draft node has @odata.draft.enabled itself
+          // Report error when the draft node has @odata.draft.enabled itself
           if (hasAnnotationValue(draftNode, '@odata.draft.enabled', true)) {
             error(null, ['definitions', artifactName, 'elements', elemName], 'Composition in draft-enabled entity can\'t lead to another entity with “@odata.draft.enabled”');
           }

package/lib/transform/localized.js

@@ -5,12 +5,14 @@ const { setProp } = require('../base/model');
 const { hasErrors } = require('../base/messages');
 const { cloneCsnDictionary } = require('../model/csnUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
+const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
 const {
   cloneCsn,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
   sortCsnDefinitionsForTests,
+  getUtils,
 } = require('../model/csnUtils');
 
 /**
@@ -34,6 +36,13 @@ const _isViewForEntity = Symbol('_isViewForEntity'); // $inferred = 'LOCALIZED-H
  */
 const _targetFor = Symbol('_targetFor');
 
+/**
+ * Callback function returning `true` if the localization view should be created.
+ * @callback acceptLocalizedView
+ * @param {string} viewName localization view name
+ * @param {string} originalName Artifact name of the original view
+ */
+
 /**
  * Create transitive localized convenience views
  *
@@ -60,8 +69,9 @@ const _targetFor = Symbol('_targetFor');
  * @param {CSN.Options} options
  * @param {boolean} useJoins If true, rewrite the "localized" association to a
  *                           join in direct convenience views.
+ * @param {acceptLocalizedView} [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
  */
-function _addLocalizationViews(csn, options, useJoins) {
+function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = null) {
   // Don't try to create convenience views with errors.
   if (hasErrors(options.messages))
     return csn;
@@ -69,7 +79,7 @@ function _addLocalizationViews(csn, options, useJoins) {
   if (hasExistingLocalizationViews(csn, options))
     return csn;
 
-  const { info } = makeMessageFunction(csn, options);
+  const { info, error } = makeMessageFunction(csn, options);
 
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
@@ -77,7 +87,16 @@ function _addLocalizationViews(csn, options, useJoins) {
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
 
-  forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
+  forEachDefinition(csn, (definition, artName, prop, path) => {
+    cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor)
+    if(definition.query) {
+      // reject managed association and structure publishing for to-hdbcds.hdbcds
+      const that = { csnUtils: getUtils(csn), options, error };
+      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
+    }
+  });
+
+
 
   sortCsnDefinitionsForTests(csn, options);
   return csn;
@@ -125,10 +144,16 @@ function _addLocalizationViews(csn, options, useJoins) {
 
     art[_hasLocalizedView] = viewName;
 
+    if(acceptLocalizedView && !acceptLocalizedView(viewName, artName))
+      return;
+
+    let view;
     if (art.query || art.projection)
-      csn.definitions[viewName] = createLocalizedViewForView(art);
+      view = createLocalizedViewForView(art);
     else
-      csn.definitions[viewName] = createLocalizedViewForEntity(art, artName, textElements);
+      view = createLocalizedViewForEntity(art, artName, textElements);
+
+    csn.definitions[viewName] = view;
 
     copyPersistenceAnnotations(csn.definitions[viewName], art);
   }
@@ -587,9 +612,10 @@ function _addLocalizationViews(csn, options, useJoins) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
  */
-function addLocalizationViews(csn, options) {
-  return _addLocalizationViews(csn, options, false);
+function addLocalizationViews(csn, options, acceptLocalizedView = null) {
+  return _addLocalizationViews(csn, options, false, acceptLocalizedView);
 }
 
 /**
@@ -599,9 +625,10 @@ function addLocalizationViews(csn, options) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
  */
-function addLocalizationViewsWithJoins(csn, options) {
-  return _addLocalizationViews(csn, options, true);
+function addLocalizationViewsWithJoins(csn, options, acceptLocalizedView = null) {
+  return _addLocalizationViews(csn, options, true, acceptLocalizedView);
 }
 
 /**
@@ -659,7 +686,7 @@ function copyPersistenceAnnotations(target, source) {
       // Do NOT copy ".exists" at the moment.  ".exists" is not propagated
       // and this would lead to some localization views referencing not-existing
       // "localized.XYZ" views.
-      if (anno.startsWith('@cds.persistence.skip'))
+      if (anno === '@cds.persistence.skip')
         target[anno] = source[anno];
     });
 }

package/lib/transform/odata/attachPath.js

@@ -24,6 +24,8 @@ const structuralNodeHandlers = {
   groupBy: traverseArray,
   having: traverseArray,
   xpr: traverseArray,
+  expand: traverseArray,
+  inline: traverseArray,
 }
 
 function attachPath(csn) {
@@ -38,6 +40,7 @@ function attachPathOnPartialCSN(csnPart, pathPrefix) {
 }
 
 function traverseRef(obj, path) {
+  if(!obj) return;
   setPath(obj, path);
   traverseArray(obj, path);
 }
@@ -48,7 +51,7 @@ function traverseArray(obj, path) {
 }
 
 function traverseDict(obj, path) {
-  if(typeof obj !== 'object') return;
+  if(!obj || typeof obj !== 'object') return;
   forAllEnumerableProperties(obj, name => {
     const ipath = path.concat(name);
     setPath(obj[name], ipath);
@@ -56,17 +59,29 @@ function traverseDict(obj, path) {
   })
 }
 
+function traverseDictArray(obj, path) {
+  if(!obj || typeof obj !== 'object') return;
+  forAllEnumerableProperties(obj, name => {
+    const ipath = path.concat(name);
+    setPath(obj[name], ipath);
+    traverseArray(obj[name], ipath);
+  })
+}
+
 function traverseTyped(obj, path) {
-  if(!obj) return;
+  if(!obj || typeof obj !== 'object') return;
   forAllEnumerableProperties(obj, name => {
     if(name[0]==='@') return; // skip annotations
     const func = structuralNodeHandlers[name];
-    if(func) func(obj[name], path.concat(name));
+    if(func)
+      func(obj[name], path.concat(name));
+    else if(path[path.length-2] === 'columns')
+      traverseDictArray(obj[name], path.concat(name)); // for columns
   })
 }
 
 function setPath(obj, path) {
-  if(typeof obj !== 'object') return;
+  if(!obj || typeof obj !== 'object') return;
   if(path.length>0)
     Object.defineProperty( obj, '$path', { value: path, configurable: true, writable: true, enumerable: false } );
 }

package/lib/transform/odata/generateForeignKeyElements.js

@@ -35,7 +35,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     let generatedForeignKeyNamesForPath = Object.create(null); // map<path,[key-name]>
 
     sortedAssociations.forEach(item => {
-      const { definitionName, elementName, element, parent, path } = item;
+      const { definitionName, structuralNodeName, elementName, element, parent, path } = item;
 
       if (csnUtils.isManagedAssociationElement(element) && element.keys) {
         if (flatKeys) // tackling the ref value in assoc.keys
@@ -44,7 +44,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
         fixCardinality(element);
       }
 
-      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, elementName, element, parent, path);
+      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, structuralNodeName, elementName, element, parent, path);
       generatedForeignKeyNamesForPath[item.path.join('/')] = arrayOfGeneratedForeignKeyNames;
     })
 
@@ -111,7 +111,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
   /**
    * Generates foreign keys and returns their names as an array
    */
-  function generateForeignKeys(definitionName, assocName, assoc, parent, path) {
+  function generateForeignKeys(definitionName, structuralNodeName, assocName, assoc, parent, path) {
     let foreignKeyElements = Object.create(null);
 
     // First, loop over the keys array of the association and generate the FKs.
@@ -134,13 +134,14 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     if (parent.returns)
       parent = parent.returns.items || parent.returns;
 
-    let currElementsNames = Object.keys(parent.elements);
+    const dictionary = parent[structuralNodeName];
+    let currElementsNames = Object.keys(parent[structuralNodeName]);
     for (const [foreignKeyName, foreignKey] of Object.entries(foreignKeyElements)) {
       copyAnnotations(assoc, foreignKey, true);
       // Insert artificial element into artifact, with all cross-links
-      if (parent.elements[foreignKeyName]) {
-        if (!(parent.elements[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(parent.elements[foreignKeyName], foreignKey))) {
-          const path = parent.elements[foreignKeyName].$path;
+      if (dictionary[foreignKeyName]) {
+        if (!(dictionary[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(dictionary[foreignKeyName], foreignKey))) {
+          const path = dictionary[foreignKeyName].$path;
           error(null, path, { name: foreignKeyName, art: assocName }, 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
         }
       }
@@ -151,8 +152,8 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     // if (flatKeys)
     currElementsNames.splice(assocIndex + 1, 0, ...Object.keys(foreignKeyElements));
 
-    parent.elements = currElementsNames.reduce((previous, name) => {
-      previous[name] = parent.elements[name] || foreignKeyElements[name];
+    parent[structuralNodeName] = currElementsNames.reduce((previous, name) => {
+      previous[name] = dictionary[name] || foreignKeyElements[name];
       return previous;
     }, Object.create(null));
 
@@ -180,7 +181,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
 
     function processStucturedKey(fkArtifact, assocName, foreignKeyRef) {
       const subStruct = fkArtifact.elements ? fkArtifact : csnUtils.getFinalBaseType(fkArtifact.type);
-      const flatElements = flattenStructure(subStruct, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
+      const flatElements = flattenStructure(subStruct.elements, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
       for (const [flatElemName, flatElem] of Object.entries(flatElements)) {
         const foreignKeyElementName =
           `${assocName.replace(/\./g, '_')}_${foreignKeyRef.as ? flatElemName.replace(implicitAs(foreignKeyRef.ref), foreignKeyRef.as) : flatElemName}`;

package/lib/transform/odata/referenceFlattener.js

@@ -1,6 +1,7 @@
 const { forEachRef } = require('../../model/csnUtils');
 const { setProp } = require('../../base/model');
 const { implicitAs } = require('../../model/csnRefs');
+const { structuralPath } = require('./structuralPath');
 
 /** This class is used for generic reference flattening.
  * It provides the following functionality:
@@ -38,6 +39,7 @@ class ReferenceFlattener {
     this.structuredReference = {};
     this.generatedElementsForPath = {};
     this.elementTransitions = {};
+    this.elementNamesWithDots = {};
   }
 
   /**
@@ -72,8 +74,7 @@ class ReferenceFlattener {
       });
       if (paths)
         setProp(node, '$paths', paths);
-      setProp(node, '$scope', resolved.scope);
-      // cache also if structured or not
+      // cache if structured or not
       let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
       this.structuredReference[path.join('/')] = structured;
     });
@@ -157,6 +158,14 @@ class ReferenceFlattener {
     return this.generatedElementsForPath[path.join('/')];
   }
 
+  setElementNameWithDots(path, elementNameWithDots) {
+    this.elementNamesWithDots[path.join('/')] = elementNameWithDots;
+  }
+
+  getElementNameWithDots(path) {
+    return this.elementNamesWithDots[path.join('/')];
+  }
+
   /**
    * Generic reference flattener as {@link ReferenceFlattener described}.
    *
@@ -167,35 +176,40 @@ class ReferenceFlattener {
       if (node.$paths) {
         let newRef = []; // flattened reference
         let flattenWithPrevious = false;
-        let anythingFlattened = false; // will be set to true if at least one node is flatted
+        let lastFlattenedID = null; // The variable will be set to the index of the last flattened path
         node.$paths.forEach((path, i) => {
           if (path === undefined || !ref[i]) return;
-          let spath = path.join('/')
+          let spath = path.join('/');
           let movedTo = this.elementTransitions[spath]; // detect element transition
           let flattened = this.flattenedElementPaths[spath];
           if (flattenWithPrevious) {
-            newRef[newRef.length - 1] = newRef[newRef.length - 1] + '_' + ref[i];
-            anythingFlattened = true;
+            newRef[newRef.length - 1] = newRef[newRef.length - 1] + '_' + (ref[i].id || ref[i]);
+            // if we have a filter or args in an assoc, it needs to be kept, therefore
+            // the id of the ref is updated with the flattened version
+            if (ref[i].id) {
+              ref[i].id = newRef[newRef.length - 1];
+              newRef[newRef.length - 1] = ref[i];
+            }
+            lastFlattenedID = i;
           } else if(movedTo && i===0) { // handle local scope reference which is transitioned - replace first item in reference
             let movedToElementName = movedTo[movedTo.length-1];
             newRef.push(movedToElementName);
-            anythingFlattened=true;
+            lastFlattenedID = i;
           } else {
             newRef.push(ref[i]);
           }
           flattenWithPrevious = flattened;
         });
-        if (newRef !== undefined && anythingFlattened) { // do not replace unchanged references
+        if (newRef !== undefined && lastFlattenedID !== null) { // make sure the reference changed and only then replace it with the new one
           // check if this is a column and add alias if missing
-          if (isColumnInSelect(ref.$path)) {
-            if (!node.as) {
+          let structural = structuralPath(csn, path);
+          if (isColumnInSelectOrProjection(structural)) {
+            if (!node.as && lastFlattenedID === ref.length-1) // attach alias only if there is none and it is the last item in the reference that was flattened
               node.as = node.ref[node.ref.length - 1];
-            }
           }
           setProp(newRef, '$path', path.concat('ref'));
           if (!node.as) {
-            // FIXME: rather use scope from inspectRef to determin if path leads to a key
-            if (ifKeysScope(path))
+            if (isPartOfKeysStructure(structural))
               node.as = implicitAs(node.ref);
             else
               setProp(node, 'as', implicitAs(node.ref))
@@ -208,13 +222,11 @@ class ReferenceFlattener {
 
   applyAliasesInOnCond(csn, inspectRef) {
     forEachRef(csn, (ref, node, path) => {
-      // is there a better way to detect if we are dealing with on-cond?
-      // TODO: please do not use inspectRef() results for "where am I?" info
-      if (!['$self', 'parent'].includes(node.$scope)) return;
-      // the above condition means: only handle references starting with
-      // $self or element references outside queries
-
+      // Process only on-conditions of associations
+      let structural = structuralPath(csn, path);
+      if(!isOnCondition(structural)) return;
       let { links } = inspectRef(path);
+      if(!links) return; // $user not resolvable
       let keysOfPreviousStepWhenManagedAssoc = undefined;
 
       let aliasedRef = [...ref];
@@ -238,32 +250,41 @@ class ReferenceFlattener {
   }
 }
 
-// FIXME: rather use scope from inspectRef to determin if path leads to a key
-function ifKeysScope(path) {
-  if (!path) return false;
-  if (Number.isInteger(path[path.length - 1]) && path[path.length - 2] === 'keys' && path[path.length - 4] === 'elements')
-    return true;
-  return false;
+/**
+ * Checks if the provided path is a column inside a key node
+ * by exploring the possibility of the structural path to  ends with 'elements' and 'keys'.
+ *
+ * @param structural structural path to explore
+ * @returns {boolean} True if the provided path matched the requirements to be part of a key node.
+ */
+function isPartOfKeysStructure(structural) {
+  return structural[structural.length-2] === 'elements'
+      && structural[structural.length-1] === 'keys';
 }
 
 /**
- * Checks if the provided path is a column inside a select node
- * by exploring the possibility of the path to end with ['SELECT','columns','<an integer>', <ref - not checked>].
+ * Checks if the provided path is a column inside a select or a projection node
+ * by exploring the possibility of the structural path to contain 'SELECT' or 'projection'
+ * and ends with 'columns' or 'columns' and 'expand'.
  *
- * @param {CSN.Path} path Path to explore
+ * @param structural structural path to explore
  * @returns {boolean} True if the provided path matched the requirements to be a select node.
  */
-function isColumnInSelect(path) {
-  if (!path)
-    return false;
-  const len = path.length;
-  if (path[len - 4] === 'SELECT' && path[len - 3] === 'columns') {
-    // check if -2 element is an integer / array index
-    const arrayIndex = parseInt(String(path[len - 2]), 10);
-    if (!isNaN(arrayIndex))
-      return true;
-  }
-  return false;
+function isColumnInSelectOrProjection(structural) {
+  return (structural.includes('SELECT') ||  structural.includes('projection'))
+    && (structural[structural.length-1] === 'columns' || (structural[structural.length-2] === 'columns' && structural[structural.length-1] === 'expand'));
+}
+
+/**
+ * Checks if the provided path is a column inside an on-condition of an element
+ * by exploring the possibility of the structural path to  ends with 'elements' and 'on'.
+ *
+ * @param structural structural path to explore
+ * @returns {boolean} True if the provided path matched the requirements to be part of an element's on-condition.
+ */
+function isOnCondition(structural) {
+  return structural[structural.length-2] === 'elements'
+      && structural[structural.length-1] === 'on';
 }
 
 module.exports = ReferenceFlattener;

package/lib/transform/odata/sortByAssociationDependency.js

@@ -24,7 +24,7 @@ function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember)
   forEachDefinition(csn, (def, definitionName) => {
     /** @type {CSN.Path} */
     let root = ['definitions', definitionName];
-    forEachMemberRecursively(def, (element, elementName, _prop, subpath, parent) => {
+    forEachMemberRecursively(def, (element, elementName, structuralNodeName, subpath, parent) => {
       let path = root.concat(subpath);
       // go only through managed associations and compositions
       if (isAssociationOrComposition(element) && element.keys && !element.on) { // check association FKs
@@ -44,7 +44,7 @@ function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember)
             elementDependencies.push(targetElementPath);
           }
         })
-        dependencies[path.join("/")] = { definitionName, elementName, element, path, parent, dependencies: elementDependencies };
+        dependencies[path.join("/")] = { structuralNodeName, definitionName, elementName, element, path, parent, dependencies: elementDependencies };
       }
     }) // forEachMemberRecursively
   }, { skipArtifact: isExternalServiceMember }) // forEachDefinition

package/lib/transform/odata/structuralPath.js

@@ -0,0 +1,72 @@
+// The module traverses a given CSN using a specific path, collects structural node names and returns them.
+
+const structuralNodeHandlers = {
+  definitions: traverseDict,
+  elements: traverseDict,
+  actions: traverseDict,
+  params: traverseDict,
+  items: traverseTyped,
+  enum: traverseDict,
+  returns: traverseTyped,
+  on: traverseArray,
+  keys: traverseArray,
+  ref: traverseArray,
+  query: traverseTyped,
+  SELECT: traverseTyped,
+  SET: traverseTyped,
+  args: traverseArray,
+  columns: traverseArray,
+  projection: traverseTyped,
+  from: traverseTyped,
+  mixin: traverseDict,
+  where: traverseArray,
+  orderBy: traverseArray,
+  groupBy: traverseArray,
+  having: traverseArray,
+  xpr: traverseArray,
+  expand: traverseArray,
+  inline: traverseArray,
+  cast: traverseTyped,
+}
+
+function structuralPath(csn, path) {
+  return traverseDict(csn.definitions, path, 1, ['definitions']);
+}
+
+function traverseArray(obj, path, index, typeStack) {
+  if(!Array.isArray(obj)) return typeStack;
+  const name = path[index];
+  const element = obj[name];
+  return traverseTyped(element, path, index+1, typeStack);
+}
+
+function traverseDict(obj, path, index, typeStack) {
+  if(typeof obj !== 'object') return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  return traverseTyped(obj[name], path, index+1, typeStack);
+}
+
+function traverseDictArray(obj, path, index, typeStack) {
+  if(typeof obj !== 'object') return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  return traverseArray(obj[name], path, index+1, typeStack);
+}
+
+function traverseTyped(obj, path, index, typeStack) {
+  if(!obj) return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  if(name[0] === '@') return typeStack; // skip annotations
+  const func = structuralNodeHandlers[name];
+  if(func) return func(obj[name], path, index+1, typeStack.concat(name));
+  // not typed -> columns?
+  if(typeStack[typeStack.length-1] === 'columns')
+    return traverseDictArray(obj, path, index, typeStack);
+  return typeStack;
+}
+
+module.exports = {
+  structuralPath
+}