@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/transform/forOdataNew.js

@@ -7,7 +7,7 @@ const { getUtils,
         cloneCsn,
         forEachDefinition,
         forEachMemberRecursively,
-        forEachRef,
+        applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf,
         getElementDatabaseNameOf,
         isAspect,
@@ -16,7 +16,7 @@ const { getUtils,
       } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
-const { isArtifactInSomeService, getServiceOfArtifact, isLocalizedArtifactInService } = require('./odata/utils');
+const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./odata/utils');
 const ReferenceFlattener = require('./odata/referenceFlattener');
 const { flattenCSN } = require('./odata/structureFlattener');
 const generateForeignKeys = require('./odata/generateForeignKeyElements');
@@ -24,7 +24,8 @@ 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 enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
+const generateDrafts = require('./draft/odata');
 
 const { addLocalizationViews } = require('./localized');
 
@@ -75,7 +76,7 @@ function transform4odataWithCsn(inputModel, options) {
   // copy the model as we don't want to change the input model
   let csn = cloneCsn(inputModel, options);
 
-  const { error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
+  const { message, error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
   throwWithError();
 
   // the new transformer works only with new CSN
@@ -84,22 +85,16 @@ function transform4odataWithCsn(inputModel, options) {
   const transformers = transformUtils.getTransformers(csn, options, '_');
   const {
     addDefaultTypeFacets,
-    createForeignKeyElement,
-    createAndAddDraftAdminDataProjection, createScalarElement,
-    createAssociationElement, createAssociationPathComparison,
-    addElement, createAction, assignAction,
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
-    recurseElements, setAnnotation, resetAnnotation, renameAnnotation,
+    recurseElements, setAnnotation, renameAnnotation,
     expandStructsInExpression
   } = transformers;
 
   const csnUtils = getUtils(csn);
   const {
     getCsnDef,
-    getFinalType,
     getServiceName,
-    hasAnnotationValue,
     isAssocOrComposition,
     isAssociation,
     isStructured,
@@ -133,7 +128,7 @@ function transform4odataWithCsn(inputModel, options) {
   addLocalizationViews(csn, options, acceptLocalizedView);
 
   validate.forOdata(csn, {
-    error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
   });
 
 
@@ -209,19 +204,7 @@ function transform4odataWithCsn(inputModel, options) {
   //        - structured types must not contain associations for OData V2
   // - Element must not be an 'array of' for OData V2 TODO: move to the validator
   // - Perform checks for exposed non-abstract entities and views - check media type and key-ness
-  let visitedArtifacts = Object.create(null);
-  forEachDefinition(csn, (def, defName) => {
-    if (def.kind === 'entity' || def.kind === 'view') {
-      // Generate artificial draft fields if requested
-      if (def['@odata.draft.enabled']) {
-        // Ignore if not part of a service
-        if (isArtifactInSomeService(defName, services)) {
-          generateDraftForOdata(def, defName, def, visitedArtifacts);
-        }
-      }
-    }
-    visitedArtifacts[defName] = true;
-  }, { skipArtifact: isExternalServiceMember });
+  generateDrafts(csn, options, services)
 
   // Deal with all kind of annotations manipulations here
   forEachDefinition(csn, (def, defName) => {
@@ -342,7 +325,7 @@ function transform4odataWithCsn(inputModel, options) {
       // but '@Core.Immutable' for everything else.
       if (!(node['@readonly'] && node['@insertonly'])) {
         if (name === '@readonly' && node[name] !== null) {
-          if (node.kind === 'entity' || node.kind === 'view') {
+          if (node.kind === 'entity') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -352,7 +335,7 @@ function transform4odataWithCsn(inputModel, options) {
         }
         // @insertonly is effective on entities/queries only
         else if (name === '@insertonly' && node[name] !== null) {
-          if (node.kind === 'entity' || node.kind === 'view') {
+          if (node.kind === 'entity') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -423,151 +406,14 @@ function transform4odataWithCsn(inputModel, options) {
     // removes leading $self in on-conditions's references
     function removeLeadingDollarSelfInOnCondition(assoc) {
       if (!assoc.on) return; // nothing to do
-      forEachRef(assoc, (ref, node) => {
-        // remove leading $self when at the begining of a ref
-        if (ref.length > 1 && ref[0] === '$self')
-          node.ref.splice(0, 1);
-      });
-    }
-  }
-
-  // Generate all that is required in ODATA for draft enablement of 'artifact' into the artifact,
-  // into its transitively reachable composition targets, and into the model.
-  // 'rootArtifact' is the root artifact where composition traversal started.
-
-  // Constraints
-  // Draft Root: Exactly one PK of type UUID
-  // Draft Node: One PK of type UUID + 0..1 PK of another type
-  // Draft Node: Must not be reachable from multiple draft roots
-  function generateDraftForOdata(artifact, artifactName, rootArtifact, visitedArtifacts) {
-    // Sanity check
-    // @ts-ignore
-    if (!isArtifactInSomeService(artifactName, services)) {
-      throw new Error('Expecting artifact to be part of a service: ' + JSON.stringify(artifact));
-    }
-    // Nothing to do if already draft-enabled (composition traversal may have circles)
-    if ((artifact['@Common.DraftRoot.PreparationAction'] || artifact['@Common.DraftNode.PreparationAction'])
-      && artifact.actions && artifact.actions.draftPrepare) {
-      return;
-    }
-
-    // Generate the DraftAdministrativeData projection into the service, unless there is already one
-    // @ts-ignore
-    let draftAdminDataProjectionName = `${getServiceOfArtifact(artifactName, services)}.DraftAdministrativeData`;
-    let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
-    if (!draftAdminDataProjection) {
-      // @ts-ignore
-      draftAdminDataProjection = createAndAddDraftAdminDataProjection(getServiceOfArtifact(artifactName, services));
-    }
-    // Report an error if it is not an entity or not what we expect
-    if (draftAdminDataProjection.kind !== 'entity' || !draftAdminDataProjection.elements['DraftUUID']) {
-      error(null, ['definitions', draftAdminDataProjectionName], { name: draftAdminDataProjectionName },
-        `Generated entity $(NAME) conflicts with existing artifact`);
-    }
-    // Generate the annotations describing the draft actions (only draft roots can be activated/edited)
-    if (artifact == rootArtifact) {
-      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 {
-      resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
-    }
-
-    artifact.elements && Object.values(artifact.elements).forEach( elem => {
-      // Make all non-key elements nullable
-      if (elem.notNull && elem.key !== true) {
-        delete elem.notNull;
-      }
-    });
-    // Generate the additional elements into the draft-enabled artifact
-
-    // key IsActiveEntity : Boolean default true
-    let isActiveEntity = createScalarElement('IsActiveEntity', 'cds.Boolean', true, true, false);
-    isActiveEntity.IsActiveEntity['@UI.Hidden'] = true;
-    addElement(isActiveEntity, artifact, artifactName);
-
-    // HasActiveEntity : Boolean default false
-    let hasActiveEntity = createScalarElement('HasActiveEntity', 'cds.Boolean', false, false, true);
-    hasActiveEntity.HasActiveEntity['@UI.Hidden'] = true;
-    addElement(hasActiveEntity, artifact, artifactName);
-
-    // HasDraftEntity : Boolean default false;
-    let hasDraftEntity = createScalarElement('HasDraftEntity', 'cds.Boolean', false, false, true);
-    hasDraftEntity.HasDraftEntity['@UI.Hidden'] = true;
-    addElement(hasDraftEntity, artifact, artifactName);
-
-    // @odata.contained: true
-    // DraftAdministrativeData : Association to one DraftAdministrativeData;
-    let draftAdministrativeData = createAssociationElement('DraftAdministrativeData', draftAdminDataProjectionName, true);
-    draftAdministrativeData.DraftAdministrativeData.cardinality = { max: 1, };
-    draftAdministrativeData.DraftAdministrativeData['@odata.contained'] = true;
-    draftAdministrativeData.DraftAdministrativeData['@UI.Hidden'] = true;
-    addElement(draftAdministrativeData, artifact, artifactName);
-
-    // Note that we need to do the ODATA transformation steps for managed associations
-    // (foreign key field generation, generatedFieldName) by hand, because the corresponding
-    // transformation steps have already been done on all artifacts when we come here)
-    let uuidDraftKey = draftAdministrativeData.DraftAdministrativeData.keys.filter(key => key.ref && key.ref.length === 1 && key.ref[0] === 'DraftUUID');
-    if (uuidDraftKey && uuidDraftKey[0]) {
-      uuidDraftKey = uuidDraftKey[0]; // filter returns an array, but it has only one element
-      let path = ['definitions', artifactName, 'elements', 'DraftAdministrativeData', 'keys', 0];
-      createForeignKeyElement(draftAdministrativeData.DraftAdministrativeData, 'DraftAdministrativeData', uuidDraftKey, artifact, artifactName, path);
-    }
-    // SiblingEntity : Association to one <artifact> on (... IsActiveEntity unequal, all other key fields equal ...)
-    let siblingEntity = createAssociationElement('SiblingEntity', artifactName, false);
-    siblingEntity.SiblingEntity.cardinality = { max: 1 };
-    addElement(siblingEntity, artifact, artifactName);
-    // ... on SiblingEntity.IsActiveEntity != IsActiveEntity ...
-    siblingEntity.SiblingEntity.on = createAssociationPathComparison('SiblingEntity', 'IsActiveEntity', '!=', 'IsActiveEntity');
-
-    // Iterate elements
-    artifact.elements && Object.entries(artifact.elements).forEach( ([elemName, elem]) => {
-      if (elemName !== 'IsActiveEntity' && elem.key) {
-        // Amend the ON-condition above:
-        // ... and SiblingEntity.<keyfield> = <keyfield> ... (for all key fields except 'IsActiveEntity')
-        let cond = createAssociationPathComparison('SiblingEntity', elemName, '=', elemName);
-        cond.push('and');
-        cond.push(...siblingEntity.SiblingEntity.on);
-        siblingEntity.SiblingEntity.on = cond;
-      }
-
-      // Draft-enable the targets of composition elements (draft nodes), too
-      // TODO rewrite
-      if (elem.target && elem.type && getFinalType(elem.type) === 'cds.Composition') {
-        let draftNode = csn.definitions[elem.target];
-
-        // Ignore if that is our own draft root
-        if (draftNode != rootArtifact) {
-          // 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”');
-          }
-          // Ignore composition if not part of a service or explicitly draft disabled
-          else if (!getServiceName(elem.target) || hasAnnotationValue(draftNode, '@odata.draft.enabled', false)) {
-            return;
-          }
-          else {
-            // Generate draft stuff into the target
-            generateDraftForOdata(draftNode, elem.target, rootArtifact, visitedArtifacts);
-          }
+      // TODO: Shouldn't this only run on the on-condition and not the whole assoc-node?
+      applyTransformationsOnNonDictionary({ assoc }, 'assoc', {
+        ref: (node, prop, ref) => {
+          // remove leading $self when at the begining of a ref
+          if (ref.length > 1 && ref[0] === '$self')
+            node.ref.splice(0, 1);
         }
-      }
-    });
-
-    // Generate the actions into the draft-enabled artifact (only draft roots can be activated/edited)
-
-    // action draftPrepare (SideEffectsQualifier: String) return <artifact>;
-    let draftPrepare = createAction('draftPrepare', artifactName, 'SideEffectsQualifier', 'cds.String');
-    assignAction(draftPrepare, artifact);
-
-    if (artifact == rootArtifact) {
-      // action draftActivate() return <artifact>;
-      let draftActivate = createAction('draftActivate', artifactName);
-      assignAction(draftActivate, artifact);
-
-      // action draftEdit (PreserveChanges: Boolean) return <artifact>;
-      let draftEdit = createAction('draftEdit', artifactName, 'PreserveChanges', 'cds.Boolean');
-      assignAction(draftEdit, artifact);
+      });
     }
   }
 

package/lib/transform/localized.js

@@ -48,7 +48,7 @@ const _targetFor = Symbol('_targetFor');
  * We have three kinds of localized convenience views:
  *
  *  1. "direct ones" using coalesce() for the table entities with localized
- *     elements: as projection on the original (created in definer.js)
+ *     elements: as projection on the original (created in extend.js)
  *  2. for table entities with associations to entities which have a localized
  *     convenience views or redirections thereon: as projection on the original
  *  3. for view entities with associations to entities which have a localized
@@ -74,11 +74,10 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   if (hasErrors(options.messages))
     return csn;
 
-  if (hasExistingLocalizationViews(csn, options))
+  const messageFunctions = makeMessageFunction(csn, options);
+  if (hasExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
 
-  const { info } = makeMessageFunction(csn, options);
-
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
 
@@ -102,7 +101,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
         return;
 
       if (isInLocalizedNamespace(artName))
-        // We already issued a warning for it in warnAboutExistingLocalizationViews()
+        // We already issued a warning for it in hasExistingLocalizationViews()
         return;
 
       const localized = getLocalizedTextElements( artName );
@@ -127,7 +126,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
     if (csn.definitions[viewName]) {
       // Already exists, skip creation.
-      info( null, artPath, null, 'Convenience view can\'t be created due to conflicting names' );
+      messageFunctions.info( null, artPath, null, 'Convenience view can\'t be created due to conflicting names' );
       return;
     }
 
@@ -339,7 +338,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
       if (elem.key || elem.$key || elem.localized)
         textElements.push( elemName );
 
-      // TODO: Already warned about in definer.js
+      // TODO: Already warned about in extend.js
       // if (elem.key && isLocalized)
       //   warning( 'localized-key', path, {}, 'Keyword "localized" is ignored for primary keys' );
     }, artPath);
@@ -349,7 +348,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
       return null;
 
     if (!isEntityPreprocessed( art )) {
-      info( null, artPath, { name: artName },
+      messageFunctions.info( null, artPath, { name: artName },
              'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements' );
       return null;
     }
@@ -358,13 +357,13 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     const textsEntity = csn.definitions[textsName];
 
     if (!textsEntity) {
-      info( null, artPath, { name: artName },
+      messageFunctions.info( null, artPath, { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity could not be found' );
       return null;
     }
 
     if (!isValidTextsEntity( textsEntity )) {
-      info( null, [ 'definitions', textsName ], { name: artName },
+      messageFunctions.info( null, [ 'definitions', textsName ], { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid' );
       return null;
     }
@@ -685,18 +684,32 @@ function copyPersistenceAnnotations(target, source) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  */
-function hasExistingLocalizationViews(csn, options) {
+function hasExistingLocalizationViews(csn, options, messageFunctions) {
   if (!csn || !csn.definitions)
     return false;
-  const firstLocalizedView = Object.keys(csn.definitions).find(isInLocalizedNamespace);
-  if (firstLocalizedView) {
-    const { info } = makeMessageFunction(csn, options);
-    info( null, [ 'definitions', firstLocalizedView ], {},
-          'Input CSN already contains expansions for localized data' );
-    return true;
+
+  let hasExistingViews = false;
+  let hasNonViews = false;
+
+  for (const name in csn.definitions) {
+    const art = csn.definitions[name];
+    if (isInLocalizedNamespace(name) || name === 'localized') {
+      if (!art.query && !art.projection) {
+        if (!name.endsWith('.texts')) {
+          hasNonViews = true;
+          messageFunctions.error('reserved-namespace-localized', ['definitions', name], {},
+            'The namespace "localized" is reserved for localization views');
+        }
+      } else if (!hasExistingViews) {
+        hasExistingViews = true;
+        messageFunctions.info( null, [ 'definitions', name ], {},
+          'Input CSN already contains localization views, no further ones will be created' );
+      }
+    }
   }
-  return false;
+  return hasExistingViews || hasNonViews;
 }
 
 /**
@@ -728,9 +741,10 @@ function isEntityPreprocessed(entity) {
 
 /**
  * @param {string} name
+ * @returns {boolean}
  */
 function isInLocalizedNamespace(name) {
-  return name.startsWith('localized.');
+  return name === 'localized' || name.startsWith('localized.');
 }
 
 /**
@@ -738,6 +752,7 @@ function isInLocalizedNamespace(name) {
  *
  * @param {CSN.Model} csn
  * @param {string} artifactName
+ * @returns {boolean}
  */
 function hasLocalizedConvenienceView(csn, artifactName) {
   return !isInLocalizedNamespace(artifactName) && !!csn.definitions[`localized.${ artifactName }`];

package/lib/transform/odata/generateForeignKeyElements.js

@@ -37,7 +37,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     sortedAssociations.forEach(item => {
       const { definitionName, structuralNodeName, elementName, element, parent, path } = item;
 
-      if (csnUtils.isManagedAssociationElement(element) && element.keys) {
+      if (csnUtils.isManagedAssociation(element) && element.keys) {
         if (flatKeys) // tackling the ref value in assoc.keys
           takeoverForeignKeysOfTargetAssociations(element, path, generatedForeignKeyNamesForPath);
         // TODO: move in separate function

package/lib/transform/odata/referenceFlattener.js

@@ -1,4 +1,4 @@
-const { forEachRef } = require('../../model/csnUtils');
+const { applyTransformations } = require('../../model/csnUtils');
 const { setProp } = require('../../base/model');
 const { implicitAs } = require('../../model/csnRefs');
 const { structuralPath } = require('./structuralPath');
@@ -52,32 +52,34 @@ class ReferenceFlattener {
    * @param {*} isStructured Callback function checking of an artifact is a structured element.
    */
   resolveAllReferences(csn, inspectRef, isStructured) {
-    forEachRef(csn, (_ref, node, path) => {
-      if (!path) return;
-      let resolved;
-      try {
-        resolved = inspectRef(path);
-      } catch (ex) {
-        return;  // TODO: fix tests: throw Error("Could not inspectRef: " + path.join("/"));
-      }
-      if (!resolved)
-        return; // TODO: fix tests: throw Error("Could not resolve: " + path.join("/"));
-      if (!resolved.links)
-        return; // TODO: fix tests:  throw Error("Could not resolve links: " + path.join("/"));
-      let paths = [];
-      resolved.links.forEach((element) => {
-        if (!element.art)
-          paths = undefined; // not resolved -> no paths
-        if (paths) {
-          paths.push(element.art.$path);
+    applyTransformations(csn, {
+      ref: (node, prop, _ref, path) => {
+        if (!path) return;
+        let resolved;
+        try {
+          resolved = inspectRef(path);
+        } catch (ex) {
+          return;  // TODO: fix tests: throw Error("Could not inspectRef: " + path.join("/"));
         }
-      });
-      if (paths)
-        setProp(node, '$paths', paths);
-      // cache if structured or not
-      let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
-      this.structuredReference[path.join('/')] = structured;
-    });
+        if (!resolved)
+          return; // TODO: fix tests: throw Error("Could not resolve: " + path.join("/"));
+        if (!resolved.links)
+          return; // TODO: fix tests:  throw Error("Could not resolve links: " + path.join("/"));
+        let paths = [];
+        resolved.links.forEach((element) => {
+          if (!element.art)
+            paths = undefined; // not resolved -> no paths
+          if (paths) {
+            paths.push(element.art.$path);
+          }
+        });
+        if (paths)
+          setProp(node, '$paths', paths);
+        // cache if structured or not
+        let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
+        this.structuredReference[path.join('/')] = structured;
+      }
+    })
   }
 
   /**
@@ -172,80 +174,84 @@ class ReferenceFlattener {
    * @param {*} csn
    */
   flattenAllReferences(csn) {
-    forEachRef(csn, (ref, node, path) => {
-      if (node.$paths) {
-        let newRef = []; // flattened reference
-        let flattenWithPrevious = false;
-        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 movedTo = this.elementTransitions[spath]; // detect element transition
-          let flattened = this.flattenedElementPaths[spath];
-          if (flattenWithPrevious) {
-            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];
+    applyTransformations(csn, {
+      ref: (node, prop, ref, path) => {
+        if (node.$paths) {
+          let newRef = []; // flattened reference
+          let flattenWithPrevious = false;
+          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 movedTo = this.elementTransitions[spath]; // detect element transition
+            let flattened = this.flattenedElementPaths[spath];
+            if (flattenWithPrevious) {
+              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);
+              lastFlattenedID = i;
+            } else {
+              newRef.push(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);
-            lastFlattenedID = i;
-          } else {
-            newRef.push(ref[i]);
-          }
-          flattenWithPrevious = flattened;
-        });
-        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
-          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) {
-            if (isPartOfKeysStructure(structural))
-              node.as = implicitAs(node.ref);
-            else
-              setProp(node, 'as', implicitAs(node.ref))
+            flattenWithPrevious = flattened;
+          });
+          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
+            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) {
+              if (isPartOfKeysStructure(structural))
+                node.as = implicitAs(node.ref);
+              else
+                setProp(node, 'as', implicitAs(node.ref))
+            }
+            node.ref = newRef;
           }
-          node.ref = newRef;
         }
       }
     })
   }
 
   applyAliasesInOnCond(csn, inspectRef) {
-    forEachRef(csn, (ref, node, path) => {
-      // 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];
-
-      for (let idx = 0; idx < ref.length; idx++) {
-        const currArt = links[idx].art;
-        if (keysOfPreviousStepWhenManagedAssoc) {
-          const usedKey = keysOfPreviousStepWhenManagedAssoc.find(key => key.ref[0] === ref[idx]);
-          if (usedKey && usedKey.as) {
-            aliasedRef.splice(idx, usedKey.ref.length, usedKey.as);
-            idx += usedKey.ref.length - 1;
-            keysOfPreviousStepWhenManagedAssoc = undefined;
+    applyTransformations(csn, {
+      ref: (node, prop, ref, path) => {
+        // 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];
+  
+        for (let idx = 0; idx < ref.length; idx++) {
+          const currArt = links[idx].art;
+          if (keysOfPreviousStepWhenManagedAssoc) {
+            const usedKey = keysOfPreviousStepWhenManagedAssoc.find(key => key.ref[0] === ref[idx]);
+            if (usedKey && usedKey.as) {
+              aliasedRef.splice(idx, usedKey.ref.length, usedKey.as);
+              idx += usedKey.ref.length - 1;
+              keysOfPreviousStepWhenManagedAssoc = undefined;
+            }
+          } else {
+            keysOfPreviousStepWhenManagedAssoc =
+              (currArt.type === 'cds.Association' || currArt.type === 'cds.Composition') && currArt.keys;
           }
-        } else {
-          keysOfPreviousStepWhenManagedAssoc =
-            (currArt.type === 'cds.Association' || currArt.type === 'cds.Composition') && currArt.keys;
         }
+        node.ref = aliasedRef;
       }
-      node.ref = aliasedRef;
     })
   }
 }

package/lib/transform/odata/structureFlattener.js

@@ -71,7 +71,7 @@ function flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExterna
  * @param {Function} error
  */
 function flattenDefinition(definition, definitionPath, csnUtils, options, referenceFlattener, error) {
-  if (definition.kind !== 'entity' && definition.kind !== 'view')
+  if (definition.kind !== 'entity')
     return;
 
   let { newFlatElements } = flattenStructure(definition.elements, definitionPath, csnUtils, options, error, referenceFlattener);