@sap/cds-compiler 5.7.2 → 5.8.0

package/lib/transform/forRelationalDB.js

@@ -3,7 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const { forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
-        isAspect, walkCsnPath, isPersistedOnDatabase
+        walkCsnPath, isPersistedOnDatabase
       } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const transformUtils = require('./transformUtils');
@@ -34,7 +34,7 @@ const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
 const { featureFlags } = require('./featureFlags');
 const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
-const { processSqlServices } = require('./db/processSqlServices');
+const { processSqlServices, createServiceDummy  } = require('./db/processSqlServices');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -157,7 +157,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   timetrace.start('Validate');
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   validate.forRelationalDB(csn, {
-    ...messageFunctions, csnUtils, ...csnUtils, csn, options, isAspect
+    ...messageFunctions, csnUtils, ...csnUtils, csn, options,
   });
   timetrace.stop('Validate');
 
@@ -354,12 +354,18 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // some errors can't be handled in the subsequent processing steps for e.g. HDBCDS
   messageFunctions.throwWithError();
 
+  // TODO: Might have to do this earlier if we want special rendering for projections?
+  const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && (csn.meta?.[featureFlags]?.$sqlService || csn.meta?.[featureFlags]?.$dummyService) ? processSqlServices(csn, options): () => {}
+
   // 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);
-  forEachDefinition(csn, transformViews);
-
+  forEachDefinition(csn, [(artifact, artifactName) => {
+    findAndMarkSqlServiceArtifacts(artifact, artifactName);
+    if(artifact.$dummyService)
+      createServiceDummy(artifact, artifactName, csn, messageFunctions);
+  },  transformViews]);
 
   if(!doA2J) {
     forEachDefinition(csn, [
@@ -381,9 +387,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     ]);
   }
 
-  // TODO: Might have to do this earlier if we want special rendering for projections?
-  const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && csn.meta?.[featureFlags]?.$sqlService ? processSqlServices(csn): () => {}
-
   // TODO: Could we maybe merge this with the final applyTransformations?
   applyTransformations(csn, {
     type: (parent, prop, type, path) => {
@@ -409,8 +412,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // 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);
-
-    findAndMarkSqlServiceArtifacts(artifact, artifactName);
   }], { allowArtifact: artifact => artifact.kind === 'entity'});
 
   throwWithAnyError();
@@ -636,9 +637,14 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   function handleAssocToJoins() {
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
-    forEachDefinition(csn,
-      art => art.technicalConfig && setProp(art, 'technicalConfig',
-      art.technicalConfig));
+    forEachDefinition(csn, (art) => {
+      if (art.technicalConfig)
+        setProp(art, 'technicalConfig', art.technicalConfig);
+      if (art.kind === 'type' && art.projection) {
+        // Missing 'elements' already reported by csnRefs.
+        delete art.projection;
+      }
+    });
 
     const newCsn = translateAssocsToJoinsCSN(csn, options);
 
@@ -712,9 +718,15 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   // If 'elem' has a default that is an enum constant, replace that by its value. Complain
   // if not found or not an enum type,
+  // usually done by the Core Compiler, but backend might be called directly
   function replaceEnumSymbolsByValues(elem, path) {
     // (190 a) Replace enum symbols by their value (if found)
-    if (elem.default && elem.default['#']) {
+    if (!elem.default?.['#'])
+      return;
+    if (elem.default.val !== undefined) {
+      delete elem.default['#'];
+    }
+    else {
       let Enum = elem.enum;
       if (!Enum && !isBuiltinType(elem.type)) {
         const typeDef = csnUtils.getCsnDef(elem.type);
@@ -755,10 +767,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   /**
    * Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.
 
-   * @param {*} node 
-   * @param {*} nodeName 
-   * @param {*} model 
-   * @param {*} path 
+   * @param {*} node
+   * @param {*} nodeName
+   * @param {*} model
+   * @param {*} path
    */
   function checkTypeParameters(node, artifact, path) {
     if (node.type && !node.virtual) {

package/lib/transform/odata/adaptAnnotationRefs.js

@@ -8,21 +8,31 @@ const { transformAnnotationExpression, implicitAs, } = require('../../model/csnU
  * key declared in the scope, we replace it with referencing the foreign key itself. If a reference is a $self reference,
  * we do nothing and if a ref points to a structure/managed association, an error is thrown
  *
- * @param {Array[]} generatedForeignKeys 
+ * @param {Array[object]||Array[]} generatedForeignKeys 
  * @param {object} csnUtils 
  * @param {object} messageFunctions 
- * @param {CSN.Path} elementPath 
  */
 function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, elementPath) {
-  const reportedErrorsForAnnoPath = {};
-  generatedForeignKeys.forEach((gfk, index) => {
-    Object.entries(gfk[1]).forEach(([key, value]) => {
-      if (key[0] !== '@') return;
-
-      transformAnnotationExpression(gfk[1], key, {
-        ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
-          if (ref[0] !== '$self') {
-            const { art } = csnUtils.inspectRef(elementPath ? path : getOriginatingKeyPath(gfk, path)); // OData uses getOriginatingKeyPath - as it relies on $path
+  if(Array.isArray(generatedForeignKeys && generatedForeignKeys[0])) {
+    // ensure we are always called with an array of objects. TODO: Cleanup fk creation in for.effective to create array of objects
+    adaptAnnotationsRefs(remapToArrayOfObjects(generatedForeignKeys), csnUtils, { error }, elementPath); 
+  } else {
+    const reportedErrorsForAnnoPath = {};
+    generatedForeignKeys.forEach((gfk, index) => {
+      Object.entries(gfk.foreignKey).forEach(([key, value]) => {
+        if (key[0] !== '@') return;
+  
+        transformAnnotationExpression(gfk.foreignKey, key, {
+          ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
+            // if the reference is a $self reference, we do nothing,
+            // as this is the way to tell that we do not reference the foreign key
+            if (ref[0] === '$self') return;
+            // if annotation was not propagated from the keys array during foreign keys creation,
+            // means that it is not a candidate for foreign key substitution
+            if (gfk.keyAnnotations !== null && !gfk.keyAnnotations.includes(key)) return;
+  
+            const art = gfk.originalKey._art || 
+            csnUtils.inspectRef(elementPath ? path : getOriginatingKeyPath(gfk, path)).art; // OData uses getOriginatingKeyPath - as it relies on $path
             if (csnUtils.isManagedAssociation(art)) {
               if (!reportedErrorsForAnnoPath[path]) {
                 error('odata-anno-xpr-ref', path, { elemref: { ref }, anno: key, '#': 'fk_substitution' });
@@ -31,15 +41,15 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
             } else {
               const gfkForRef = findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref);
               if (gfkForRef.length === 1) {
-                ref[0] = gfkForRef[0][0];
-
+                ref[0] = gfkForRef[0].prefix;
+  
                 if (ctx?.annoExpr?.['=']) {
                   ctx.annoExpr['='] = true;
                 }
               } else {
                 // check if the annotation reference points to a structure that has been expanded,
                 // if so -> report an error
-                const foundInOriginalRef = findOriginalRef(generatedForeignKeys.filter(gfk => gfk[2].$originalKeyRef), ref);
+                const foundInOriginalRef = findOriginalRef(generatedForeignKeys.filter(gfk => gfk.originalKey.$originalKeyRef), ref);
                 // references to expanded structures in flat mode will be found in the $originalKeyRef
                 // and in structured mode more than one match will be found in the generated foreign keys
                 if ((foundInOriginalRef.length || gfkForRef.length > 1) && !reportedErrorsForAnnoPath[path]) {
@@ -49,15 +59,15 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
               }
             }
           }
-        }
-      }, elementPath ? elementPath.concat(['keys', index]) : value?.$path?.slice(0, value.$path.length - 1)); // OData uses $path
+        }, elementPath ? elementPath.concat(['keys', index]) : value?.$path?.slice(0, value.$path.length - 1)); // OData uses $path
+      });
     });
-  });
+  }
 
   // During tuple expansion, the key ref object looses the $path, therefore
   // it needs to be extracted from the anno path
   function getOriginatingKeyPath(gfk, path) {
-    return gfk[2].$path || path.slice(0, path.findIndex(ps => ps[0] === '@'));
+    return gfk.originalKey.$path || path.slice(0, path.findIndex(ps => ps[0] === '@'));
   }
 
   // Loops through the generated foreign keys for this entity
@@ -65,15 +75,21 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
   // key ref. In case there are more than one foreign keys found,
   // that means the key ref points to a structured element/managed assoc
   function findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref) {
-    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk[2].as || implicitAs(gfk[2].ref))));
+    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk.originalKey.as || implicitAs(gfk.originalKey.ref))));
   }
 
   // Tuple expansion is performed before the generation of the foreign keys and the original(unexpanded) key ref
   // is stored in the property $originalKeyRef. Here we try to evaluate whether the reference in the annotation
   // points to a structure that has been expanded.
   function findOriginalRef(generatedForeignKeys, ref) {
-    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk[2].$originalKeyRef.as || implicitAs(gfk[2].$originalKeyRef.ref))));
+    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk.originalKey.$originalKeyRef.as || implicitAs(gfk.originalKey.$originalKeyRef.ref))));
   }
 }
 
-module.exports = adaptAnnotationsRefs;
+function remapToArrayOfObjects(generatedForeignKeys) {
+  return generatedForeignKeys.map(([ prefix, foreignKey, originalKey ]) => {
+    return { prefix, foreignKey, originalKey, keyAnnotations: null };
+  });
+}
+
+module.exports = { adaptAnnotationsRefs };

package/lib/transform/odata/createForeignKeys.js

@@ -2,9 +2,9 @@
 
 const { isBuiltinType } = require('../../base/builtins');
 const { setProp } = require('../../base/model');
-const { applyTransformations, implicitAs, findAnnotationExpression, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
+const { applyTransformations, implicitAs, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
-const adaptAnnotationsRefs = require('./adaptAnnotationRefs');
+const { adaptAnnotationsRefs } = require('./adaptAnnotationRefs');
 
 function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iterateOptions = {}) {
 
@@ -28,20 +28,20 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
         orderedElements.push([ elementName, element ]);
         if (!csnUtils.isManagedAssociation(element)) return;
         const elementPath = path.concat(prop, elementName);
-        const generatedForeignKeys = createForeignKeysForElement(csnUtils, elementPath, element, elementName, csn, options, '_');
+        const generatedForeignKeys = createForeignKeysForElement(elementPath, element, elementName, csn, options, '_');
 
         // Second, finalize the generated FK elements
         const refCount = generatedForeignKeys.reduce((acc, fk) => {
           // count duplicates
-          if (acc[fk[0]])
-            acc[fk[0]]++;
+          if (acc[fk.prefix])
+            acc[fk.prefix]++;
           else
-            acc[fk[0]] = 1;
+            acc[fk.prefix] = 1;
 
           // check for name clash with existing elements
-          if (parent[prop][fk[0]] && isDeepEqual(element, parent[prop][fk[0]], true)) {
+          if (parent[prop][fk.prefix] && isDeepEqual(element, parent[prop][fk.prefix], true)) {
             // error location is the colliding element
-            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
+            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk.prefix, art: elementName });
           }
           // attach a proper $path
           setProp(element, '$path', elementPath);
@@ -50,7 +50,7 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
 
         // set default for single foreign key from association (if available)
         if (element.default?.val !== undefined && generatedForeignKeys.length === 1)
-        generatedForeignKeys[0][1].default = element.default;
+        generatedForeignKeys[0].foreignKey.default = element.default;
 
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
@@ -63,8 +63,8 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
         }
 
         adaptAnnotationsRefs(generatedForeignKeys, csnUtils, messageFunctions);
-        setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => gfk[0]));
-        orderedElements.push(...generatedForeignKeys);
+        setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => gfk.prefix));
+        orderedElements.push(...generatedForeignKeys.map(gfk => [ gfk.prefix, gfk.foreignKey ]));
       
     });
 
@@ -74,123 +74,127 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
     }, Object.create(null));
   }
 
-function createForeignKeysForElement(csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalkey = {} ) {
-  const special$self = !csn?.definitions?.$self && '$self';
-  const isInspectRefResult = !Array.isArray(path);
+  function createForeignKeysForElement(path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalKey = {} ) {
+    const special$self = !csn?.definitions?.$self && '$self';
+    const isInspectRefResult = !Array.isArray(path);
 
-  let fks = [];
-  if (!element)
-    return fks;
+    let fks = [];
+    if (!element)
+      return fks;
 
-  let finalElement = element;
-  let finalTypeName;
+    let finalElement = element;
+    let finalTypeName;
 
-  // resolve derived type
-  if (element.type && !isBuiltinType(element.type) && element.type !== special$self) {
-    const tmpElt = csnUtils.effectiveType(element);
-    // effective type resolves to structs and enums only but not scalars
-    if (Object.keys(tmpElt).length) {
-      finalElement = tmpElt;
-      finalTypeName = finalElement.$path[1];
-    }
-    else {
-      // unwind a derived type chain to a scalar type
-      while (finalElement?.type && !isBuiltinType(finalElement?.type)) {
-        finalTypeName = finalElement.type;
-        finalElement = csn.definitions[finalElement.type];
+    // resolve derived type
+    if (element.type && !isBuiltinType(element.type) && element.type !== special$self) {
+      const tmpElt = csnUtils.effectiveType(element);
+      // effective type resolves to structs and enums only but not scalars
+      if (Object.keys(tmpElt).length) {
+        finalElement = tmpElt;
+        finalTypeName = finalElement.$path[1];
+      }
+      else {
+        // unwind a derived type chain to a scalar type
+        while (finalElement?.type && !isBuiltinType(finalElement?.type)) {
+          finalTypeName = finalElement.type;
+          finalElement = csn.definitions[finalElement.type];
+        }
       }
     }
-  }
 
-  if (!finalElement)
-    return [];
-
-  // main if for this function
-  // the element is a managed association
-  if (csnUtils.isManagedAssociation(finalElement)) {
-    finalElement.keys.forEach((key, keyIndex) => {
-      const continuePath = getContinuePath([ 'keys', keyIndex ]);
-      const alias = key.as || implicitAs(key.ref);
-      const result = csnUtils.inspectRef(continuePath);
-      let gfks = createForeignKeysForElement(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1,
-        lvl === 0 ? { ref: key.ref, as: key.as, $path: key.$path, $originalKeyRef: key.$originalKeyRef } : originalkey);
+    if (!finalElement)
+      return [];
+
+    // main if for this function
+    // the element is a managed association
+    if (csnUtils.isManagedAssociation(finalElement)) {
+      finalElement.keys.forEach((key, keyIndex) => {
+        const continuePath = getContinuePath([ 'keys', keyIndex ]);
+        const alias = key.as || implicitAs(key.ref);
+        const result = csnUtils.inspectRef(continuePath);
+        let gfks = createForeignKeysForElement(result, result.art, alias, csn, options, pathDelimiter, lvl + 1,
+          lvl === 0 ? key : originalKey);
+        if (lvl === 0) {
+          gfks.forEach(gfk => gfk.keyAnnotations.push( ...copyAnnotations(key, gfk.foreignKey)));
+          Object.keys(key).forEach( prop => {
+            // once applied -> remove the annotations from the keys array, to keep the OData CSN size as small as possible
+            if (prop[0] === '@')
+              delete key[prop]
+          });
+        }
+        fks = fks.concat(gfks);
+      });
+    }
+    // the element is a structure
+    else if (finalElement.elements) {
+      Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
+        // Skip already produced foreign keys
+        if (!elem['@odata.foreignKey4']) {
+          const continuePath = getContinuePath([ 'elements', elemName ]);
+          fks = fks.concat(createForeignKeysForElement(continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1, originalKey));
+        }
+      });
+    }
+    // we have reached a leaf element, create a foreign key
+    else if ((finalElement.type == null || isBuiltinType(finalElement.type)) && !finalElement.on) {
+      const newFk = Object.create(null);
+      [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
+        // copy props from original element to preserve derived types!
+        if (element[prop] !== undefined)
+          newFk[prop] = element[prop];
+      });
+      return [ { prefix, foreignKey: newFk, originalKey, keyAnnotations: [] } ];
+    }
+
+    fks.forEach((fk) => {
+      // prepend current prefix
+      fk.prefix = `${prefix}${pathDelimiter}${fk.prefix}`;
+      // if this is the entry association, decorate the final foreign keys with the association props/annos
       if (lvl === 0) {
-        gfks.forEach(gfk => copyAnnotations(key, gfk[1]));
-        // once applied -> remove the annotations from the keys array, to keep the OData CSN size as small as possible
-        Object.keys(key).forEach( prop => {
-          if (prop[0] === '@') delete key[prop]
-        });
-      }
-      fks = fks.concat(gfks);
-    });
-  }
-  // the element is a structure
-  else if (finalElement.elements) {
-    Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
-      // Skip already produced foreign keys
-      if (!elem['@odata.foreignKey4']) {
-        const continuePath = getContinuePath([ 'elements', elemName ]);
-        fks = fks.concat(createForeignKeysForElement(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1, originalkey));
+        fk.foreignKey['@odata.foreignKey4'] = prefix;
+
+        const fkPath = path.slice(0, path.length - 1);
+        fkPath.push(fk.prefix);
+        setProp(fk.foreignKey, '$path', fkPath);
+
+        const allowedOverwriteAnnotationNames = ['@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`)];
+        const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !allowedOverwriteAnnotationNames.includes(pn));
+        copyAnnotations(element, fk.foreignKey, false, {}, validAnnoNames);
+        const overwriteAnnoNames = Object.keys(element).filter(pn => allowedOverwriteAnnotationNames.includes(pn));
+        copyAnnotations(element, fk.foreignKey, true, {}, overwriteAnnoNames);
+
+        // propagate not null to final foreign key
+        for (const prop of [ 'notNull', 'key' ]) {
+          if (element[prop] !== undefined)
+            fk.foreignKey[prop] = element[prop];
+        }
+        if (element.$location)
+          setProp(fk.foreignKey, '$location', element.$location);
       }
     });
-  }
-  // we have reached a leaf element, create a foreign key
-  else if ((finalElement.type == null || isBuiltinType(finalElement.type)) && !finalElement.on) {
-    const newFk = Object.create(null);
-    [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
-      // copy props from original element to preserve derived types!
-      if (element[prop] !== undefined)
-        newFk[prop] = element[prop];
-    });
-    return [ [ prefix, newFk, originalkey ] ];
-  }
+    return fks;
 
-  fks.forEach((fk) => {
-    // prepend current prefix
-    fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;
-    // if this is the entry association, decorate the final foreign keys with the association props/annos
-    if (lvl === 0) {
-      if (options.transformation !== 'effective')
-        fk[1]['@odata.foreignKey4'] = prefix;
-
-      const allowedOverwriteAnnotationNames = ['@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`)];
-      const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !allowedOverwriteAnnotationNames.includes(pn) && !findAnnotationExpression(element, pn));
-      copyAnnotations(element, fk[1], false, {}, validAnnoNames);
-      const overwriteAnnoNames = Object.keys(element).filter(pn => allowedOverwriteAnnotationNames.includes(pn) && !findAnnotationExpression(element, pn));
-      copyAnnotations(element, fk[1], true, {}, overwriteAnnoNames);
-
-      // propagate not null to final foreign key
-      for (const prop of [ 'notNull', 'key' ]) {
-        if (element[prop] !== undefined)
-          fk[1][prop] = element[prop];
-      }
-      if (element.$location)
-        setProp(fk[1], '$location', element.$location);
+    /**
+     * Get the path to continue resolving references
+     *
+     * If we are currently inside of a type, we need to start our path fresh from that given type.
+     * Otherwise, we would try to resolve .elements on a thing that does not exist.
+     *
+     * We also respect if we have a previous inspectRef result as our base.
+     *
+     * @param {Array} additions
+     * @returns {CSN.Path}
+     */
+    function getContinuePath( additions ) {
+      if (csn.definitions[finalElement.type])
+        return [ 'definitions', finalElement.type, ...additions ];
+      else if (finalTypeName)
+        return [ 'definitions', finalTypeName, ...additions ];
+      else if (isInspectRefResult)
+        return [ path, ...additions ];
+      return [ ...path, ...additions ];
     }
-  });
-  return fks;
-
-  /**
-   * Get the path to continue resolving references
-   *
-   * If we are currently inside of a type, we need to start our path fresh from that given type.
-   * Otherwise, we would try to resolve .elements on a thing that does not exist.
-   *
-   * We also respect if we have a previous inspectRef result as our base.
-   *
-   * @param {Array} additions
-   * @returns {CSN.Path}
-   */
-  function getContinuePath( additions ) {
-    if (csn.definitions[finalElement.type])
-      return [ 'definitions', finalElement.type, ...additions ];
-    else if (finalTypeName)
-      return [ 'definitions', finalTypeName, ...additions ];
-    else if (isInspectRefResult)
-      return [ path, ...additions ];
-    return [ ...path, ...additions ];
   }
 }
-}
 
 module.exports = createForeignKeyElements;

package/lib/transform/odata/flattening.js

@@ -14,7 +14,7 @@ const { forEach } = require('../../utils/objectUtils');
 const { assignAnnotation } = require('../../edm/edmUtils');
 
 function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options) {
-  const allMgdAssocDefs = []; 
+  const allMgdAssocDefs = [];
   forEachDefinition(csn, (def, defName) => {
     if (def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
       ['elements', 'params'].forEach(dictName => {
@@ -345,7 +345,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
           // try to find rightmost 'items', terminate if association comes first.
           let i = links.length-1;
           const getProp = (propName) => links[i].art?.[propName];
-  
+
           let hasItems = false;
           for(; i >= 0 && !getProp('target') && !hasItems; i--) {
             const art = links[i].art;
@@ -361,7 +361,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
                   name: refCheck.eltLocationStr,
                   '#': 'flatten_builtin'
                 });
-            }  
+            }
           }
         }
       }
@@ -467,7 +467,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
         let comeFromSameDef = flatElt.$defPath.slice(0, flatElt.$defPath.length - 1).join('.') === se[1].$defPath.slice(0, se[1].$defPath.length - 1).join('.');
         return (comeFromSameDef && (se[1]['@odata.foreignKey4'] && se[1]['@odata.foreignKey4'] === structuredAssocName) && se[0].startsWith(flatEltName))
       });
-    
+
     generatedForeignKeysForAssoc.forEach(gfk => gfk[1]['@odata.foreignKey4'] = flatEltName);
     // reassign the generated foreign keys for current assoc in order to assign
     // correct values for $generatedFieldName later on during flattenManagedAssocsAsKeys();
@@ -565,7 +565,7 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
       if (insideKeys(path))
         setProp(parent, '_art', art);
       const lastRef = ref[ref.length - 1];
-      const fn = (suspend = false, suspendPos = 0, 
+      const fn = (suspend = false, suspendPos = 0,
                     refFilter = (_parent) => true) => {
         if (refFilter(parent)) {
           const scopedPath = [ ...parent.$path ];
@@ -573,9 +573,11 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
           //       full path into target, uncomment this line and
           //       comment/remove setProp in expansion.js
           // setProp(parent, '$structRef', parent.ref);
+          const flattenParameters = true; // structured parameters are flattened
           const [ newRef, refChanged ] = flattenStructStepsInRef(ref,
               scopedPath, links, scope, resolvedLinkTypes,
-              suspend, suspendPos, parent.$bparam);
+              suspend, suspendPos, parent.$bparam,
+              flattenParameters);
           parent.ref = newRef;
           resolved.set(parent, { links, art, scope });
           // Explicitly set implicit alias for things that are now flattened - but only in columns
@@ -628,7 +630,7 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
             annoExpr['='] = true;
         });
       }
-      else 
+      else
         adaptRefs.push(fn);
     },
   }
@@ -679,7 +681,7 @@ function replaceManagedAssocsAsKeys(allFlatManagedAssocDefinitions, csnUtils) {
       return done;
     }
   });
-  
+
   function cloneAndExtendRef(keyAssocKey, key) {
     let newKey = { ref:  [`${key.ref.join('_')}_${keyAssocKey.as || keyAssocKey.ref.join('_')}`] };
     setProp(newKey, '_art', keyAssocKey._art);