@sap/cds-compiler 4.1.2 → 4.2.4

package/lib/transform/db/constraints.js

@@ -56,6 +56,25 @@ function createReferentialConstraints( csn, options ) {
             },
           });
         }
+        // for `texts` compositions, we may generate foreign key constraints even w/o `up_`
+        else if (elementName === 'texts' && element.target === `${path[path.length - 1]}.texts`) {
+          const { on } = element;
+          const target = csn.definitions[element.target];
+          // `texts` entities have a key named "locale"
+          const targetSideHasLocaleKey = target.elements.locale?.key;
+          if (targetSideHasLocaleKey && !skipConstraintGeneration(parent, target, { /* there is no assoc */ })) {
+            const sourceElements = Array.from(elementsOfSourceSide(on, elements));
+            const targetElements = Array.from(elementsOfTargetSide(on, target.elements));
+            // `texts` entities have all the keys the original entity has
+            const allElementsAreKeysAndHaveTheSameName = targetElements.length &&
+            targetElements.every(
+              ([ targetKey, e ]) => e.key &&
+              sourceElements.some(([ sourceKey, sourceElement ]) => sourceElement.key && targetKey === sourceKey )
+            );
+            if (allElementsAreKeysAndHaveTheSameName)
+              attachConstraintsToDependentKeys(targetElements, sourceElements, path[path.length - 1], 'texts', { texts: true });
+          }
+        }
       }
     },
   }, [], { skipIgnore: false, skipArtifact: a => a.query || a.kind !== 'entity' });
@@ -134,7 +153,7 @@ function createReferentialConstraints( csn, options ) {
    * @param {Array} parentKeys array holding parent keys in the format [['key1', 'value1'], [...], ...]
    * @param {CSN.PathSegment} parentTable the sql-table where the foreign key constraints will be pointing to
    * @param {CSN.PathSegment} sourceAssociation the name of the association from which the constraint originates
-   * @param {CSN.PathSegment} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
+   * @param {CSN.PathSegment | object} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
    *                                    it is used for a comment in the constraint, which is only printed out in test-mode
    */
   function attachConstraintsToDependentKeys( dependentKeys, parentKeys, parentTable, sourceAssociation, upLinkFor = null ) {
@@ -440,13 +459,16 @@ function createReferentialConstraints( csn, options ) {
    */
   function elementsOfTargetSide( on, targetElements ) {
     const elements = new Map();
-    on.filter(element => typeof element === 'object' &&
-      element.ref.length > 1 &&
-      targetElements[element.ref[element.ref.length - 1]])
-      .forEach((element) => {
-        elements.set(element.ref[element.ref.length - 1], targetElements[element.ref[element.ref.length - 1]]);
-      });
-
+    const findElements = (tokenStream) => {
+      tokenStream
+        .forEach((element) => {
+          if (typeof element === 'object' && element.ref?.length > 1 && targetElements[element.ref[element.ref.length - 1]])
+            elements.set(element.ref[element.ref.length - 1], targetElements[element.ref[element.ref.length - 1]]);
+          else if (element.xpr)
+            findElements(element.xpr);
+        });
+    };
+    findElements(on);
     return elements;
   }
 
@@ -459,12 +481,16 @@ function createReferentialConstraints( csn, options ) {
    */
   function elementsOfSourceSide( on, sourceElements ) {
     const elements = new Map();
-    on.filter(element => typeof element === 'object' &&
-      element.ref.length === 1 &&
-      sourceElements[element.ref[0]])
-      .forEach((element) => {
-        elements.set(element.ref[0], sourceElements[element.ref[0]]);
-      });
+    const findElements = (tokenStream) => {
+      tokenStream
+        .forEach((element) => {
+          if (typeof element === 'object' && element.ref?.length === 1 && sourceElements[element.ref[0]])
+            elements.set(element.ref[0], sourceElements[element.ref[0]]);
+          else if (element.xpr)
+            findElements(element.xpr);
+        });
+    };
+    findElements(on);
     return elements;
   }
 
@@ -507,12 +533,16 @@ function createReferentialConstraints( csn, options ) {
         dependentKey.push(foreignKeyName);
         onDeleteRules.add($foreignKeyConstraintCopy.onDelete);
       });
-      // onDelete Rule is the "weakest" rule applicable. Precedence: RESTRICT > SET NULL > CASCADE
+      // onDelete Rule is the "weakest" rule applicable. Precedence: RESTRICT > CASCADE
       const onDelete = onDeleteRules.has('RESTRICT') ? 'RESTRICT' : 'CASCADE';
       let onDeleteRemark = null;
       // comments in sqlite files are causing the JDBC driver to throw an error on deployment
-      if (options.testMode && onDelete === 'CASCADE')
-        onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
+      if (options.testMode && onDelete === 'CASCADE') {
+        if ($foreignKeyConstraint.upLinkFor?.texts)
+          onDeleteRemark = `Constraint originates from localized composition ”${$foreignKeyConstraint.parentTable}:texts“`;
+        else
+          onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
+      }
       // constraint identifier usually start with `c__` to avoid name clashes
       let identifier = options.pre2134ReferentialConstraintNames ? '' : 'c__';
       identifier += `${getResultingName(csn, options.sqlMapping, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`;

package/lib/transform/db/expansion.js

@@ -5,8 +5,9 @@ const {
   applyTransformations,
   setDependencies,
   walkCsnPath,
+  getUtils,
 } = require('../../model/csnUtils');
-const { csnRefs, implicitAs } = require('../../model/csnRefs');
+const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 
@@ -18,35 +19,30 @@ const { forEach } = require('../../utils/objectUtils');
  * @param {CSN.Options} options
  * @param {string} pathDelimiter
  * @param {object} messageFunctions
- * @param {Function} messageFunctions.error
- * @param {Function} messageFunctions.info
- * @param {Function} messageFunctions.throwWithAnyError
  * @param {object} csnUtils
  * @param {object} [iterateOptions]
  */
-function expandStructureReferences( csn, options, pathDelimiter, { error, info, throwWithAnyError }, csnUtils, iterateOptions = {} ) {
-  const {
-    isStructured, get$combined, getFinalTypeInfo,
-  } = csnUtils;
-  let { effectiveType, inspectRef } = csnUtils;
+function expandStructureReferences( csn, options, pathDelimiter, messageFunctions, csnUtils, iterateOptions = {} ) {
+  const { error, info, throwWithAnyError } = messageFunctions;
 
   rewriteExpandInline();
 
-
   applyTransformations(csn, {
     keys: (parent, name, keys, path) => {
       parent.keys = expand(keys, path.concat('keys'), true);
     },
     columns: (parent, name, columns, path) => {
       const artifact = csn.definitions[path[1]];
+      csnUtils.initDefinition(artifact); // potentially no initialized, yet
       if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
-        const root = get$combined({ SELECT: parent });
+        const root = csnUtils.get$combined({ SELECT: parent });
         // TODO: replace with the correct options.transformation?
         // Do not expand the * in OData for a moment, not to introduce changes
         // while the OData CSN is still official
+        const isComplexQuery = parent.from.join !== undefined;
         if (!options.toOdata)
-          parent.columns = replaceStar(root, columns, parent.excluding);
-        parent.columns = expand(parent.columns, path.concat('columns'), true);
+          parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
+        parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery);
       }
     },
     groupBy: (parent, name, groupBy, path) => {
@@ -74,7 +70,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         // get$combined expects a SET/SELECT - so we wrap the parent
         // (which is the thing inside SET/SELECT)
         // We can directly use SELECT here, as only projections and SELECT can have .columns
-        const root = get$combined({ SELECT: parent });
+        const root = csnUtils.get$combined({ SELECT: parent });
         if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
           // Make root look like normal .elements - we never cared about conflict afaik anyway
           Object.keys(root).forEach((key) => {
@@ -102,7 +98,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
 
     cleanup.forEach(fn => fn());
 
-    ({ effectiveType, inspectRef } = csnRefs(csn));
+    csnUtils = getUtils(csn);
 
     const publishing = [];
     // OData must allow navigations to @cds.persistence.skip targets
@@ -144,7 +140,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         if (!(obj && obj.ref) || obj.$scope === 'alias')
           continue;
 
-        const links = obj._links || inspectRef(path.concat([ name, i ])).links;
+        const links = obj._links || csnUtils.inspectRef(path.concat([ name, i ])).links;
 
         if (!links)
           continue;
@@ -244,7 +240,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
      */
     function nextBase( parent, base ) {
       if (parent.ref) {
-        const finalBaseType = getFinalTypeInfo(parent._art.type);
+        const finalBaseType = csnUtils.getFinalTypeInfo(parent._art.type);
         const art = parent._art;
 
         if (finalBaseType && (finalBaseType.type === 'cds.Association' || finalBaseType.type === 'cds.Composition'))
@@ -297,7 +293,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
     function isToMany( obj ) {
       if (!obj._art)
         return false;
-      const eType = effectiveType(obj._art);
+      const eType = csnUtils.effectiveType(obj._art);
       return (eType.type === 'cds.Association' || eType.type === 'cds.Composition') && eType.cardinality && eType.cardinality.max !== 1;
     }
 
@@ -516,18 +512,18 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
    *
    * @param {Array} thing
    * @param {CSN.Path} path
-   * @param {boolean} [withAlias=false] Whether to "expand" the (implicit) alias aswell.
+   * @param {boolean} [withAlias=false] Whether to "expand" the (implicit) alias as well.
+   * @param {boolean} [isComplexQuery]
    * @returns {Array} New array - with all structured things expanded
    */
-  function expand( thing, path, withAlias = false ) {
+  function expand( thing, path, withAlias = false, isComplexQuery = false ) {
     const newThing = [];
     for (let i = 0; i < thing.length; i++) {
       const col = thing[i];
       if (col.ref && col.$scope !== '$magic') {
-        const _art = col._art || inspectRef(path.concat(i)).art;
-        if (_art && isStructured(_art))
-          newThing.push(...expandRef(_art, col, withAlias));
-
+        const _art = col._art || csnUtils.inspectRef(path.concat(i)).art;
+        if (_art && csnUtils.isStructured(_art))
+          newThing.push(...expandRef(_art, col, withAlias, isComplexQuery));
         else
           newThing.push(col);
       }
@@ -535,6 +531,23 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         col.as = implicitAs(col.ref);
         newThing.push(col);
       }
+      else if (col.cast?.type) {
+        const _art = col.cast._type || csnUtils.inspectRef(path.concat(i, 'cast', 'type')).art;
+        if (_art && csnUtils.isStructured(_art)) {
+          // special case for `null as name : Struct`
+          if (col.val === null) {
+            newThing.push(...expandValAsStructure(_art, col, withAlias));
+          }
+          else {
+            error('type-invalid-cast', path.concat(i, 'cast', 'type'), {
+              '#': col.val !== undefined ? 'val-to-structure' : 'expr-to-structure', value: col.val,
+            });
+          }
+        }
+        else {
+          newThing.push(col);
+        }
+      }
       else {
         newThing.push(col);
       }
@@ -544,44 +557,109 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
   }
 
   /**
-   * Expand the ref and - if requested - expand the alias with it.
-   *
-   * Iterative, to not run into stack overflow.
+   * Expands a column, and calls leafCallback() when a leaf node is reached.
    *
    * @param {CSN.Element} art
-   * @param {object} root Column, ref in order by, etc.
-   * @param {boolean} withAlias
-   * @returns {Array}
+   *     Structured Artifact which is used for expansion (and names, etc.).  For a ref, it's the
+   *     underlying type or a cast-type, for a value, it's always the cast-type.
+   * @param {string} colName
+   *     Name of the column, that is used as the first name segment, e.g. a column `a` may end up in
+   *     leafs `a_b` and `a_c`, if `art` has elements `b` and `c`.
+   * @param {string[]} colTypeRef
+   *     Expanded type for the column. Basically the path to the to-be-expanded `art`.
+   * @param {(currentRef: any[], currentAlias: string[]) => object} leafCallback
+   *    Callback when leaf nodes are reached. currentRef is the type reference for the expanded
+   *    column.  currentAlias is the columns calculated alias.
+   * @returns {object[]}
    */
-  function expandRef( art, root, withAlias ) {
+  function _expandStructCol( art, colName, colTypeRef, leafCallback ) {
     const expanded = [];
-    /** @type {Array<[CSN.Element, any[], any[]]>} */
-    const stack = [ [ art, root.ref, [ root.as || implicitAs(root.ref) ] ] ];
+    /** @type {Array<[CSN.Element, any[], string[]]>} */
+    const stack = [ [ art, colTypeRef, [ colName ] ] ];
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
-      if (isStructured(current)) {
-        for (const [ n, e ] of Object.entries(current.elements || effectiveType(current).elements).reverse())
-          stack.push([ e, currentRef.concat(n), currentAlias.concat(n) ]);
+      if (csnUtils.isStructured(current)) {
+        const elements = Object.entries(current.elements || csnUtils.effectiveType(current).elements).reverse();
+        for (const [ name, elem ] of elements)
+          stack.push([ elem, currentRef.concat(name), currentAlias.concat(name) ]);
       }
       else {
-        const obj = { ...root, ...{ ref: currentRef } };
-        if (withAlias) {
-          const newAlias = currentAlias.join(pathDelimiter);
-          // if (alias !== undefined) // explicit alias
-          obj.as = newAlias;
-          // alias was implicit - to later distinguish expanded s -> s.a from explicitly written s.a
-          if (root.as === undefined)
-            setProp(obj, '$implicitAlias', true);
-        }
-        if (root.key)
-          obj.key = true;
-        expanded.push(obj);
+        const newCol = leafCallback(currentRef, currentAlias);
+        expanded.push(newCol);
       }
     }
 
     return expanded;
   }
 
+  /**
+   * Expand the ref and - if requested - expand/set the alias with it.
+   *
+   * @param {CSN.Element} art
+   * @param {object} root Column, ref in order by, etc.
+   * @param {boolean} withAlias Whether to add an explicit flattened alias to the expanded columns/references.
+   * @param {boolean} [isComplexQuery]
+   * @returns {Array}
+   */
+  function expandRef( art, root, withAlias, isComplexQuery ) {
+    return _expandStructCol(art, columnAlias(root), root.ref, ( currentRef, currentAlias) => {
+      const obj = { ...root, ref: currentRef };
+      if (withAlias) {
+        // TODO: Remove this line in case foreign key annotations should
+        //       be adressed via full path into target instead of using alias
+        //       names. See flattening.js::flattenAllStructStepsInRefs()
+        //       apply transformations on `ref` counterpart comment.
+        setProp(obj, '$structRef', currentAlias);
+        obj.as = currentAlias.join(pathDelimiter);
+        // alias was implicit - to later distinguish expanded s -> s.a from explicitly written s.a
+        if (root.as === undefined)
+          setProp(obj, '$implicitAlias', true);
+      }
+
+      // The Java runtime, as of 2023-09-13, assumes that for _simple projections_, all references
+      // are relative to the query source.  To avoid breaking that assumption unless necessary,
+      // we only add the table alias if:
+      //  - it is a complex query with possibly multiple available table aliases, or
+      //  - the transformation is not for OData (which is used by Java), or
+      //  - the first path step has the same name as the table alias (only one, as otherwise the query would be complex)
+      if (typeof root.$env === 'string' && (isComplexQuery || options.transformation !== 'odata' || root.$env === pathId(obj.ref[0])))
+        obj.ref = [ root.$env, ...obj.ref ];
+
+      return obj;
+    });
+  }
+
+  /**
+   * Expand `null` columns which were cast to a structure, that is: `null as name : Struct`.
+   * Requires that `col` has an alias.
+   *
+   * @param {CSN.Element} art
+   * @param {object} col
+   * @param {boolean} withAlias Whether to add an explicit flattened alias to the expanded columns/references.
+   * @returns {Array}
+   */
+  function expandValAsStructure( art, col, withAlias ) {
+    const colName = col.as || '';
+    // Expression-columns may have an internal name such as `$_column_N`. If the name is internal,
+    // we should not publish names based upon the internal name.
+    const isInternal = !col.as || !Object.prototype.propertyIsEnumerable.call(col, 'as');
+
+    return _expandStructCol(art, colName, col.cast.type?.ref || [ col.cast.type ], ( currentRef, currentAlias) => {
+      const newCol = {
+        ...col,
+        val: col.val,
+        cast: { type: { ref: currentRef } },
+      };
+      if (withAlias) {
+        if (!isInternal)
+          newCol.as = currentAlias.join(pathDelimiter);
+        else
+          setProp(newCol, 'as', currentAlias.join(pathDelimiter));
+      }
+      return newCol;
+    });
+  }
+
   /**
    * Get the effective name produced by the object
    *
@@ -604,9 +682,10 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
    * @param {object} base The raw set of things a * can expand to
    * @param {Array} subs Things - the .expand/.inline or .columns
    * @param {string[]} [excluding=[]]
+   * @param {boolean} [isComplexQuery=false] Wether the query is a single source select or something more complex
    * @returns {Array} If there was a star, expand it and handle shadowing/excluding, else just return subs
    */
-  function replaceStar( base, subs, excluding = [] ) {
+  function replaceStar( base, subs, excluding = [], isComplexQuery = false ) {
     const stars = [];
     const names = Object.create(null);
     for (let i = 0; i < subs.length; i++) {
@@ -638,7 +717,11 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
             }
           }
           else { // the thing is not shadowed - use the name from the base
-            star.push({ ref: [ part ] });
+            const col = { ref: [ part ] };
+            if (isComplexQuery) // $env: tableAlias
+              setProp(col, '$env', base[part][0].parent);
+
+            star.push(col);
           }
         }
       }

package/lib/transform/db/flattening.js

@@ -7,7 +7,7 @@ const {
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
-const { setProp } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 const { cardinality2str } = require('../../model/csnUtils');
 
@@ -208,7 +208,10 @@ function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, ite
       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);
         resolved.set(parent, { links, art, scope });
         // Explicitly set implicit alias for things that are now flattened - but only in columns
@@ -219,7 +222,9 @@ function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, ite
           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) {
+        else if (parent.ref[parent.ref.length - 1] !== lastRef &&
+                (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
+                !parent.as) {
           parent.as = lastRef;
         }
       };
@@ -396,6 +401,36 @@ function getBranches( element, elementName, effectiveType, pathDelimiter ) {
   return branches;
 }
 
+/**
+ * Link annotate extensions to managed associations as a preparational step
+ * for later annotation assignment on the final foreignkeys
+ * This function must be applied on an unmodified, structured CSN in order to
+ * traverse both the extensions and dictionary trees in corresponding order.
+ *
+ * @param {CSN.Model} csn
+ * @param {object} options
+ */
+function linkForeignKeyAnnotationExtensionsToAssociation( csn, options ) {
+  if (isBetaEnabled(options, 'annotateForeignKeys')) {
+    csn.extensions?.forEach(( ext ) => {
+      const defName = ext.annotate;
+
+      const traverseExtensions = (env, enode) => {
+        if (env?.target && env?.keys) {
+          setProp(env, '$fkExtensions', enode);
+        }
+        else {
+          const elements = env?.items?.elements || env?.elements;
+          if (enode?.elements && elements)
+            Object.keys(enode.elements).forEach(en => traverseExtensions(elements[en], enode.elements[en]));
+        }
+      };
+      if (ext.annotate)
+        traverseExtensions(csn.definitions[defName], ext);
+    });
+  }
+}
+
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
@@ -530,7 +565,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
      * @returns {object} The clone of base
      */
     function cloneAndExtendRef( key, base, ref ) {
-      const clone = cloneCsnNonDict(base, options);
+      const clone = cloneCsnNonDict(base, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
       if (key.ref) {
         // We build a ref that contains the aliased fk - that element will be created later on, so this ref is not resolvable yet
         // Therefore we keep it as $ref - ref is the non-aliased, resolvable "clone"
@@ -546,6 +581,8 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
         }
         setProp(clone, '$ref', $ref);
         clone.ref = clone.ref.concat(key.ref);
+        if (clone.$structRef && key.$structRef)
+          clone.$structRef = clone.$structRef.concat(key.$structRef);
       }
 
       if (!clone.as && clone.ref && clone.ref.length > 0) {
@@ -646,6 +683,34 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
             }
           }
         }
+        // assign annotations from fkExtension tree to foreign keys
+        if (isBetaEnabled(options, 'annotateForeignKeys')) {
+          const extCollector = {};
+          fks.forEach(([ _fkn, fk ]) => {
+            let ext = element.$fkExtensions;
+            let extKey = elementName;
+            for (const step of fk.$extensionPath) {
+              extKey += `.${step}`;
+              ext = ext?.elements?.[step];
+              if (!ext)
+                break;
+              // collect annotations, lowest wins
+              // eslint-disable-next-line no-loop-func
+              Object.entries(ext).forEach(([ k, v ]) => {
+                if (k[0] === '@') {
+                  fk[k] = v;
+                  extCollector[extKey] = ext;
+                }
+              });
+            }
+          });
+
+          // remove consumed annotations after applying the annotation hierarchy to each fk!
+          Object.values(extCollector).forEach(ext => Object.keys(ext).forEach((k) => {
+            if (k[0] === '@')
+              delete ext[k];
+          }));
+        }
         orderedElements.push(...fks);
       });
 
@@ -669,10 +734,11 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
  * @param {CSN.Model} csn
  * @param {object} options
  * @param {string} pathDelimiter
+ * @param {object} extensionPath
  * @param {number} lvl
  * @returns {Array[]} First element of every sub-array is the foreign key name, second is the foreign key definition
  */
-function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0 ) {
+function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, extensionPath = [], lvl = 0 ) {
   const special$self = !csn?.definitions?.$self && '$self';
   const isInspectRefResult = !Array.isArray(path);
 
@@ -718,7 +784,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       const continuePath = getContinuePath([ 'keys', keyIndex ]);
       const alias = key.as || implicitAs(key.ref);
       const result = csnUtils.inspectRef(continuePath);
-      fks = fks.concat(createForeignKeys(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
+      fks = fks.concat(createForeignKeys(csnUtils, result, result.art, alias, csn, options, pathDelimiter, extensionPath.concat(key.$structRef), lvl + 1));
     });
     if (!hasKeys)
       delete finalElement.keys;
@@ -732,13 +798,14 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       // Skip already produced foreign keys
       if (!elem['@odata.foreignKey4']) {
         const continuePath = getContinuePath([ 'elements', elemName ]);
-        fks = fks.concat(createForeignKeys(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
+        fks = fks.concat(createForeignKeys(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, extensionPath.concat(elemName), lvl + 1));
       }
     });
   }
   // we have reached a leaf element, create a foreign key
   else if (finalElement.type == null || isBuiltinType(finalElement.type)) {
     const newFk = Object.create(null);
+    setProp(newFk, '$extensionPath', extensionPath);
     for (const prop of [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type' ]) {
       // copy props from original element to preserve derived types!
       if (element[prop] !== undefined)
@@ -794,6 +861,7 @@ module.exports = {
   flattenAllStructStepsInRefs,
   flattenElements,
   removeLeadingSelf,
+  linkForeignKeyAnnotationExtensionsToAssociation,
   handleManagedAssociationsAndCreateForeignKeys,
   getBranches,
 };

package/lib/transform/forOdata.js

@@ -152,6 +152,8 @@ function transform4odataWithCsn(inputModel, options) {
     { skipArtifact: isExternalServiceMember }
   );
 
+  flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
+
   // All type refs must be resolved, including external APIs.
   // OData has no 'type of' so 'real' imported OData APIs marked @cds.external are safe.
   // If in the future 'other' APIs that might support type refs are imported, these refs must be
@@ -169,6 +171,7 @@ function transform4odataWithCsn(inputModel, options) {
     expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
+
     flattening.flattenAllStructStepsInRefs(csn, options, resolved, '_', { skipArtifact: isExternalServiceMember });
     // No type references exist anymore
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
@@ -389,7 +392,7 @@ function transform4odataWithCsn(inputModel, options) {
 
     // Only on element level
     if(node.kind == null) {
-      if (node['@mandatory']&& node['@Common.FieldControl'] === undefined) {
+      if (node['@mandatory'] && !Object.entries(node).some(([k,v]) => k === '@Common.FieldControl' || k.startsWith('@Common.FieldControl.') && v != null)) {
         setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
       }
       if (node['@assert.range'] != null &&