@sap/cds-compiler 2.4.4 → 2.10.2

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:
@@ -38,6 +39,7 @@ class ReferenceFlattener {
     this.structuredReference = {};
     this.generatedElementsForPath = {};
     this.elementTransitions = {};
+    this.elementNamesWithDots = {};
   }
 
   /**
@@ -72,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;
     });
@@ -157,6 +158,14 @@ class ReferenceFlattener {
     return this.generatedElementsForPath[path.join('/')];
   }
 
+  setElementNameWithDots(path, elementNameWithDots) {
+    this.elementNamesWithDots[path.join('/')] = elementNameWithDots;
+  }
+
+  getElementNameWithDots(path) {
+    return this.elementNamesWithDots[path.join('/')];
+  }
+
   /**
    * Generic reference flattener as {@link ReferenceFlattener described}.
    *
@@ -167,35 +176,40 @@ 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) {
-            newRef[newRef.length - 1] = newRef[newRef.length - 1] + '_' + ref[i];
-            anythingFlattened = true;
+            newRef[newRef.length - 1] = newRef[newRef.length - 1] + '_' + (ref[i].id || ref[i]);
+            // if we have a filter or args in an assoc, it needs to be kept, therefore
+            // the id of the ref is updated with the flattened version
+            if (ref[i].id) {
+              ref[i].id = newRef[newRef.length - 1];
+              newRef[newRef.length - 1] = ref[i];
+            }
+            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))
@@ -208,10 +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?
-      if (!['on', '$self', null].includes(node.$scope)) return;
-
+      // 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];
@@ -235,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

@@ -18,13 +18,13 @@ const {
 } = require('./utils');
 const { forEach } = require('../../utils/objectUtils.js');
 
-function buildDependenciesFor(csn, referenceFlattener) {
+function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember) {
 
   let dependencies = {};
   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,10 +44,10 @@ function buildDependenciesFor(csn, referenceFlattener) {
             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
-  }) // forEachDefinition
+  }, { skipArtifact: isExternalServiceMember }) // forEachDefinition
 
   let result = []; // final list of sorted association items
   let inResult = {}; // paths of associations which were added in the result

package/lib/transform/odata/structuralPath.js

@@ -0,0 +1,76 @@
+// 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: traverseRef,
+  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 traverseRef(obj, path, index, typeStack) {
+  return traverseArray(obj, path, index, typeStack);
+}
+
+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

@@ -1,7 +1,6 @@
 'use strict';
 
 const { copyAnnotations } = require('../../model/csnUtils');
-const { setProp } = require('../../base/model');
 const { cloneCsn, forEachDefinition } = require('../../model/csnUtils');
 const { attachPathOnPartialCSN } = require('./attachPath');
 
@@ -50,18 +49,16 @@ const { isNotNull, setNotNull, setUpNotNull } = function () {
  * During the OData transformations in flat-mode, all structured elements will be flattened.
  * This module performs the complete flattening.
  * It also provides information to the reference flattener: elements produced for specific path in the CSN structure.
- * Each generated element gets hidden attributes:
- *  - $viaTransform - states that the element was generated during transformation
- *  - _flatElementNameWithDots - names in the element path concatenated with dot
  * @param {CSN.Model} csn CSN-object to flatten
  * @param {*} csnUtils instances of utility functions
  * @param {*} options
  * @param {*} referenceFlattener
  * @param {Function} error
+ * @param {Function} isExternalServiceMember returns true for an artifact that is part of an external service
  */
-function flattenCSN(csn, csnUtils, options, referenceFlattener, error) {
+function flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExternalServiceMember) {
   forEachDefinition(csn, (def, defName, propertyName, path) =>
-    flattenDefinition(def, path, csnUtils, options, referenceFlattener, error));
+    flattenDefinition(def, path, csnUtils, options, referenceFlattener, error), { skipArtifact: isExternalServiceMember });
 }
 
 /**
@@ -77,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
@@ -96,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) {
@@ -121,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
@@ -130,7 +132,6 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
       let elementNameWithDots = elementPathInStructure.concat(elementName).join('.');
       addNewElementToResult(element, newElementName, elementNameWithDots, currPath);
     }
-
   });
 
   if (referenceFlattener) {
@@ -138,31 +139,29 @@ 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]) {
       error(null, path, `Generated element ${elementName} conflicts with other generated element`);
     } else {
-      let newElement = createNewElement(element, elementNameWithDots);
+      let newPath = path.slice(0, 2).concat('elements', elementName);
+      let newElement = createNewElement(element, elementNameWithDots, newPath);
       newFlatElements[elementName] = newElement;
       generatedNewFlatElementsNames.push(elementName);
 
       if (referenceFlattener) {
-        let newPath = path.slice(0, 2).concat('elements', elementName);
         referenceFlattener.registerElementTransition(path, newPath);
       }
     }
   } // addNewElementToResult
 
   // creates new element by copying the properties of the originating element
-  function createNewElement(element, elementNameWithDots) {
+  function createNewElement(element, elementNameWithDots, path) {
     let newElement = cloneCsn(element, options);
     if (!isTopLevelElement) propagatePropsToElement(newElement);
     if (isNotNull() === undefined) delete newElement.notNull;
-    if (!isTopLevelElement) {
-      setProp(newElement, '$viaTransform', true);
-      setProp(newElement, '_flatElementNameWithDots', elementNameWithDots);
+    if (!isTopLevelElement && referenceFlattener) {
+      referenceFlattener.setElementNameWithDots(path, elementNameWithDots);
     }
     return newElement;
   } // createNewElement

package/lib/transform/odata/toFinalBaseType.js

@@ -1,12 +1,12 @@
 'use strict';
 
 const {
-  cloneCsn, forEachDefinition,
-  forEachMemberRecursively, isBuiltinType,
+  forEachDefinition, forEachMemberRecursively,
+  isBuiltinType, cloneCsnDictionary,
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
-function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
+function expandToFinalBaseType(csn, transformers, csnUtils, services, options, isExternalServiceMember) {
   const isV4 = options.toOdata.version === 'v4';
   forEachDefinition(csn, (def, defName) => {
     // Unravel derived type chains to final one for elements, actions, action parameters (propagating annotations)
@@ -60,7 +60,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
     if (def.kind === 'type' && def.items && isArtifactInSomeService(defName, services)) {
       expandFirstLevelOfArrayed(def);
     }
-  });
+  }, { skipArtifact: isExternalServiceMember });
 
   // In case we have in the model something like:
   // type Foo: array of Bar; type Bar: { qux: Integer };
@@ -70,7 +70,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
     if (def.items.type && !isBuiltinType(def.items.type)) {
       let finalType = csnUtils.getFinalTypeDef(def.items.type);
       if (csnUtils.isStructured(finalType)) {
-        def.items.elements = cloneCsn(finalType.elements, options);
+        def.items.elements = cloneCsnDictionary(finalType.elements, options);
         delete def.items.type;
       }
     }

package/lib/transform/odata/typesExposure.js

@@ -8,7 +8,7 @@
 
 const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsn, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
+const { cloneCsn, isBuiltinType, forEachDefinition, forEachMember, cloneCsnDictionary } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
 
 /**
@@ -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,
@@ -167,7 +174,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
     /**
      * Calculate the new type name that will be exposed in multi schema,
      * in case that the element has a named type.
-     * 
+     *
      * @param {string} typeName type of the element
      * @param {string} service current service name
      */
@@ -196,7 +203,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
     /**
      * Calculate the new type name that will be exposed in multi schema,
      * in case that the element has an anonymous type.
-     * 
+     *
      * @param {string} typeName type of the element
      * @param {string} parentName name of the parent def holding the element
      */
@@ -212,7 +219,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
 
     /**
      * Tf does not exists, create a context with the given name in the CSN
-     * @param {string} name 
+     * @param {string} name
      */
     function createSchema(name) {
       schemas[`${name}`] = { kind: 'schema', name };
@@ -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: { ... }'
@@ -323,7 +333,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
     if (def.items.type && !isBuiltinType(def.items.type)) {
       let finalType = csnUtils.getFinalTypeDef(def.items.type);
       if (csnUtils.isStructured(finalType)) {
-        if (!def.items.elements) def.items.elements = cloneCsn(finalType.elements, options);
+        if (!def.items.elements) def.items.elements = cloneCsnDictionary(finalType.elements, options);
         delete def.items.type;
       }
     }

package/lib/transform/odata/utils.js

@@ -22,7 +22,7 @@ function isManagedAssociationElement(artifact) {
   return artifact.target !== undefined && artifact.on === undefined;
 }
 
-function forEachManagedAssociation(csn, callback) {
+function forEachManagedAssociation(csn, callback, isExternalServiceMember) {
 
   forEachDefinition(csn, (def) => {
     forEachMemberRecursively(def, (element) => {
@@ -30,7 +30,7 @@ function forEachManagedAssociation(csn, callback) {
         callback(element)
       }
     })
-  })
+  }, { skipArtifact: isExternalServiceMember });
 
 }