@sap/cds-compiler 4.0.2 → 4.2.2

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 } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 
@@ -18,34 +19,28 @@ 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
         if (!options.toOdata)
-          parent.columns = replaceStar(root, columns, parent.excluding);
+          parent.columns = replaceStar(root, columns, parent.excluding, parent.from.join !== undefined);
         parent.columns = expand(parent.columns, path.concat('columns'), true);
       }
     },
@@ -74,7 +69,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 +97,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 +139,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 +239,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'))
@@ -274,15 +269,8 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         return { columns, toMany: [] };
 
       for (const col of columns) {
-        if (col.expand) {
-          // TODO: Can col.ref be empty without an as? Assumption is it cannot - if it has, it's an error, we throw, compiler checks.
-          const { expanded, toManys } = expandInline(root, col, col.ref || [], [ dbName(col) ]);
-
-          allToMany.push(...toManys);
-          newThing.push(...expanded);
-        }
-        else if (col.inline) {
-          const { expanded, toManys } = expandInline(root, col, col.ref || [], []);
+        if (col.expand || col.inline) {
+          const { expanded, toManys } = expandInline(root, col, col.ref || [], col.expand ? [ dbName(col) ] : []);
 
           allToMany.push(...toManys);
           newThing.push(...expanded);
@@ -304,7 +292,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;
     }
 
@@ -335,18 +323,21 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           });
           toManys.push({ art: current, ref: currentRef, as: currentAlias.join(pathDelimiter) });
         }
-        else if (current.expand) {
-          current.expand = replaceStar(nextBase(current, base), current.expand, current.excluding);
-          for (let i = current.expand.length - 1; i >= 0; i--) {
-            const sub = current.expand[i];
-            stack.push([ nextBase(current, base), sub, sub.ref ? currentRef.concat(sub.ref) : currentRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
-          }
-        }
-        else if (current.inline) {
-          current.inline = replaceStar(nextBase(current, base), current.inline, current.excluding);
-          for (let i = current.inline.length - 1; i >= 0; i--) {
-            const sub = current.inline[i];
-            stack.push([ nextBase(current, base), sub, sub.ref ? currentRef.concat(sub.ref) : currentRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
+        else if (current.expand || current.inline) {
+          const withoutStar = replaceStar(nextBase(current, base), current.expand || current.inline, current.excluding);
+          current[current.expand ? 'expand' : 'inline'] = withoutStar;
+          for (let i = withoutStar.length - 1; i >= 0; i--) {
+            const sub = withoutStar[i];
+            let subRef;
+            if (sub.ref) {
+              // Each expand/inline can introduce another layer of $self/$projection.  Since $self is
+              // a path-breakout, we can simply use the ref without outer expand/inline-references.
+              subRef = (sub.$scope === '$self') ? sub.ref : currentRef.concat(sub.ref);
+            }
+            else {
+              subRef = currentRef;
+            }
+            stack.push([ nextBase(current, base), sub, subRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
           }
         }
         else if (current.xpr || current.args) {
@@ -520,7 +511,7 @@ 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.
    * @returns {Array} New array - with all structured things expanded
    */
   function expand( thing, path, withAlias = false ) {
@@ -528,10 +519,9 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
     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))
+        const _art = col._art || csnUtils.inspectRef(path.concat(i)).art;
+        if (_art && csnUtils.isStructured(_art))
           newThing.push(...expandRef(_art, col, withAlias));
-
         else
           newThing.push(col);
       }
@@ -539,6 +529,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);
       }
@@ -548,44 +555,102 @@ 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.
+   * @returns {Array}
+   */
+  function expandRef( art, root, withAlias ) {
+    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);
+      }
+
+      if (typeof root.$env === 'string')
+        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
    *
@@ -608,9 +673,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++) {
@@ -642,7 +708,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

@@ -5,9 +5,9 @@ const {
   isBuiltinType, cloneCsnNonDict,
   copyAnnotations, implicitAs, isDeepEqual,
 } = require('../../model/csnUtils');
-const transformUtils = require('../transformUtilsNew');
+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');
 
@@ -79,24 +79,23 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
   const ignoreOdataKinds = { aspect: 1, event: 1, type: 1 };
   const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
   applyTransformations(csn, {
-    cast: (parent, prop, cast, path) => {
-      // Resolve cast already - we otherwise lose .localized
-      if (cast.type && !isBuiltinType(cast.type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(cast.type, path) && !isODataItems(cast.type)))
-        toFinalBaseType(parent.cast, resolved, true);
-    },
-    // @ts-ignore
-    type: (parent, prop, type, path) => {
-      if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
+    type: (node, prop, type, path, parent, parentProp) => {
+      if (options.toOdata && node.kind && node.kind in ignoreOdataKinds)
         return;
+      if (parentProp === 'cast') {
+        const e = csnUtils.getFinalTypeInfo(type, t => resolved.get(t)?.art || csnUtils.artifactRef(t));
+        if (!e || e.items || e.elements)
+          return;
+      }
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
-        toFinalBaseType(parent, resolved, true);
+        toFinalBaseType(node, resolved, true);
 
-        if (parent.items) // items could have unresolved types
-          toFinalBaseType(parent.items, resolved, true);
+        if (node.items) // items could have unresolved types
+          toFinalBaseType(node.items, resolved, true);
 
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
-        let nextElements = parent.elements || parent.items?.elements;
+        let nextElements = node.elements || node.items?.elements;
         if (nextElements) {
           const stack = [ nextElements ];
           while (stack.length > 0) {
@@ -111,9 +110,9 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
           }
         }
 
-        const directLocalized = parent.localized || false;
+        const directLocalized = node.localized || false;
         if (!directLocalized && !options.toOdata)
-          removeLocalized(parent);
+          removeLocalized(node);
       }
     },
   }, [ (definitions, artifactName, artifact) => {
@@ -209,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
@@ -220,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;
         }
       };
@@ -284,8 +288,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
     forEach(dict, (elementName, element) => {
       if (element.elements) {
         // Ignore the structured element, replace it by its flattened form
-        // TODO: use $ignore - _ is for links
-        element._ignore = true;
+        element.$ignore = true;
 
         const branches = getBranches(element, elementName, effectiveType, pathDelimiter);
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
@@ -308,6 +311,8 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
 
 
           if (flatElement.type && isAssocOrComposition(flatElement) && flatElement.on) {
+            // unmanaged relations can't be primary key
+            delete flatElement.key;
             // Make refs resolvable by fixing the first ref step
             for (const onPart of flatElement.on) {
               if (onPart.ref) {
@@ -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
@@ -441,6 +476,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
    * @param {*} path
    */
   function flattenFKs( assoc, assocName, path ) {
+    // TODO Depth first search and not iterate mark and sweep approach
     let finished = false;
     while (!finished) {
       const newKeys = [];
@@ -465,8 +501,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
         const { ref } = assoc.keys[i];
         if (isStructured(art)) {
           done = false;
-          // Mark this element to filter it later - not needed after expansion
-          setProp(assoc.keys[i], '$toDelete', true);
           const flat = flattenStructuredElement(art, ref[ref.length - 1], [], pathToKey);
           Object.keys(flat).forEach((flatElemName) => {
             const key = assoc.keys[i];
@@ -502,12 +536,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
         }
         else if (art.target) {
           done = false;
-          // Mark this element to filter it later - not needed after expansion
-          setProp(assoc.keys[i], '$toDelete', true);
           // Directly work on csn.definitions - this way the changes take effect in csnRefs/inspectRef immediately
           // Add the newly generated foreign keys to the end - they will be picked up later on
           // Recursive solutions run into call stack issues
-          art.keys.forEach(key => collector.push(cloneAndExtendRef(key, assoc.keys[i], ref)));
+          art.keys?.forEach(key => collector.push(cloneAndExtendRef(key, assoc.keys[i], ref)));
         }
         else if (assoc.keys[i].ref && !assoc.keys[i].as) {
           setProp(assoc.keys[i], inferredAlias, true);
@@ -523,7 +555,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
       }
       return done;
     }
-    assoc.keys = assoc.keys.filter(o => !o.$toDelete);
 
     /**
      * Clone base and extend the .ref and .as of the clone with the .ref and .as of ref.
@@ -534,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"
@@ -550,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) {
@@ -612,6 +645,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
           return acc;
         }, Object.create(null));
 
+        // set default for single foreign key from association (if available)
+        if (element.default?.val !== undefined && fks.length === 1)
+          fks[0][1].default = element.default;
+
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
           if (occ > 1)
@@ -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,
 };