@sap/cds-compiler 4.7.6 → 4.8.0

package/lib/transform/forRelationalDB.js

@@ -2,9 +2,10 @@
 
 const { setProp, isBetaEnabled } = require('../base/model');
 const { forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
-        getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
+        getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
         isAspect, walkCsnPath, isPersistedOnDatabase
       } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
 const { csnRefs, pathId, traverseQuery, columnAlias} = require('../model/csnRefs');
@@ -256,25 +257,14 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   //
   // First, gather all nodes that are arrayed: Don't replace inline, or getFinalTypeInfo()
   // may not return `.items` for types that were already processed.
+  // TODO: Do this in resolveTypeReferences?
   {
-    const removeItems = new Set();
     applyTransformations(csn, {
       type: (node) => {
-        if (node.items || node.type && csnUtils.getFinalTypeInfo(node.type)?.items)
-          removeItems.add(node);
         renamePrimitiveTypesAndUuid(node.type, node, 'type');
         addDefaultTypeFacets(node, implicitDefaultLengths);
       },
-      items: (node) => removeItems.add(node),
     });
-    // no support for array-of - turn into CLOB/Text
-    // must be done after A2J or compiler checks could change
-    // (e.g. annotation def checks for arrayed types)
-    for (const node of removeItems) {
-      node.type = 'cds.LargeString';
-      delete node.items;
-    }
-    removeItems.clear();
   }
 
   forEachDefinition(csn, [
@@ -294,15 +284,17 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // Managed associations get an on-condition - in views and entities
   doA2J && associations.attachOnConditions(csn, csnUtils, pathDelimiter);
 
-  // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
-  // and make them entities
-  forEachDefinition(csn, cdsPersistence.getPersistenceTableProcessor(csn, options, messageFunctions));
-
-  // Allow using managed associations as steps in on-conditions to access their fks
-  // To be done after handleAssociations, since then the foreign keys of the managed assocs
-  // are part of the elements
-  if (doA2J)
-    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, pathDelimiter));
+  {
+    // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
+    // and make them entities
+    const fns = [cdsPersistence.getPersistenceTableProcessor(csn, options, messageFunctions)];
+    // Allow using managed associations as steps in on-conditions to access their fks
+    // To be done after handleAssociations, since then the foreign keys of the managed assocs
+    // are part of the elements
+    if(doA2J) fns.push(associations.getFKAccessFinalizer(csn, csnUtils, pathDelimiter));
+
+    forEachDefinition(csn, fns);
+  }
 
   // Create convenience views for localized entities/views.
   // To be done after getFKAccessFinalizer because associations are
@@ -328,21 +320,15 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // - view with parameters: ok on HANA, not allowed otherwise
     // (don't complain about action/function with parameters)
     handleChecksForWithParameters,
-    // Remove .masked
-    // Check that keys are not explicitly nullable
-    // Check that Associations are not used in entities/views with parameters
-    // (150 b) Strip inheritance
-    // Note that this should happen after implicit redirection, because includes are required for that
-    handleDBChecks,
+    checkAssocsWithParams,
+    // (170) Transform '$self' in backlink associations to appropriate key comparisons
+    // Must happen before draft processing because the artificial ON-conditions in generated
+    // draft shadow entities have crooked '_artifact' links, confusing the backlink processing.
+    // But it must also happen after flattenForeignKeys has been called for all artifacts,
+    // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
+    backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, pathDelimiter, doA2J)
   ]);
 
-  // (170) Transform '$self' in backlink associations to appropriate key comparisons
-  // Must happen before draft processing because the artificial ON-conditions in generated
-  // draft shadow entities have crooked '_artifact' links, confusing the backlink processing.
-  // But it must also happen after flattenForeignKeys has been called for all artifacts,
-  // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
-  forEachDefinition(csn, backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, pathDelimiter, doA2J));
-
   /**
    * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
    * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
@@ -367,16 +353,14 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
-  const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions, transformCommon);
+  const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions);
   forEachDefinition(csn, transformViews);
 
-  // Recursively apply transformCommon and attach @cds.persistence.name
-  forEachDefinition(csn, recursivelyApplyCommon);
-
   const checkConstraintIdentifiers = (artifact, artifactName, prop, path) => {
     assertConstraintIdentifierUniqueness(artifact, artifactName, path, error);
   };
 
+  // TODO: Could we maybe merge this with the final applyTransformations?
   forEachDefinition(csn, [
     /* assert that there will be no conflicting unique- and foreign key constraint identifiers */
     checkConstraintIdentifiers,
@@ -386,9 +370,26 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     removeKeyPropInType,
   ]);
 
-  // Remove leading $self to keep renderer-diffs smaller
-  if(doA2J)
-    flattening.removeLeadingSelf(csn);
+
+  // TODO: Could we maybe merge this with the final applyTransformations?
+  applyTransformations(csn, {
+    elements: (parent, prop, elements, path) => {
+      // Attach @cds.persistence.name to elements, replace enums by their base value
+      const artifact = csn.definitions[path[1]];
+      forEach(elements, (name, element) => {
+        replaceEnums(element, name, path.concat(['elements', name]));
+        if ((!element.virtual || artifact.query))
+          csnUtils.addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(name, options.sqlMapping, options.sqlDialect), element);
+      });
+      // Remove leading $self to keep renderer-diffs smaller
+      if(doA2J && options.transformation === 'hdbcds')
+        flattening.removeLeadingSelf(parent, prop, elements);
+    }
+  }, [(definitions, artifactName, artifact) => {
+    // Attach @cds.persistence.name to artifacts
+    if (!artifact.$ignore && artifact.kind !== 'service' && artifact.kind !== 'context')
+      csnUtils.addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+  }], { allowArtifact: artifact => artifact.kind === 'entity'});
 
   throwWithAnyError();
 
@@ -434,7 +435,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         }
       }
     },
-
+    includes: killProp,
+    masked: killProp,
+    localized: killProp,
+    enum: killProp
   }
 
   if(options.sqlDialect === 'postgres') {
@@ -449,8 +453,25 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     killers.target = killParent;
   }
 
+  const killTypes = [];
+
+  if(doA2J) { // replace types and aspects with dummies to shrink overall CSN size
+    killers.kind = (parent, prop, kind, path) => {
+      if(kind === 'type' || kind === 'aspect') {
+        const artifactName = path[1];
+        killTypes.push(() => {
+          csn.definitions[artifactName] = {
+            kind,
+            type: 'cds.Integer'
+          };
+        })
+      }
+    }
+  }
+
   applyTransformations(csn, killers, [], { skipIgnore: false });
 
+  killTypes.forEach(fn => fn());
   redoProjections.forEach(fn => fn());
 
   timetrace.stop('Transform CSN');
@@ -577,34 +598,12 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   }
 
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function recursivelyApplyCommon(artifact, artifactName) {
-    if (!artifact.$ignore) {
-      if (artifact.kind !== 'service' && artifact.kind !== 'context')
-        csnUtils.addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
-
-      forEachMemberRecursively(artifact, (member, memberName, property, path) => {
-        if (property === 'returns')
-          return; // ignore "returns" type
-        transformCommon(member, memberName, path);
-        // (240 b) Annotate elements, foreign keys, parameters etc with their DB names
-        // Virtual elements in entities and types are not annotated, as they have no DB representation.
-        // In views they are, as we generate a null expression for them (null as <colname>)
-        if ((!member.virtual || artifact.query))
-          csnUtils.addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
-      }, [ 'definitions', artifactName ]);
-    }
-  }
-
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
   function removeKeyPropInType(artifact, artifactName) {
-    if (!artifact.$ignore && artifact.kind === 'type') {
+    if (!doA2J && !artifact.$ignore && artifact.kind === 'type') {
       forEachMemberRecursively(artifact, (member) => {
         if (member.key)
           delete member.key;
@@ -616,47 +615,42 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
-  function handleDBChecks(artifact, artifactName) {
-    // Strip inheritance
-    if (artifact.includes)
-      delete artifact.includes;
-
-    // Process the artifact's  members
-    forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
-      // (100 a) Ignore the property 'masked' itself (but not its effect on projections)
-      if (member.masked)
-        delete member.masked;
-      // Report an error on
-      // - view with parameters that has an element of type association/composition
-      // - association that points to entity with parameters
-      if (member.target && csnUtils.isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
-        if (artifact.params) {
-          // HANA does not allow 'WITH ASSOCIATIONS' on something with parameters:
-          // SAP DBTech JDBC: [7]: feature not supported: parameterized sql view cannot support association: line 1 col 1 (at pos 0)
-          message('def-unexpected-paramview-assoc', path, { '#': 'source' });
-        }
-        else if(artifact['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
-          // UDF/CVs w/o params don't support 'WITH ASSOCIATIONS'
-          const anno = artifact['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
-          message('def-unexpected-calcview-assoc', path, { '#': 'source', anno });
-        }
-        if (csn.definitions[member.target].params) {
-          // HANA does not allow association targets with parameters or to UDFs/CVs w/o parameters:
-          // SAP DBTech JDBC: [7]: feature not supported: cannot support create association to a parameterized view
-          message('def-unexpected-paramview-assoc', path, { '#': 'target' });
-        }
-        else if(csn.definitions[member.target]['@cds.persistence.udf'] || csn.definitions[member.target]['@cds.persistence.calcview']) {
-          // HANA won't check the assoc target but when querying an association with target UDF, this is the error:
-          // SAP DBTech JDBC: [259]: invalid table name: target object SYSTEM.UDF does not exist: line 3 col 6 (at pos 43)
-          // CREATE TABLE F (id INTEGER NOT NULL);
-          // CREATE FUNCTION UDF RETURNS TABLE (ID INTEGER) LANGUAGE SQLSCRIPT SQL SECURITY DEFINER AS BEGIN RETURN SELECT ID FROM F; END;
-          // CREATE TABLE Y (  id INTEGER NOT NULL,  toUDF_id INTEGER) WITH ASSOCIATIONS (MANY TO ONE JOIN UDF AS toUDF ON (toUDF.id = toUDF_id));
-          // CREATE VIEW U AS SELECT  id, toUDF.a FROM Y;
-          const anno = csn.definitions[member.target]['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
-          message('def-unexpected-calcview-assoc', path, { '#': 'target', anno });
+  function checkAssocsWithParams(artifact, artifactName) {
+    if(options.transformation === 'hdbcds') {
+      forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
+        // Report an error on
+        // - view with parameters that has an element of type association/composition
+        // - association that points to entity with parameters
+        if (member.target && csnUtils.isAssocOrComposition(member)) {
+          if (artifact.params) {
+            // HANA does not allow 'WITH ASSOCIATIONS' on something with parameters:
+            // SAP DBTech JDBC: [7]: feature not supported: parameterized sql view cannot support association: line 1 col 1 (at pos 0)
+            message('def-unexpected-paramview-assoc', path, { '#': 'source' });
+          }
+          else if(artifact['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
+            // UDF/CVs w/o params don't support 'WITH ASSOCIATIONS'
+            const anno = artifact['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+            message('def-unexpected-calcview-assoc', path, { '#': 'source', anno });
+          }
+          if (csn.definitions[member.target].params) {
+            // HANA does not allow association targets with parameters or to UDFs/CVs w/o parameters:
+            // SAP DBTech JDBC: [7]: feature not supported: cannot support create association to a parameterized view
+            message('def-unexpected-paramview-assoc', path, { '#': 'target' });
+          }
+          else if(csn.definitions[member.target]['@cds.persistence.udf'] || csn.definitions[member.target]['@cds.persistence.calcview']) {
+            // HANA won't check the assoc target but when querying an association with target UDF, this is the error:
+            // SAP DBTech JDBC: [259]: invalid table name: target object SYSTEM.UDF does not exist: line 3 col 6 (at pos 43)
+            // CREATE TABLE F (id INTEGER NOT NULL);
+            // CREATE FUNCTION UDF RETURNS TABLE (ID INTEGER) LANGUAGE SQLSCRIPT SQL SECURITY DEFINER AS BEGIN RETURN SELECT ID FROM F; END;
+            // CREATE TABLE Y (  id INTEGER NOT NULL,  toUDF_id INTEGER) WITH ASSOCIATIONS (MANY TO ONE JOIN UDF AS toUDF ON (toUDF.id = toUDF_id));
+            // CREATE VIEW U AS SELECT  id, toUDF.a FROM Y;
+            const anno = csn.definitions[member.target]['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+            message('def-unexpected-calcview-assoc', path, { '#': 'target', anno });
+          }
         }
-      }
-    }, [ 'definitions', artifactName ]);
+      }, [ 'definitions', artifactName ]);
+    }
+
   }
 
   /**
@@ -731,7 +725,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
 
   /**
-   * Remove `localized` from elements and replace Enum symbols by their values.
+   * Replace Enum symbols by their values.
    *
    * Only applies to elements.
    *
@@ -739,11 +733,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
    * @param {String} objName
    * @param {CSN.Path} path
    */
-  function transformCommon(obj, objName, path) {
-    // (100 b) Remove attribute 'localized'
-    if (obj.localized)
-      delete obj.localized;
-
+  function replaceEnums(obj, objName, path) {
     // (190 a) Replace enum symbols by their value (if found)
     replaceEnumSymbolsByValues(obj, path);
 
@@ -832,6 +822,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
+   * @todo can we do this earlier? Together with another forEachMemberRecursively?
    */
   function checkTypeParameters(artifact, artifactName) {
     forEachMemberRecursively(artifact, (member, memberName, prop, path) => {

package/lib/transform/odata/flattening.js

@@ -1,8 +1,9 @@
 '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 { applyTransformationsOnDictionary,
@@ -26,25 +27,32 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
           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;
+          forEach(dict, (childName, child) => {
+            const location = [ ...csnPath, childName ];
+            let 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, elt, resolvedElt,
-                !!elt.notNull, location, [ defName, eltName ]);
+              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]);
             }
           });
 
@@ -60,7 +68,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             elements[flatEltName] = flatElt;
             return elements;
           }, Object.create(null));
-          setProp(def, `$${dictName}`, flatDict);
+          setProp(def, `$flat${dictName}`, flatDict);
         }
       });
       const flatAnnos = Object.create(null);
@@ -91,7 +99,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
         }
         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
@@ -178,11 +186,11 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
            !isODataV4BuiltinFromService(elt.type, location)
            && !isItemsType(elt.type)) {
         let resolvedType = csnUtils.getFinalTypeInfo(elt);
-  
+
         delete resolvedType.kind;
         if(resolvedType.items)
           delete resolvedType.type;
-  
+
         if(elt.items) {
           if(resolvedType.items) {
             elt.items = resolvedType;
@@ -200,16 +208,16 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             elt.type = resolvedType;
         }
       }
-  
+
       function isItemsType(typeName) {
         let 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)) {
@@ -224,20 +232,19 @@ 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);
+      ref: (elemref, prop, xpr, path) => {
+        const { art } = (elemref._art ? { art: elemref._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' });
+          error('odata-anno-xpr-ref', path, { anno: refCheck.anno, elemref, name: refCheck.eltLocationStr, '#': 'flatten_builtin' });
         }
       }
     }
@@ -250,9 +257,14 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
     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(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
@@ -260,8 +272,14 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
         }
         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')
@@ -271,14 +289,13 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
         }
       }
     }
-    
+
     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,17 +320,10 @@ 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') {
       ['query', 'projection'].forEach(dictName => {
@@ -322,16 +332,45 @@ function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, iterateOptio
       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)) {
+      typeNames.push(defName);
       applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, iterateOptions, [ 'definitions' ]);
     }
   });
   adaptRefs.forEach(fn => fn());
   adaptRefs.length = 0;
+  if(isBetaEnabled(options, 'odataPathsInAnnotationExpressions')) {
+    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,19 +394,18 @@ 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 fn = (suspend=false, suspendPos=0) => {
         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);
+        parent.ref = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, suspend, suspendPos);
         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?