@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/transform/forOdataNew.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { isDeprecatedEnabled } = require('../base/model');
+const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtilsNew');
 const { getUtils,
         cloneCsn,
@@ -22,8 +22,9 @@ const { flattenCSN } = require('./odata/structureFlattener');
 const generateForeignKeys = require('./odata/generateForeignKeyElements');
 const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssociations');
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { attachPath } = require('./odata/attachPath');
+const enrichUniversalCsn = require('./universalCsnEnricher');
 
 const { addLocalizationViews } = require('./localized');
 
@@ -89,7 +90,7 @@ function transform4odataWithCsn(inputModel, options) {
     addElement, createAction, assignAction,
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
-    recurseElements, setAnnotation, renameAnnotation,
+    recurseElements, setAnnotation, resetAnnotation, renameAnnotation,
     expandStructsInExpression
   } = transformers;
 
@@ -119,6 +120,9 @@ function transform4odataWithCsn(inputModel, options) {
   // @ts-ignore
   const isExternalServiceMember = (_art, name) => externalServices.includes(getServiceName(name));
 
+  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
+    enrichUniversalCsn(csn, options);
+
   const keepLocalizedViews = isDeprecatedEnabled(options, 'createLocalizedViews');
 
   function acceptLocalizedView(_name, parent) {
@@ -187,7 +191,11 @@ function transform4odataWithCsn(inputModel, options) {
   generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
 
   // Apply default type facets as set by options
-  // Flatten on-conditions in unmanaged associations
+  // Flatten on-conditions in unmanaged associations 
+  /* FIXME (HJB): Is this comment still correct? processOnCond only strips $self
+                  We should not remove $self prefixes in structured OData to not
+                  interfer with path resolution 
+  */
   // This must be done before all the draft logic as all
   // composition targets are annotated with @odata.draft.enabled in this step
   forEachDefinition(csn, [ setDefaultTypeFacets, processOnCond ], { skipArtifact: isExternalServiceMember });
@@ -326,7 +334,7 @@ function transform4odataWithCsn(inputModel, options) {
         renameAnnotation(node, name, '@UI.Importance');
         let annotation = node['@UI.Importance'];
         if (annotation !== null)
-          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' }
+          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' };
       }
 
       // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
@@ -457,11 +465,11 @@ function transform4odataWithCsn(inputModel, options) {
     }
     // Generate the annotations describing the draft actions (only draft roots can be activated/edited)
     if (artifact == rootArtifact) {
-      artifact['@Common.DraftRoot.ActivationAction'] = 'draftActivate';
-      artifact['@Common.DraftRoot.EditAction'] = 'draftEdit';
-      artifact['@Common.DraftRoot.PreparationAction'] = 'draftPrepare';
+      resetAnnotation(artifact, '@Common.DraftRoot.ActivationAction', 'draftActivate', info, ['definitions', draftAdminDataProjectionName]);
+      resetAnnotation(artifact, '@Common.DraftRoot.EditAction', 'draftEdit', info, ['definitions', draftAdminDataProjectionName]);
+      resetAnnotation(artifact, '@Common.DraftRoot.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
     } else {
-      artifact['@Common.DraftNode.PreparationAction'] = 'draftPrepare';
+      resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
     }
 
     artifact.elements && Object.values(artifact.elements).forEach( elem => {
@@ -529,7 +537,7 @@ function transform4odataWithCsn(inputModel, options) {
 
         // Ignore if that is our own draft root
         if (draftNode != rootArtifact) {
-          // Barf if the draft node has @odata.draft.enabled itself
+          // Report error when the draft node has @odata.draft.enabled itself
           if (hasAnnotationValue(draftNode, '@odata.draft.enabled', true)) {
             error(null, ['definitions', artifactName, 'elements', elemName], 'Composition in draft-enabled entity can\'t lead to another entity with “@odata.draft.enabled”');
           }
@@ -565,6 +573,9 @@ function transform4odataWithCsn(inputModel, options) {
   // CDXCORE-481
   // (4.5) If the member is an association whose target has @cds.odata.valuelist annotate it
   // with @Common.ValueList.viaAssociation.
+  /*
+    FIXME (HJB): Comment outdated: Anno propagation to FKs is done in EdmPreprocessor
+  */
   // This must be done before foreign keys are calculated and the annotations are propagated
   // to them. This will make sure that association and all its foreign keys are annotated with
   // Common.ValueList in the final EDM.

package/lib/transform/localized.js

@@ -698,6 +698,8 @@ function copyPersistenceAnnotations(target, source) {
  * @param {CSN.Options} options
  */
 function hasExistingLocalizationViews(csn, options) {
+  if (!csn || !csn.definitions)
+    return false;
   const firstLocalizedView = Object.keys(csn.definitions).find(isInLocalizedNamespace);
   if (firstLocalizedView) {
     const { info } = makeMessageFunction(csn, options);

package/lib/transform/odata/attachPath.js

@@ -24,6 +24,8 @@ const structuralNodeHandlers = {
   groupBy: traverseArray,
   having: traverseArray,
   xpr: traverseArray,
+  expand: traverseArray,
+  inline: traverseArray,
 }
 
 function attachPath(csn) {
@@ -38,6 +40,7 @@ function attachPathOnPartialCSN(csnPart, pathPrefix) {
 }
 
 function traverseRef(obj, path) {
+  if(!obj) return;
   setPath(obj, path);
   traverseArray(obj, path);
 }
@@ -48,7 +51,7 @@ function traverseArray(obj, path) {
 }
 
 function traverseDict(obj, path) {
-  if(typeof obj !== 'object') return;
+  if(!obj || typeof obj !== 'object') return;
   forAllEnumerableProperties(obj, name => {
     const ipath = path.concat(name);
     setPath(obj[name], ipath);
@@ -56,17 +59,29 @@ function traverseDict(obj, path) {
   })
 }
 
+function traverseDictArray(obj, path) {
+  if(!obj || typeof obj !== 'object') return;
+  forAllEnumerableProperties(obj, name => {
+    const ipath = path.concat(name);
+    setPath(obj[name], ipath);
+    traverseArray(obj[name], ipath);
+  })
+}
+
 function traverseTyped(obj, path) {
-  if(!obj) return;
+  if(!obj || typeof obj !== 'object') return;
   forAllEnumerableProperties(obj, name => {
     if(name[0]==='@') return; // skip annotations
     const func = structuralNodeHandlers[name];
-    if(func) func(obj[name], path.concat(name));
+    if(func)
+      func(obj[name], path.concat(name));
+    else if(path[path.length-2] === 'columns')
+      traverseDictArray(obj[name], path.concat(name)); // for columns
   })
 }
 
 function setPath(obj, path) {
-  if(typeof obj !== 'object') return;
+  if(!obj || typeof obj !== 'object') return;
   if(path.length>0)
     Object.defineProperty( obj, '$path', { value: path, configurable: true, writable: true, enumerable: false } );
 }

package/lib/transform/odata/generateForeignKeyElements.js

@@ -35,7 +35,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     let generatedForeignKeyNamesForPath = Object.create(null); // map<path,[key-name]>
 
     sortedAssociations.forEach(item => {
-      const { definitionName, elementName, element, parent, path } = item;
+      const { definitionName, structuralNodeName, elementName, element, parent, path } = item;
 
       if (csnUtils.isManagedAssociationElement(element) && element.keys) {
         if (flatKeys) // tackling the ref value in assoc.keys
@@ -44,7 +44,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
         fixCardinality(element);
       }
 
-      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, elementName, element, parent, path);
+      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, structuralNodeName, elementName, element, parent, path);
       generatedForeignKeyNamesForPath[item.path.join('/')] = arrayOfGeneratedForeignKeyNames;
     })
 
@@ -111,7 +111,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
   /**
    * Generates foreign keys and returns their names as an array
    */
-  function generateForeignKeys(definitionName, assocName, assoc, parent, path) {
+  function generateForeignKeys(definitionName, structuralNodeName, assocName, assoc, parent, path) {
     let foreignKeyElements = Object.create(null);
 
     // First, loop over the keys array of the association and generate the FKs.
@@ -134,13 +134,14 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     if (parent.returns)
       parent = parent.returns.items || parent.returns;
 
-    let currElementsNames = Object.keys(parent.elements);
+    const dictionary = parent[structuralNodeName];
+    let currElementsNames = Object.keys(parent[structuralNodeName]);
     for (const [foreignKeyName, foreignKey] of Object.entries(foreignKeyElements)) {
       copyAnnotations(assoc, foreignKey, true);
       // Insert artificial element into artifact, with all cross-links
-      if (parent.elements[foreignKeyName]) {
-        if (!(parent.elements[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(parent.elements[foreignKeyName], foreignKey))) {
-          const path = parent.elements[foreignKeyName].$path;
+      if (dictionary[foreignKeyName]) {
+        if (!(dictionary[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(dictionary[foreignKeyName], foreignKey))) {
+          const path = dictionary[foreignKeyName].$path;
           error(null, path, { name: foreignKeyName, art: assocName }, 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
         }
       }
@@ -151,8 +152,8 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     // if (flatKeys)
     currElementsNames.splice(assocIndex + 1, 0, ...Object.keys(foreignKeyElements));
 
-    parent.elements = currElementsNames.reduce((previous, name) => {
-      previous[name] = parent.elements[name] || foreignKeyElements[name];
+    parent[structuralNodeName] = currElementsNames.reduce((previous, name) => {
+      previous[name] = dictionary[name] || foreignKeyElements[name];
       return previous;
     }, Object.create(null));
 
@@ -180,7 +181,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
 
     function processStucturedKey(fkArtifact, assocName, foreignKeyRef) {
       const subStruct = fkArtifact.elements ? fkArtifact : csnUtils.getFinalBaseType(fkArtifact.type);
-      const flatElements = flattenStructure(subStruct, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
+      const flatElements = flattenStructure(subStruct.elements, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
       for (const [flatElemName, flatElem] of Object.entries(flatElements)) {
         const foreignKeyElementName =
           `${assocName.replace(/\./g, '_')}_${foreignKeyRef.as ? flatElemName.replace(implicitAs(foreignKeyRef.ref), foreignKeyRef.as) : flatElemName}`;

package/lib/transform/odata/referenceFlattener.js

@@ -1,6 +1,7 @@
 const { forEachRef } = require('../../model/csnUtils');
 const { setProp } = require('../../base/model');
 const { implicitAs } = require('../../model/csnRefs');
+const { structuralPath } = require('./structuralPath');
 
 /** This class is used for generic reference flattening.
  * It provides the following functionality:
@@ -73,8 +74,7 @@ class ReferenceFlattener {
       });
       if (paths)
         setProp(node, '$paths', paths);
-      setProp(node, '$scope', resolved.scope);
-      // cache also if structured or not
+      // cache if structured or not
       let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
       this.structuredReference[path.join('/')] = structured;
     });
@@ -176,10 +176,10 @@ class ReferenceFlattener {
       if (node.$paths) {
         let newRef = []; // flattened reference
         let flattenWithPrevious = false;
-        let anythingFlattened = false; // will be set to true if at least one node is flatted
+        let lastFlattenedID = null; // The variable will be set to the index of the last flattened path
         node.$paths.forEach((path, i) => {
           if (path === undefined || !ref[i]) return;
-          let spath = path.join('/')
+          let spath = path.join('/');
           let movedTo = this.elementTransitions[spath]; // detect element transition
           let flattened = this.flattenedElementPaths[spath];
           if (flattenWithPrevious) {
@@ -190,27 +190,26 @@ class ReferenceFlattener {
               ref[i].id = newRef[newRef.length - 1];
               newRef[newRef.length - 1] = ref[i];
             }
-            anythingFlattened = true;
+            lastFlattenedID = i;
           } else if(movedTo && i===0) { // handle local scope reference which is transitioned - replace first item in reference
             let movedToElementName = movedTo[movedTo.length-1];
             newRef.push(movedToElementName);
-            anythingFlattened=true;
+            lastFlattenedID = i;
           } else {
             newRef.push(ref[i]);
           }
           flattenWithPrevious = flattened;
         });
-        if (newRef !== undefined && anythingFlattened) { // do not replace unchanged references
+        if (newRef !== undefined && lastFlattenedID !== null) { // make sure the reference changed and only then replace it with the new one
           // check if this is a column and add alias if missing
-          if (isColumnInSelect(ref.$path)) {
-            if (!node.as) {
+          let structural = structuralPath(csn, path);
+          if (isColumnInSelectOrProjection(structural)) {
+            if (!node.as && lastFlattenedID === ref.length-1) // attach alias only if there is none and it is the last item in the reference that was flattened
               node.as = node.ref[node.ref.length - 1];
-            }
           }
           setProp(newRef, '$path', path.concat('ref'));
           if (!node.as) {
-            // FIXME: rather use scope from inspectRef to determin if path leads to a key
-            if (ifKeysScope(path))
+            if (isPartOfKeysStructure(structural))
               node.as = implicitAs(node.ref);
             else
               setProp(node, 'as', implicitAs(node.ref))
@@ -223,13 +222,11 @@ class ReferenceFlattener {
 
   applyAliasesInOnCond(csn, inspectRef) {
     forEachRef(csn, (ref, node, path) => {
-      // is there a better way to detect if we are dealing with on-cond?
-      // TODO: please do not use inspectRef() results for "where am I?" info
-      if (!['$self', 'parent'].includes(node.$scope)) return;
-      // the above condition means: only handle references starting with
-      // $self or element references outside queries
-
+      // Process only on-conditions of associations
+      let structural = structuralPath(csn, path);
+      if(!isOnCondition(structural)) return;
       let { links } = inspectRef(path);
+      if(!links) return; // $user not resolvable
       let keysOfPreviousStepWhenManagedAssoc = undefined;
 
       let aliasedRef = [...ref];
@@ -253,32 +250,41 @@ class ReferenceFlattener {
   }
 }
 
-// FIXME: rather use scope from inspectRef to determin if path leads to a key
-function ifKeysScope(path) {
-  if (!path) return false;
-  if (Number.isInteger(path[path.length - 1]) && path[path.length - 2] === 'keys' && path[path.length - 4] === 'elements')
-    return true;
-  return false;
+/**
+ * Checks if the provided path is a column inside a key node
+ * by exploring the possibility of the structural path to  ends with 'elements' and 'keys'.
+ *
+ * @param structural structural path to explore
+ * @returns {boolean} True if the provided path matched the requirements to be part of a key node.
+ */
+function isPartOfKeysStructure(structural) {
+  return structural[structural.length-2] === 'elements'
+      && structural[structural.length-1] === 'keys';
 }
 
 /**
- * Checks if the provided path is a column inside a select node
- * by exploring the possibility of the path to end with ['SELECT','columns','<an integer>', <ref - not checked>].
+ * Checks if the provided path is a column inside a select or a projection node
+ * by exploring the possibility of the structural path to contain 'SELECT' or 'projection'
+ * and ends with 'columns' or 'columns' and 'expand'.
  *
- * @param {CSN.Path} path Path to explore
+ * @param structural structural path to explore
  * @returns {boolean} True if the provided path matched the requirements to be a select node.
  */
-function isColumnInSelect(path) {
-  if (!path)
-    return false;
-  const len = path.length;
-  if (path[len - 4] === 'SELECT' && path[len - 3] === 'columns') {
-    // check if -2 element is an integer / array index
-    const arrayIndex = parseInt(String(path[len - 2]), 10);
-    if (!isNaN(arrayIndex))
-      return true;
-  }
-  return false;
+function isColumnInSelectOrProjection(structural) {
+  return (structural.includes('SELECT') ||  structural.includes('projection'))
+    && (structural[structural.length-1] === 'columns' || (structural[structural.length-2] === 'columns' && structural[structural.length-1] === 'expand'));
+}
+
+/**
+ * Checks if the provided path is a column inside an on-condition of an element
+ * by exploring the possibility of the structural path to  ends with 'elements' and 'on'.
+ *
+ * @param structural structural path to explore
+ * @returns {boolean} True if the provided path matched the requirements to be part of an element's on-condition.
+ */
+function isOnCondition(structural) {
+  return structural[structural.length-2] === 'elements'
+      && structural[structural.length-1] === 'on';
 }
 
 module.exports = ReferenceFlattener;

package/lib/transform/odata/sortByAssociationDependency.js

@@ -24,7 +24,7 @@ function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember)
   forEachDefinition(csn, (def, definitionName) => {
     /** @type {CSN.Path} */
     let root = ['definitions', definitionName];
-    forEachMemberRecursively(def, (element, elementName, _prop, subpath, parent) => {
+    forEachMemberRecursively(def, (element, elementName, structuralNodeName, subpath, parent) => {
       let path = root.concat(subpath);
       // go only through managed associations and compositions
       if (isAssociationOrComposition(element) && element.keys && !element.on) { // check association FKs
@@ -44,7 +44,7 @@ function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember)
             elementDependencies.push(targetElementPath);
           }
         })
-        dependencies[path.join("/")] = { definitionName, elementName, element, path, parent, dependencies: elementDependencies };
+        dependencies[path.join("/")] = { structuralNodeName, definitionName, elementName, element, path, parent, dependencies: elementDependencies };
       }
     }) // forEachMemberRecursively
   }, { skipArtifact: isExternalServiceMember }) // forEachDefinition

package/lib/transform/odata/structuralPath.js

@@ -0,0 +1,72 @@
+// The module traverses a given CSN using a specific path, collects structural node names and returns them.
+
+const structuralNodeHandlers = {
+  definitions: traverseDict,
+  elements: traverseDict,
+  actions: traverseDict,
+  params: traverseDict,
+  items: traverseTyped,
+  enum: traverseDict,
+  returns: traverseTyped,
+  on: traverseArray,
+  keys: traverseArray,
+  ref: traverseArray,
+  query: traverseTyped,
+  SELECT: traverseTyped,
+  SET: traverseTyped,
+  args: traverseArray,
+  columns: traverseArray,
+  projection: traverseTyped,
+  from: traverseTyped,
+  mixin: traverseDict,
+  where: traverseArray,
+  orderBy: traverseArray,
+  groupBy: traverseArray,
+  having: traverseArray,
+  xpr: traverseArray,
+  expand: traverseArray,
+  inline: traverseArray,
+  cast: traverseTyped,
+}
+
+function structuralPath(csn, path) {
+  return traverseDict(csn.definitions, path, 1, ['definitions']);
+}
+
+function traverseArray(obj, path, index, typeStack) {
+  if(!Array.isArray(obj)) return typeStack;
+  const name = path[index];
+  const element = obj[name];
+  return traverseTyped(element, path, index+1, typeStack);
+}
+
+function traverseDict(obj, path, index, typeStack) {
+  if(typeof obj !== 'object') return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  return traverseTyped(obj[name], path, index+1, typeStack);
+}
+
+function traverseDictArray(obj, path, index, typeStack) {
+  if(typeof obj !== 'object') return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  return traverseArray(obj[name], path, index+1, typeStack);
+}
+
+function traverseTyped(obj, path, index, typeStack) {
+  if(!obj) return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  if(name[0] === '@') return typeStack; // skip annotations
+  const func = structuralNodeHandlers[name];
+  if(func) return func(obj[name], path, index+1, typeStack.concat(name));
+  // not typed -> columns?
+  if(typeStack[typeStack.length-1] === 'columns')
+    return traverseDictArray(obj, path, index, typeStack);
+  return typeStack;
+}
+
+module.exports = {
+  structuralPath
+}

package/lib/transform/odata/structureFlattener.js

@@ -74,17 +74,22 @@ function flattenDefinition(definition, definitionPath, csnUtils, options, refere
   if (definition.kind !== 'entity' && definition.kind !== 'view')
     return;
 
-  let { newFlatElements } = flattenStructure(definition, definitionPath, csnUtils, options, error, referenceFlattener);
+  let { newFlatElements } = flattenStructure(definition.elements, definitionPath, csnUtils, options, error, referenceFlattener);
 
   attachPathOnPartialCSN(newFlatElements, definitionPath.concat('elements'));
-
   definition.elements = newFlatElements;
+
+  if (definition.params) {
+    let { newFlatElements } = flattenStructure(definition.params, definitionPath, csnUtils, options, error, referenceFlattener);
+    attachPathOnPartialCSN(newFlatElements, definitionPath.concat('params'));
+    definition.params = newFlatElements;
+  }
 } // flattenDefinition
 
 /**
  * Flattens structured element by calling element flattener for each structured child.
  * Returns a dictionary containing all the new elements for the given structure.
- * @param {*} struct the structure to flatten
+ * @param {*} dictionary to flatten
  * @param {CSN.Path} path the path of the structure in the CSN tree
  * @param {*} csnUtils
  * @param {Function} error Error message function
@@ -93,14 +98,14 @@ function flattenDefinition(definition, definitionPath, csnUtils, options, refere
  * @param {*} [newFlatElements]
  * @param {boolean} [isTopLevelElement] states if this is a top level element
  */
-function flattenStructure(struct, path, csnUtils, options, error, referenceFlattener = undefined, elementPathInStructure = [],
+function flattenStructure(dictionary, path, csnUtils, options, error, referenceFlattener = undefined, elementPathInStructure = [],
   newFlatElements = Object.create(null), isTopLevelElement = true, isParentNotNull = false) {
 
-  if (!isTopLevelElement) addPropsForPropagationFromElement(struct);
+  if (!isTopLevelElement) addPropsForPropagationFromElement(dictionary);
 
   let generatedNewFlatElementsNames = []; // holds the names of all new child elements of the structure
 
-  struct.elements && Object.entries(struct.elements).forEach(([elementName, element]) => {
+  dictionary && Object.entries(dictionary).forEach(([elementName, element]) => {
     let currPath = path.concat('elements', elementName);
 
     if (isTopLevelElement) {
@@ -118,8 +123,8 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
       addPropsForPropagationFromElement(element);
 
       // if the child element is structured itself -> needs to be flattened
-      const subStruct = element.elements ? element : csnUtils.getFinalBaseType(element.type);
-      let result = flattenStructure(subStruct, currPath, csnUtils, options, error, referenceFlattener, elementPathInStructure.concat(elementName), newFlatElements, false, isNotNull());
+      const elements = element.elements || csnUtils.getFinalBaseType(element.type).elements;
+      let result = flattenStructure(elements, currPath, csnUtils, options, error, referenceFlattener, elementPathInStructure.concat(elementName), newFlatElements, false, isNotNull());
       generatedNewFlatElementsNames.push(...result.generatedNewFlatElementsNames); // accomulate names of produced elements
 
     } else { // when we do not need to flat, this is scalar or empty (cds-compiler#4337) -> needs to be registered in referenceFlattener
@@ -127,7 +132,6 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
       let elementNameWithDots = elementPathInStructure.concat(elementName).join('.');
       addNewElementToResult(element, newElementName, elementNameWithDots, currPath);
     }
-
   });
 
   if (referenceFlattener) {
@@ -135,7 +139,6 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
   }
   return { newFlatElements, generatedNewFlatElementsNames };
 
-
   // adds newly created element into the final dictionary of elements
   function addNewElementToResult(element, elementName, elementNameWithDots, path) {
     if (newFlatElements[elementName]) {

package/lib/transform/odata/typesExposure.js

@@ -25,7 +25,6 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
   // collect in this variable all the newly exposed types
   const exposedStructTypes = [];
   const schemas = Object.create(null);
-
   // walk through the definitions of the given CSN and expose types where needed
   forEachDefinition(csn, (def, defName, propertyName, path) => {
     // we do expose types only for definition from inside services
@@ -33,11 +32,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
     if (serviceName) {
       if (['type', 'entity', 'view'].includes(def.kind)) {
         forEachMember(def, (element, elementName, propertyName, path) => {
-          if (propertyName === 'elements' || propertyName === 'params') {
+          if (['elements', 'params'].includes(propertyName)) {
             const artificialtName = `${isMultiSchema ?
               defNameWithoutServiceOrContextName(defName, serviceName)
               : defNameWithoutServiceOrContextName(defName, serviceName).replace(/\./g, '_')}_${elementName}`;
-            exposeTypeOf(element, elementName, defName, serviceName, artificialtName, path);
+            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, artificialtName, path);
           }
         }, path);
       }
@@ -64,11 +63,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
    * @param {string} artificialName
    * @param {CSN.Path} path
    */
-  function exposeTypeOf(node, memberName, defName, service, artificialName, path) {
+  function exposeTypeOf(node, isKey, memberName, defName, service, artificialName, path) {
     if (isArrayed(node))
-      exposeArrayOfTypeOf(node, memberName, defName, service, artificialName, path);
+      exposeArrayOfTypeOf(node, isKey, memberName, defName, service, artificialName, path);
     else if (csnUtils.isStructured(node))
-      exposeStructTypeOf(node, memberName, defName, service, artificialName, path);
+      exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path);
   }
 
   /**
@@ -90,12 +89,12 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
   function exposeTypesOfAction(action, actionName, defName, service, path) {
     if (action.returns) {
       const artificialName = `return_${actionName.replace(/\./g, '_')}`;
-      exposeTypeOf(action.returns, actionName, defName, service, artificialName, path.concat(['returns']));
+      exposeTypeOf(action.returns, false, actionName, defName, service, artificialName, path.concat(['returns']));
     }
 
     action.params && Object.entries(action.params).forEach(([paramName, param]) => {
       const artificialName = `param_${actionName.replace(/\./g, '_')}_${paramName}`;
-      exposeTypeOf(param, actionName, defName, service, artificialName, path.concat(['params', paramName]));
+      exposeTypeOf(param, false, actionName, defName, service, artificialName, path.concat(['params', paramName]));
     });
   }
 
@@ -108,9 +107,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
    * @param {String} service
    * @param {String} artificialName
    */
-  function exposeStructTypeOf(node, memberName, defName, service, artificialName, path, parentName) {
+  function exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path, parentName) {
+    if (node.items) exposeStructTypeOf(node.items, isKey, memberName, defName, service, artificialName, path);
 
-    if (node.items) exposeStructTypeOf(node.items, memberName, defName, service, artificialName, path);
+    // start conservative, assume we're in a named type
+    let isAnonymous = false;
 
     if (isExposableStructure(node)) {
       let typeDef = node.type ? csnUtils.getCsnDef(node.type) : /* structure|anonymous type */ node;
@@ -124,6 +125,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
       // and the new target. Consequently, we now have both type and elements properties in this case, and the elements should be taken as a priority
       // as the correct target is there and no longer in the type definition
       let newTypeElements = (node.type && node.elements) ? node.elements : typeDef.elements;
+      // if node and typeDef are identical, we're anonymous
+      isAnonymous = node === typeDef;
+      // if we've left the anonymous world, we're no longer in a key def
+      if (!isAnonymous)
+        isKey = false;
 
       let newType = exposeStructType(newTypeFullName, newTypeElements, memberName, path);
       if (!newType) {
@@ -138,6 +144,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
       newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
         if (node.elements && node.elements[elemName].$location) setProp(newElem, '$location', node.elements[elemName].$location);
         exposeStructTypeOf(newElem,
+          isKey,
           memberName,
           typeDef.kind === 'type' ? node.type : defName,
           service,
@@ -251,6 +258,9 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
           error(null, path, `"${elemName}": Element name conflicts with existing element`);
         }
         let cloned = cloneCsn(element, options);
+        // if this was an anonymous sub element of a key, mark it as not nullable
+        if(isAnonymous && isKey && !cloned.key && cloned.notNull === undefined)
+          cloned.notNull = true;
         type.elements[elemName] = cloned;
       });
 
@@ -265,12 +275,12 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
 
   // If a member is of type "array of <named type|anonymous type>", we expose the arrayed type,
   // like we expose structures in structured mode
-  function exposeArrayOfTypeOf(node, memberName, defName, service, artificialName, path) {
+  function exposeArrayOfTypeOf(node, isKey, memberName, defName, service, artificialName, path) {
     // if anonymously defined in place -> we always expose the type
     // this would be definition like 'elem: array of { ... }'
     // and we use the artificial name for the new type name
     if (node.items && !node.type) {
-      exposeStructTypeOf(node.items, memberName, defName, service, artificialName, path.concat('items'));
+      exposeStructTypeOf(node.items, isKey, memberName, defName, service, artificialName, path.concat('items'));
     }
     // we can have both of the 'type' and 'items' in the cases:
     // 1. 'elem: Foo' and 'type Foo: array of Baz' and 'type Baz: { ... }'