@sap/cds-compiler 5.3.0 → 5.4.0

package/lib/transform/forOdata.js

@@ -10,6 +10,8 @@ const { forEachDefinition,
         isAspect,
         getServiceNames,
         forEachGeneric,
+        cardinality2str,
+        getUtils
       } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
@@ -18,6 +20,7 @@ const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const { timetrace } = require('../utils/timetrace');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
 const flattening = require('./odata/flattening');
+const createForeignKeyElements = require('./odata/createForeignKeys');
 const associations = require('./db/associations')
 const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
@@ -181,24 +184,31 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // If errors are detected, throwWithAnyError() will return from further processing
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
+  // do expansion before Fk creation because of messages reporting
   if (!structuredOData) {
     expansion.expandStructureReferences(csn, options, '_',
       { error, info, throwWithAnyError }, csnUtils,
       { skipArtifact: isExternalServiceMember });
-    const resolved = new WeakMap();
+  }
+
+  createForeignKeyElements(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });
 
+  if (!structuredOData) {
+    const resolved = new WeakMap();
     const { inspectRef, effectiveType } = csnRefs(csn);
+    const { getFinalTypeInfo } = getUtils(csn);
     const { adaptRefs, transformer: refFlattener } =
       flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
 
-    flattening.allInOneFlattening(csn, refFlattener, adaptRefs,
-        inspectRef, isExternalServiceMember, error, csnUtils, options);
+    const allMgdAssocDefs = flattening.allInOneFlattening(csn, refFlattener, adaptRefs,
+      inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options);
     flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs,
         inspectRef, effectiveType, csnUtils, error, options,
       { //skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
       });
-
+    flattening.replaceManagedAssocsAsKeys(allMgdAssocDefs, csnUtils);
+      
     // replace structured with flat dictionaries that contain
     // rewritten path expressions
     forEachDefinition(csn, (def) => {
@@ -223,16 +233,14 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     });
   }
 
-  // TODO: add the generated foreign keys to the columns when we are in a view
-  // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_',
-    !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
+  bindCsnReferenceOnly();
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
   // since then the foreign keys of the managed assocs are part of the elements
-  if(!structuredOData)
+  if(!structuredOData) {
     forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_'));
+  }
 
   // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
   throwWithAnyError();
@@ -277,7 +285,8 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
           !(propertyName === 'enum' || propertyName === 'returns') &&
           (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
-        member['@cds.persistence.name'] = getElementDatabaseNameOf(member.$defPath?.slice(1).join('.') || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
+        member['@cds.persistence.name'] = getElementDatabaseNameOf((!member['@odata.foreignKey4'] && member.$defPath?.slice(1).join('.'))
+                                                                    || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -286,6 +295,12 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
       // Resolve annotation shorthands for elements, actions, action parameters
       renameShorthandAnnotations(member);
 
+      // If an association was modelled as not null, like so:
+      // <associationName>: Association to <target> not null;
+      // a cardinality property is set to the association member
+      // with the value { "min": 1 };
+      setCardinalityToNotNullAssociations(member);
+
       // - If the association target is annotated with @cds.odata.valuelist, annotate the
       //      association with @Common.ValueList.viaAssociation
       // - Check for @Analytics.Measure and @Aggregation.default
@@ -419,6 +434,27 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     }
   }
 
+  // If an association was modelled as not null, like so:
+  // <associationName>: Association to <target> not null;
+  // a cardinality property is set to the association member
+  // with the value { "min": 1 };
+  function setCardinalityToNotNullAssociations(member) {
+    if (member.target && member.keys && !member.on) {
+      if (member.notNull) {
+        if (member.cardinality === undefined)
+          member.cardinality = {};
+          // min=0 is falsy => check for undefined
+        if (member.cardinality.min === undefined) {
+          member.cardinality.min = 1;
+        }
+        else if (member.cardinality.min === 0) {
+          warning(null, member.$path, { value: cardinality2str(member, false), code: 'not null' },
+                  'Expected target cardinality $(VALUE) and $(CODE) to match');
+        }
+      }
+    }
+  }
+
   // Apply default type facets to each type definition and every member
   // But do not apply default string length (as in DB)
   function setDefaultTypeFacets(def) {
@@ -466,4 +502,11 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     }
   }
 
+  function bindCsnReferenceOnly() {
+    // invalidate caches for CSN ref API
+    const csnRefApi = csnRefs(csn);
+    Object.assign(csnUtils, csnRefApi);
+  }
+
+
 } // transform4odataWithCsn

package/lib/transform/forRelationalDB.js

@@ -248,7 +248,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   });
 
-  processCalculatedElementsInEntities(csn);
+  processCalculatedElementsInEntities(csn, options);
 
   timetrace.start('Transform CSN')
 
@@ -856,6 +856,13 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
             checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
             break;
           }
+          case 'cds.Map': {
+            if (options.sqlDialect === 'plain')
+              error('ref-unsupported-type', path, { '#': 'dialect', type: node.type, value: 'plain' });
+            else if (options.transformation === 'hdbcds')
+              error('ref-unsupported-type', path, {'#': 'hdbcds', type: node.type, value: options.sqlDialect });
+            break;
+          }
           case 'cds.Vector': {
             if (options.sqlDialect !== 'hana') {
               error('ref-unsupported-type', path, {

package/lib/transform/odata/createForeignKeys.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const { isBuiltinType } = require('../../base/builtins');
+const { setProp } = require('../../base/model');
+const { applyTransformations, implicitAs, findAnnotationExpression, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
+const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
+
+function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iterateOptions = {}) {
+
+    const { error } = messageFunctions;
+
+    applyTransformations(csn, { elements: createForeignKeysInCsn, params: createForeignKeysInCsn},
+                         [], Object.assign(iterateOptions, { skip: ['aspect', 'event'], skipStandard: { targetAspect: true } }));
+
+    /**
+     * Process a given elements or params dictionary and create foreign key elements.
+     *
+     * @param {object} parent The thing HAVING params or elements
+     * @param {string} prop
+     * @param {object} dict The params or elements thing
+     * @param {CSN.Path} path
+     */
+    function createForeignKeysInCsn( parent, prop, dict, path ) {
+      const orderedElements = [];
+      // First, generate the FK elements for given element
+      Object.entries(dict).forEach(([elementName, element]) => {
+        orderedElements.push([ elementName, element ]);
+        if (!csnUtils.isManagedAssociation(element)) return;
+        const elementPath = path.concat(prop, elementName);
+        const generatedForeignKeys = createForeignKeysForElement(csnUtils, 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]]++;
+          else
+            acc[fk[0]] = 1;
+
+          // check for name clash with existing elements
+          if (parent[prop][fk[0]] && isDeepEqual(element, parent[prop][fk[0]], true)) {
+            // error location is the colliding element
+            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
+          }
+          // attach a proper $path
+          setProp(element, '$path', elementPath);
+          return acc;
+        }, Object.create(null));
+
+        // set default for single foreign key from association (if available)
+        if (element.default?.val !== undefined && generatedForeignKeys.length === 1)
+        generatedForeignKeys[0][1].default = element.default;
+
+        // check for duplicate foreign keys
+        Object.entries(refCount).forEach(([ name, occ ]) => {
+          if (occ > 1)
+            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-gen', name, art: elementName });
+        });
+        if (element.keys) {
+          if (options.transformation === 'effective')
+            delete element.default;
+        }
+        setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => gfk[0]));
+        orderedElements.push(...generatedForeignKeys);
+      
+    });
+
+    parent[prop] = orderedElements.reduce((elementsAccumulator, [ name, element ]) => {
+      elementsAccumulator[name] = element;
+      return elementsAccumulator;
+    }, Object.create(null));
+}
+
+function createForeignKeysForElement(csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0 ) {
+  const special$self = !csn?.definitions?.$self && '$self';
+  const isInspectRefResult = !Array.isArray(path);
+
+  let fks = [];
+  if (!element)
+    return fks;
+
+  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];
+      }
+    }
+  }
+
+  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);
+      fks = fks.concat(createForeignKeysForElement(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
+    });
+  }
+  // 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));
+      }
+    });
+  }
+  // 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 ] ];
+  }
+
+  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 validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !findAnnotationExpression(element, pn));
+      copyAnnotations(element, fk[1], true, {}, validAnnoNames);
+      // 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);
+    }
+  });
+  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

@@ -5,14 +5,16 @@ const { forEachDefinition,
   transformExpression, transformAnnotationExpression } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
-const { setProp } = require('../../base/model');
+const { setProp, forEachGeneric } = require('../../base/model');
 const { applyTransformationsOnDictionary,
   applyTransformationsOnNonDictionary } = require('../db/applyTransformations.js');
 const { handleManagedAssociationsAndCreateForeignKeys } = require('../db/flattening');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { forEach } = require('../../utils/objectUtils');
+const { assignAnnotation } = require('../../edm/edmUtils');
 
-function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options) {
+function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options) {
+  const allMgdAssocDefs = []; 
   forEachDefinition(csn, (def, defName) => {
     if (def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
       ['elements', 'params'].forEach(dictName => {
@@ -27,7 +29,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             let resolvedElt = child;
             let typeIdx = 0;
             if (child.type && !child.elements) {
-              resolvedElt = csnUtils.getFinalTypeInfo(child.type);
+              resolvedElt = getFinalTypeInfo(child.type);
               if (resolvedElt.elements)
                 typeIdx = rootPrefix.length + 1;
             }
@@ -41,10 +43,12 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
                         { '#': 'flatten-element-exist', name: flatEltName });
                 propagateToFlatElem(child, flatElt);
                 rewriteOnCondition(flatElt, flattenedSubTree);
+                adaptManagedAssociationSpecialFields(flatElt, flatEltName, flattenedSubTree);
                 orderedElementList.push([flatEltName, flatElt]);
               });
             }
             else {
+              // TODO: run adaptManagedAssociationSpecialFields here as well
               const flatElt = cloneElt(dictName, child, location, [ defName, childName ]);
               orderedElementList.push([childName, flatElt]);
             }
@@ -53,16 +57,26 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
           const flatDict = orderedElementList.reduce((elements, [ flatEltName, flatElt ]) => {
             if (flatElt.items) {
               // rewrite annotation paths inside items.elements
-              forEachMemberRecursively(flatElt.items, (elt, _eltName, _prop, path) => {
+              forEachMemberRecursively(flatElt.items, (elt, eltName, _prop, path) => {
                 const exprAnnos = Object.keys(elt).filter(pn => pn[0] === '@');
                 flattenAndPrefixExprPaths(elt, exprAnnos, elt.$path, path, 0, true);
+                if (csnUtils.isManagedAssociation(elt)) {
+                  allMgdAssocDefs.push(elt);
+                }
               }, [ flatEltName ], true, { pathWithoutProp: true } );
             }
+            setProp(flatElt, '$pathInStructuredModel', flatElt.$path);
             setProp(flatElt, '$path', [ ...csnPath, flatEltName ]);
             elements[flatEltName] = flatElt;
             return elements;
           }, Object.create(null));
           setProp(def, `$flat${dictName}`, flatDict);
+          orderedElementList.reduce(
+            (mgdAssocs, [ _flatEltName, flatElt ]) => {
+              if(csnUtils.isManagedAssociation(flatElt))
+                mgdAssocs.push(flatElt);
+              return mgdAssocs;
+            }, allMgdAssocDefs);
         }
       });
       // entity annotations
@@ -126,7 +140,30 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
         });
       }
     }
+    // loop through types as well in order to collect the managaed associations
+    // that reside in types definitions
+    if ((def.kind === 'action' || def.kind === 'function' || def.kind === 'type') && !isExternalServiceMember(def, defName)) {
+      if (def.kind === 'type' && csnUtils.isManagedAssociation(def))
+        allMgdAssocDefs.push(def);
+      else
+        forEachMemberRecursively(def, (elt, _eltName, _prop, _path) => {
+          if (csnUtils.isManagedAssociation(elt)) {
+            allMgdAssocDefs.push(elt);
+          }
+        });
+    }
+    // loop through actions/functions and action/function parameters as well
+    if (def.kind === 'entity' && def.actions && !isExternalServiceMember(def, defName)) {
+      forEachGeneric(def, 'actions', (act) => {
+        forEachMemberRecursively(act, (elt, _eltName, _prop, _path) => {
+          if (csnUtils.isManagedAssociation(elt)) {
+            allMgdAssocDefs.push(elt);
+          }
+        });
+      });
+    }
   });
+  return allMgdAssocDefs;
 
   function recurseIntoElement(scope, elt, resolvedElt, rootPathIsNotNull, location, rootPrefix = [], typeIdx = 0) {
     const eltName = rootPrefix[rootPrefix.length-1];
@@ -143,7 +180,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       forEach(resolvedElt.elements, (childName, child) => {
         resolvedElt = child;
         if (child.type && !child.elements) {
-          resolvedElt = csnUtils.getFinalTypeInfo(child.type);
+          resolvedElt = getFinalTypeInfo(child.type);
           if (resolvedElt.elements)
             typeIdx = rootPrefix.length + 1;
         }
@@ -206,14 +243,16 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
   function cloneElt(scope, elt, location, rootPrefix = [], typeIdx = 0) {
     const flatElt = cloneCsnNonDict(elt,
       { ...options,
-        hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ]
+        hiddenPropertiesToClone: [ '$structRef', '$fkExtensions', '$generatedForeignKeys' ]
       } );
 
     // needed for @cds.persistence.name
     setProp(flatElt, '$defPath', rootPrefix);
     setProp(flatElt, '$scope', scope);
     retypeCloneWithFinalBaseType(flatElt, location);
-
+    if((elt._type || elt).type === 'cds.Map') {
+      assignAnnotation(flatElt, '@open', elt['@open'] || true);
+    }
     const [ nonAnnoProps, exprAnnoProps ] = Object.keys(flatElt).reduce((acc, pn) => {
       if (pn[0] !== '@' && pn !== 'value')
         acc[0].push(pn);
@@ -405,6 +444,25 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       });
     }
   }
+
+  // update the @odata.foreignKey4 and the $generatedForeignKeys array of
+  // an association that have been flattened
+  function adaptManagedAssociationSpecialFields(flatElt, flatEltName, flattenedSubTree) {
+    if (!(flatElt.target || flatElt.keys) && !flatElt.on )
+      return;
+    const structuredAssocName = flatElt.$defPath[flatElt.$defPath.length - 1];
+    const generatedForeignKeysForAssoc = flattenedSubTree
+      .filter(se => {
+        // compare $defPath without the last element
+        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();
+    setProp(flatElt, '$generatedForeignKeys', generatedForeignKeysForAssoc.map(gfk => gfk[0]));
+  }
 }
 
 function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef, effectiveType,
@@ -494,6 +552,8 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
       const { links, art, scope } = inspectRef(path);
       const resolvedLinkTypes = resolveLinkTypes(links);
       setProp(parent, '$path', [ ...path ]);
+      if (insideKeys(path))
+        setProp(parent, '_art', art);
       const lastRef = ref[ref.length - 1];
       const fn = (suspend = false, suspendPos = 0, 
                     refFilter = (_parent) => true) => {
@@ -536,18 +596,19 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
             || path[path.length - 3] === 'projection')
             && path[path.length - 2] === 'columns';
         }
-        /**
-         * Return true if the path points inside keys
-         *
-         * @param {CSN.Path} path
-         * @returns {boolean}
-         */
-        function insideKeys( path ) {
-          return path.length >= 3
-            && path[path.length - 2] === 'keys'
-            && typeof path[path.length - 1] === 'number';
-        }
       };
+      /**
+       * Return true if the path points inside keys
+       *
+       * @param {CSN.Path} path
+       * @returns {boolean}
+       */
+      function insideKeys( path ) {
+        return path.length >= 3
+          && path[path.length - 2] === 'keys'
+          && typeof path[path.length - 1] === 'number';
+      }
+
 
       // adapt queries later
       if(ctx?.annoExpr?.['=']) {
@@ -565,9 +626,64 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
   return { adaptRefs, transformer, inspectRef, effectiveType };
 }
 
+// replace managed associations in key refs with their respective foreing keys
+function replaceManagedAssocsAsKeys(allFlatManagedAssocDefinitions, csnUtils) {
+  allFlatManagedAssocDefinitions.forEach( assoc => {
+    let finished = false;
+
+    while (!finished) {
+      const newKeys = [];
+      finished = processKeys(newKeys);
+      assoc.keys = newKeys;
+    }
+
+    function processKeys(collector) {
+      let done = true;
+      assoc.keys.forEach( key => {
+        const art = key._art;
+        if (art && csnUtils.isManagedAssociation(art)) {
+          done = false;
+          // key._art is the artifact from the structured model, because of that we need to look
+          // for the flat representation in the allFlatManagedAssocDefinitions
+          allFlatManagedAssocDefinitions.find(fa => (fa.$pathInStructuredModel || fa.$path).join() === art.$path.join())
+            .keys.forEach( keyAssocKey => {
+            collector.push(cloneAndExtendRef(keyAssocKey, key));
+          });
+        }
+        else if (art && !art.on){
+          if (!key.$generatedFieldName) {
+            const flatAssocName = assoc.$path[assoc.$path.length - 1];
+            // When we have a definition like type "<type_name>: Association to <target_name>",
+            // we do not generate foreign keys in the definition, therefore no $generatedForeignKeys,
+            // respectively we do not assign $generatedFieldName
+            if (assoc.$generatedForeignKeys) {
+              const generatedForeignKey = assoc.$generatedForeignKeys.find(gfk => gfk === `${flatAssocName}_${key.as || key.ref.join('_')}`);
+              key.$generatedFieldName = generatedForeignKey;
+            }
+          }
+          if (key.as && key.as === key.ref[0]) delete key.as;
+          collector.push(key);
+        }
+      })
+
+      return done;
+    }
+  });
+  
+  function cloneAndExtendRef(keyAssocKey, key) {
+    let newKey = { ref:  [`${key.ref.join('_')}_${keyAssocKey.as || keyAssocKey.ref.join('_')}`] };
+    setProp(newKey, '_art', keyAssocKey._art);
+    if (key.as) {
+      newKey.as = `${key.as}_${keyAssocKey.as || keyAssocKey.ref.join('_')}`;
+    }
+    return newKey;
+  }
+}
+
 module.exports = {
   allInOneFlattening,
   flattenAllStructStepsInRefs,
   handleManagedAssociationsAndCreateForeignKeys,
-  getStructRefFlatteningTransformer
+  getStructRefFlatteningTransformer,
+  replaceManagedAssocsAsKeys
 };

package/lib/transform/odata/typesExposure.js

@@ -64,6 +64,7 @@ const { cloneCsnNonDict } = require('../../model/cloneCsn');
 function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
   const special$self = !csn?.definitions?.$self && '$self';
+
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.odataVersion === 'v4' && (options.odataProxies || options.odataXServiceRefs);
   // service sub schemas as return value
@@ -166,7 +167,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           isKey = false;
         // in case this was a named type and if the openness does not match the type definition
         // expose the type as a new one not changing the original definition.
-        if(elements && !!node['@open'] !== !!typeDef['@open'])
+        if(elements && node['@open'] != null && !!node['@open'] !== !!typeDef['@open'])
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
         lastNonAnonymousFQDefName = fullQualifiedNewTypeName;
       }
@@ -293,10 +294,10 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       if(type) {
         typeName = (type.ref && csnUtils.artifactRef(type)) || type;
         const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
-        if(!isBuiltinType(typeName) && typeName !== special$self) {
+        if((!isBuiltinType(typeName) || typeName === 'cds.Map') && typeName !== special$self) {
           rc.typeDef = typeDef = csnUtils.artifactRef(typeName, typeName);
           if(!isArtifactInService(typeName, serviceName)) {
-            while(!isBuiltinType(typeName)) {
+            while(!isBuiltinType(typeName) || typeDef.$emtpyMapType) {
               typeDef = csnUtils.artifactRef(typeName, typeName);
               if(typeDef !== typeName) {
                 // Implementation note: For `type S: T:struct;`, elements from `T:struct` were already propagated to `S`.

package/lib/transform/transformUtils.js

@@ -1332,14 +1332,14 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
 
       function isScalarOrNoType(art) {
         art = effectiveType(art);
-        if(art) {
-          const type = art.type || (art.items && art.items.type);
-          // items in ON conds are illegal but this should be checked elsewhere
+        if (art) {
+          const type = art.type || art.items?.type;
+          // items in ON-conditions are illegal but this should be checked elsewhere
           const elements = art.elements || (art.items && art.items.elements);
           // @Core.Computed has no type
-          return(!elements && !type ||
-          (type && isBuiltinType(type) &&
-           !['cds.Association', 'cds.Composition'].includes(type)))
+          return (!elements && !type ||
+            (type && isBuiltinType(type) &&
+              type !== 'cds.Association' && type !== 'cds.Composition' && type !== 'cds.Map'))
         }
         return false;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",