@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/edm/annotations/edmJson.js

@@ -7,8 +7,8 @@ const {
   EdmTypeFacetNames,
   EdmPrimitiveTypeMap,
 } = require('../EdmPrimitiveTypeDefinitions.js');
-const { mapCdsToEdmType } = require('../edmUtils.js');
-const { isBuiltinType } = require('../../model/csnUtils');
+const { isBuiltinType, isAnnotationExpression } = require('../../model/csnUtils');
+const { transformExpression } = require('../../transform/db/applyTransformations.js');
 
 /**
  * Translate a given token stream expression into an edmJson representation
@@ -77,9 +77,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Error transformer
-  const notADynExpr = (parent, op, xpr, parentparent, parentprop, txt) => {
+  const notADynExpr = (parent, op, xpr, csnPath, parentparent, parentprop, txt) => {
     error('odata-anno-xpr', location, {
-      anno, op: txt ??= op, '#': 'notadynexpr',
+      anno, op: txt ?? op, '#': 'notadynexpr',
     });
     delete parent[op];
   };
@@ -93,27 +93,27 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     //----------------------------------
     // operators not supported as dynamic expression
     '.': notADynExpr,
-    isNull: (p, o) => notADynExpr(p, o, null, null, null, 'is null'),
-    isNotNull: (p, o) => notADynExpr(p, o, null, null, null, 'is not null'),
+    isNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is null'),
+    isNotNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is not null'),
     exists: notADynExpr,
     '#': notADynExpr,
     SELECT: notADynExpr,
-    SET: (p, o) => notADynExpr(p, o, null, null, null, 'UNION'),
+    SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
     like: notADynExpr,
     new: notADynExpr,
   };
 
   //----------------------------------
   // list is a $Collection => []
-  transform.list = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.list = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     parentparent[parentprop] = xpr.filter(a => a);
-    applyTransformations(parentparent, transform);
+    transformExpression(parentparent, parentprop, transform);
   };
   // XPR
-  transform.xpr = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.xpr = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     // eliminate 'xpr' node by pulling up xpr node to its parent
     parentparent[parentprop] = xpr;
-    applyTransformations(parentparent, transform);
+    transformExpression(parentparent, parentprop, transform);
   };
   //----------------------------------
   // CASE
@@ -144,12 +144,14 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       curIf.$If.push(caseExpr[i]);
     parent.$If = edmIf.$If;
     delete parent.case;
-    applyTransformations(parent, transform);
+    transformExpression(parent, undefined, transform);
+  };
+  transform.$If = (_parent, _prop, expr) => {
+    transformExpression(expr, undefined, transform);
   };
-  transform.$If = noOp;
   //----------------------------------
   // Cast => $Cast
-  transform.cast = (parent, prop, castExpr, parentparent, parentprop) => {
+  transform.cast = (parent, prop, castExpr, csnPath, parentparent, parentprop) => {
     const csnType = castExpr[0];
     // try to resolve to final scalar base type and use that instead of derived type
     if (!isBuiltinType(csnType.type)) {
@@ -161,7 +163,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         });
       }
     }
-    const edmTypeName = mapCdsToEdmType(csnType, messageFunctions, options.isV2(), false, location);
+    const edmTypeName = edmUtils.mapCdsToEdmType(csnType, messageFunctions, options.isV2(), false, location);
     const typeFunc = { func: 'Type', args: [ { val: edmTypeName } ] };
     const castFunc = { func: '$Cast', args: [ typeFunc, castExpr[1] ] };
 
@@ -184,7 +186,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
 
     parentparent[parentprop] = castFunc;
-    applyTransformations(parentparent, transform);
+    transformExpression(parentparent, parentprop, transform);
   };
   //----------------------------------
   const evalArgs = (argDef, args, propName) => {
@@ -220,7 +222,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ exact }, xpr, prop);
     parent[opStr] = xpr;
     delete parent[prop];
-    applyTransformations(parent, transform);
+    transformExpression(parent, undefined, transform);
   };
   //----------------------------------
   // LOGICAL
@@ -249,12 +251,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ min: 1 }, xpr[1].list, prop);
     parent.$In = [ xpr[0], ...xpr[1].list ];
     delete parent[prop];
-    applyTransformations(parent, transform);
+    transformExpression(parent, undefined, transform);
   };
   transform.$In = noOp;
-  transform.between = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.between = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     evalArgs({ exact: 2 }, xpr.slice(1), prop);
-    applyTransformations(xpr, transform);
+    transformExpression(xpr, undefined, transform);
     delete parent[prop];
     parentparent[parentprop]
     = {
@@ -264,22 +266,22 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         ],
       };
   };
-  transform['||'] = (parent, prop, xpr, parentparent, parentprop) => {
+  transform['||'] = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     evalArgs({ exact: 2 }, xpr, prop);
-    applyTransformations(xpr, transform);
+    transformExpression(xpr, undefined, transform);
     delete parent[prop];
     parentparent[parentprop].$Apply = [ { $Function: 'odata.concat' }, ...xpr ];
   };
   //----------------------------------
   // ARITHMETICAL AND UNARY
-  transform['+'] = (parent, prop, xpr, parentparent, parentprop) => {
+  transform['+'] = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     if (Array.isArray(xpr)) {
       op('$Add')(parent, prop, xpr);
     }
     else {
       delete parent[prop];
       parentparent[parentprop] = xpr;
-      applyTransformations(parentparent, transform);
+      transformExpression(parentparent, parentprop, transform);
     }
   };
   transform.$Add = noOp;
@@ -295,13 +297,13 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   // $DivBy, $Mod are functions
   //----------------------------------
   // LITERALS
-  transform.val = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.val = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     if (xpr === null)
       parent.$Null = true;
     else
       parentparent[parentprop] = xpr;
   };
-  transform.ref = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.ref = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     if (xpr.some(ps => ps.args || ps.where)) {
       error('odata-anno-xpr-args', location, {
         anno, elemref: parent, '#': 'wrongref',
@@ -311,7 +313,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Functions
-  transform.func = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.func = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     const rewriteArgs = (argDefs, evalVal = true) => {
       Object.entries(argDefs).forEach(([ argName, argDef ]) => {
         const [ foundProps, newArgs ]
@@ -590,7 +592,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       delete parent.args;
     };
 
-    const exactArgs = (tgt = parent, x = xpr, count) => {
+    const exactArgs = (tgt = parent, x = xpr, count = undefined) => {
       standard(tgt, x);
       evalArgs({ exact: count }, tgt[x], xpr);
     };
@@ -694,7 +696,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       // $Record ???
       $Collection: () => {
         standard(parentparent, parentprop);
-        applyTransformations(parentparent, transform);
+        transformExpression(parentparent, parentprop, transform);
       },
       $Path: () => {
         oneArg(parent, xpr);
@@ -704,7 +706,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             anno, op: `${xpr}(…)`, meta: 'string', '#': 'wrongval_meta',
           });
         }
-        applyTransformations(parentparent, transform);
+        transformExpression(parentparent, parentprop, transform);
       },
       $Null: () => {
         parent[xpr] = true;
@@ -724,7 +726,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         funcDef.forEach(f => f());
       else
         funcDef();
-      applyTransformations(parent, transform);
+      transformExpression(parent, undefined, transform);
     }
     else {
       const funcName = xpr.startsWith('odata.') ? xpr : `odata.${xpr}`;
@@ -740,7 +742,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
           parentparent[parentprop].$Apply = [ { $Function: funcName }, ...(parent.args || []) ];
           delete parentparent[parentprop].func;
           delete parentparent[parentprop].args;
-          applyTransformations(parentparent, transform);
+          transformExpression(parentparent, parentprop, transform);
         }
       }
       else {
@@ -752,41 +754,14 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     delete parent[prop];
   };
 
-  return applyTransformations({ annoVal }, {
-    '=': (parent, prop, xpr, parentparent, parentprop) => {
-      delete parent['='];
-      parentparent[parentprop] = applyTransformations({ $edmJson: parseExpr( parent, { array: false }) }, transform);
-    },
-  }).annoVal;
-
-  function applyTransformations( parent, customTransformers ) {
-    function standard( _parent, _prop, node ) {
-      if (!node || typeof node !== 'object' ||
-          !{}.propertyIsEnumerable.call( _parent, _prop ) ||
-          (typeof _prop === 'string' && _prop.startsWith('@')))
-        return;
-
-
-      if (Array.isArray(node)) {
-        node.forEach( (n, i) => standard( node, i, n ) );
+  return transformExpression(carrier, anno, {
+    '=': (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+      if (isAnnotationExpression(parent)) {
+        delete parent['='];
+        parentparent[parentprop] = transformExpression({ $edmJson: parseExpr( parent, { array: false }) }, undefined, transform);
       }
-      else {
-        for (const name of Object.getOwnPropertyNames( node )) {
-          const ct = customTransformers[name];
-          if (ct) {
-            if (Array.isArray(ct))
-              ct.forEach(cti => cti(node, name, node[name], _parent, _prop));
-            else
-              ct(node, name, node[name], _parent, _prop);
-          }
-          standard(node, name, node[name]);
-        }
-      }
-    }
-    for (const name of Object.getOwnPropertyNames( parent ))
-      standard( parent, name, parent[name] );
-    return parent;
-  }
+    },
+  });
 }
 
 // Not everything that can occur in OData annotations can be expressed with

package/lib/edm/annotations/genericTranslation.js

@@ -302,10 +302,10 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       if (knownAnnos.length === 0)
         return;
     }
-    if (isBetaEnabled(options, 'annotationExpressions')) {
+    if (isBetaEnabled(options, 'odataAnnotationExpressions')) {
       knownAnnos.forEach((knownAnno) => {
         if (knownAnno.search(/\.\$edmJson\./g) < 0)
-          carrier[knownAnno] = xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
+          xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
       });
     }
 
@@ -676,7 +676,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
 
         // anno is the full <Annotation Term=...>
         const anno = handleTerm(fullTermName, prefixTree[voc][term], msg);
-        if (anno !== undefined) {
+        if (!anno?.$isInvalid) {
           // addAnnotationFunc needs AppliesTo message from dictionary to decide where to put the anno
           const termName = fullTermName.replace(/#(\w+)$/g, ''); // remove qualifier
           const dictTerm = getDictTerm(termName, msg); // message for unknown term was already issued in handleTerm
@@ -835,14 +835,16 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       }
       else if ( Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
         // object consists only of properties starting with "@", no $value
+        setProp(oTarget, '$isInvalid', true);
         message('odata-anno-value', msg.location,
                 { anno: msg.anno(), str: 'base', '#': 'nested' } );
       }
       else {
         // regular record
         if (dTypeIsACollection) {
-          message('odata-anno-value', msg.location,
-                  { anno: msg.anno(), str: 'structured', '#': 'incompval' });
+          message('odata-anno-value', msg.location, {
+            anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'incompval',
+          });
         }
         oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, dTypeIsACollection, msg));
       }
@@ -1100,8 +1102,15 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       }
     }
 
-    if ( [ 'Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(resolvedType) )
-      resolvedType = resolvedType.split('.')[1];
+    if ( EdmPathTypeMap[resolvedType] ) {
+      if (resolvedType === 'Edm.AnyPropertyPath') {
+        resolvedType = 'PropertyPath';
+        typeName = resolvedType;
+      }
+      else {
+        resolvedType = resolvedType.split('.')[1];
+      }
+    }
 
     return {
       name: typeName,
@@ -1139,8 +1148,17 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       actualTypeName = obj.$Type;
       if (!getDictType(actualTypeName)) {
         // this type doesn't exist
-        message('odata-anno-type', msg.location,
-                { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
+        if (typeof actualTypeName !== 'string') {
+          actualTypeName = JSON.stringify(obj.$Type);
+          message('odata-anno-type', msg.location,
+                  {
+                    anno: msg.anno(), code: '$Type', rawvalue: actualTypeName, '#': 'literal',
+                  });
+        }
+        else {
+          message('odata-anno-type', msg.location,
+                  { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
+        }
         // explicitly mentioned type, render in XML and JSON
         newRecord.setXml({ Type: actualTypeName });
         // unknown dictionary type: can't fully qualify it

package/lib/edm/annotations/preprocessAnnotations.js

@@ -40,11 +40,10 @@ function preprocessAnnotations( csn, serviceName, options ) {
     const keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
     if (keyNames.length === 0) {
       keyNames.push('MISSING');
-      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'nokey' },
-              'target $(NAME) has no key');
+      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'nokey' } );
     }
     else if (keyNames.length > 1) {
-      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'multkeys' });
+      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'multkeys' });
     }
 
     return keyNames[0];

package/lib/edm/csn2edm.js

@@ -14,7 +14,6 @@ const {
   cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType, getUtils,
 } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { makeMessageFunction } = require('../base/messages');
 const {
   EdmTypeFacetMap,
   EdmTypeFacetNames,
@@ -23,21 +22,34 @@ const {
 const { getEdm } = require('./edm.js');
 
 /*
-OData V2 spec 06/01/2017 PDF version is available from here:
+OData V2 spec 06/01/2017 PDF version is available here:
 https://msdn.microsoft.com/en-us/library/dd541474.aspx
 */
 
-function csn2edm( _csn, serviceName, _options ) {
-  return csn2edmAll(_csn, _options, [ serviceName ])[serviceName];
+/**
+ * @param {CSN.Model} _csn
+ * @param {string} serviceName
+ * @param {CSN.Options} _options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @return {any}
+ */
+function csn2edm( _csn, serviceName, _options, messageFunctions ) {
+  return csn2edmAll(_csn, _options, [ serviceName ], messageFunctions)[serviceName];
 }
 
-function csn2edmAll( _csn, _options, serviceNames = undefined ) {
+/**
+ * @param {CSN.Model} _csn
+ * @param {CSN.Options} _options
+ * @param {string[]|undefined} serviceNames
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @return {any}
+ */
+function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
   // get us a fresh model copy that we can work with
   const csn = cloneCsnNonDict(_csn, _options);
   const special$self = !csn?.definitions?.$self && '$self';
+  messageFunctions.setModel(csn);
 
-  // use original options for messages; cloned CSN for semantic location
-  const messageFunctions = makeMessageFunction(csn, _options, 'to.edmx');
   const {
     info, warning, error, message, throwWithError,
   } = messageFunctions;
@@ -477,7 +489,10 @@ function csn2edmAll( _csn, _options, serviceNames = undefined ) {
         const type = `${schema.name}.${EntityTypeName}`;
         if (properties.length === 0)
           warning(null, location, { type }, 'EDM EntityType $(TYPE) has no properties');
-        else if (entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
+        // only if this entity has an entity set, it is required to have a key
+        // this especially covers: 'items: composition of one { data : String; }'
+        // "keyless" composition targets in structured containment mode
+        else if (entityCsn.$hasEntitySet && entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
           message('odata-spec-violation-no-key', location);
 
         if (!edmUtils.isODataSimpleIdentifier(EntityTypeName))
@@ -627,15 +642,17 @@ function csn2edmAll( _csn, _options, serviceNames = undefined ) {
             else if (isEdmPropertyRendered(elementCsn, options)) {
             // CDXCORE-CDXCORE-173
             // V2: filter  @Core.MediaType
-              if ( options.isV2() && elementCsn['@Core.MediaType']) {
+              if (options.isV2() && elementCsn['@Core.MediaType']) {
                 hasStream = elementCsn['@Core.MediaType'];
-                delete elementCsn['@Core.MediaType'];
+                elementCsn['@cds.api.ignore'] = true;
                 // CDXCORE-CDXCORE-177:
                 // V2: don't render element but add attribute 'm:HasStream="true' to EntityType
-                // V4: render property type 'Edm.Stream'
                 streamProps.push(elementName);
               }
               else {
+                // V4: render property type 'Edm.Stream' but don't add '@Core.IsURL'
+                if ( elementCsn['@Core.MediaType'])
+                  delete elementCsn['@Core.IsURL'];
                 collectUsedType(elementCsn);
                 props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
               }

package/lib/edm/edmInboundChecks.js

@@ -2,8 +2,9 @@
 
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
-  forEachDefinition, forEachMemberRecursively,
+  forEachDefinition, forEachMemberRecursively, isBuiltinType, getUtils,
 } = require('../model/csnUtils');
+const { assignAnnotation } = require('./edmUtils.js');
 
 // eslint-disable-next-line no-unused-vars
 function resolveForeignKeyRefs( csn, csnUtils ) {
@@ -22,9 +23,11 @@ function resolveForeignKeyRefs( csn, csnUtils ) {
 
 function inboundQualificationChecks( csn, options, messageFunctions,
                                      serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils ) {
-  const { message, throwWithError } = messageFunctions;
+  const { message, warning, throwWithError } = messageFunctions;
 
-  forEachDefinition(csn, [ attach$path, checkProperArrayUsage ]);
+  const { getFinalTypeInfo } = getUtils(csn);
+
+  forEachDefinition(csn, [ attach$path, onServiceMember ]);
   checkNestedContextsAndServices();
   throwWithError();
 
@@ -37,27 +40,67 @@ function inboundQualificationChecks( csn, options, messageFunctions,
                              }, [ 'definitions', defName ]);
   }
 
-  function checkProperArrayUsage( def, defName ) {
+  // code that should be run only on service members
+  function onServiceMember( def, defName ) {
     if (!isMyServiceRequested(defName))
       return;
-    const currPath = [ 'definitions', defName ];
-    checkIfItemsOfItems(def, undefined, undefined, currPath);
-    forEachMemberRecursively(def, checkIfItemsOfItems, currPath);
-
-    function checkIfItemsOfItems( construct, _constructName, _prop, path ) {
-      const constructType = csnUtils.effectiveType(construct);
-      if (constructType.items) {
-        if (constructType.items.target) {
-          const isComp = constructType.items.type === 'cds.Composition';
+
+    const location = [ 'definitions', defName ];
+    // check items.items
+    checkIfItemsOfItems(def, undefined, undefined, location);
+    forEachMemberRecursively(def, checkIfItemsOfItems, location);
+
+    // decorate UUID keys with @Core.ComputedDefaultValue and complain
+    // on named type UUID elements that have no such annotation
+    const anno = '@Core.ComputedDefaultValue';
+    if (def.kind === 'entity' && def.elements) {
+      Object.entries(def.elements).forEach(([ eltName, elt ]) => {
+        if (elt.key)
+          addCoreComputedDefaultValueOnUUIDKeys(elt, [ eltName ], location);
+      });
+    }
+
+    function addCoreComputedDefaultValueOnUUIDKeys( elt, eltPath, path ) {
+      let type = elt.items?.type || elt.type;
+      if (type && !isBuiltinType(type)) {
+        type = getFinalTypeInfo(type);
+        if (!isBuiltinType(type.type))
+          path = [ 'definitions', type.type ];
+      }
+      else {
+        type = elt;
+      }
+
+      if (type.type === 'cds.UUID' && elt['@odata.foreignKey4'] == null) {
+        if (path[1] === defName)
+          assignAnnotation(elt, anno, true);
+        else if (elt[anno] == null)
+          warning('odata-key-uuid-default-anno', path, { type: type.type, anno, id: `${defName}:${eltPath.join('.')}` });
+      }
+      else {
+        const elements = type.items?.elements || type.elements;
+        if (elements) {
+          Object.entries(elements).forEach(([ eltName, subelt ]) => {
+            addCoreComputedDefaultValueOnUUIDKeys(subelt, [ ...eltPath, eltName ], [ ...path, 'elements', eltName ]);
+          });
+        }
+      }
+    }
+
+    function checkIfItemsOfItems( member, _memberName, _prop, path ) {
+      const memberType = csnUtils.effectiveType(member);
+      if (memberType.items) {
+        if (memberType.items.target) {
+          const isComp = memberType.items.type === 'cds.Composition';
           message('type-invalid-items', path, { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
           return;
         }
-        if (constructType.items.items) {
+        if (memberType.items.items) {
           message('chained-array-of', path);
           return;
         }
 
-        const itemsType = csnUtils.effectiveType(constructType.items);
+        const itemsType = csnUtils.effectiveType(memberType.items);
         if (itemsType.items)
           message('chained-array-of', path);
       }

package/lib/edm/edmPreprocessor.js

@@ -5,7 +5,7 @@ const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model')
 const {
   forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isEdmPropertyRendered, getUtils, cloneCsnNonDict,
-  isBuiltinType, applyTransformations, cloneAnnotationValue, cardinality2str,
+  isBuiltinType, applyTransformations, cloneAnnotationValue, cardinality2str, isAnnotationExpression,
 } = require('../model/csnUtils');
 const edmUtils = require('./edmUtils.js');
 const edmAnnoPreproc = require('./edmAnnoPreprocessor.js');
@@ -97,7 +97,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
   */
   if (csn.meta && csn.meta.options && csn.meta.options.odataVersion === 'v4' && options.isV2()) {
     // eslint-disable-next-line global-require
-    const { toFinalBaseType } = require('../transform/transformUtils').getTransformers(csn, options);
+    const { toFinalBaseType } = require('../transform/transformUtils').getTransformers(csn, options, messageFunctions);
     expandCSNToFinalBaseType(csn, { toFinalBaseType }, csnUtils, serviceRootNames, options);
   }
 
@@ -168,7 +168,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         initEdmNavPropBindingTargets,
         pullupCapabilitiesAnnotations,
         annotateOptionalActFuncParams,
-        openService,
       ]);
     }
 
@@ -722,11 +721,11 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       // FK creation.
       // The FK creation already propagates the annotations from the association
       const elements = construct.items && construct.items.elements || construct.elements;
-      const fk = elements[element['@odata.foreignKey4']];
-      for (const attrName in fk) {
-        const attr = fk[attrName];
-        if (attrName[0] === '@')
-          edmUtils.assignAnnotation(element, attrName, attr);
+      const assoc = elements[element['@odata.foreignKey4']];
+      if (assoc) {
+        Object.keys(assoc).filter(pn => pn[0] === '@' && !isAnnotationExpression(assoc[pn])).forEach((pn) => {
+          edmUtils.assignAnnotation(element, pn, assoc[pn]);
+        });
       }
       // and eventually remove some afterwards
       if (options.isV2())
@@ -1075,8 +1074,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
     function muteNavProp( elt, msg = 'std' ) {
       edmUtils.assignAnnotation(elt, '@odata.navigable', false);
-      warning('odata-navigation', [ 'definitions', struct.name, 'elements', elt.name ],
-              { target: elt._target.name, service: globalSchemaPrefix, '#': msg });
+      if (elt._target['@cds.autoexpose'] !== false) {
+        warning('odata-navigation', [ 'definitions', struct.name, 'elements', elt.name ],
+                { target: elt._target.name, service: globalSchemaPrefix, '#': msg });
+      }
     }
 
     function createSchemaRefFor( targetSchemaName ) {
@@ -2125,7 +2126,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             optPns.forEach((op) => {
               const type = op.items?.type || op.type;
               if (type !== special$self)
-                warning('odata-parameter-order', location.concat(op.name));
+                error('odata-parameter-order', location.concat(op.name));
             });
             optPns = [];
           }
@@ -2134,11 +2135,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     }
   }
 
-  function openService( def ) {
-    if (options.odataOpenType && !def.$isParamEntity && !def.$proxy)
-      edmUtils.assignAnnotation(def, '@open', true);
-  }
-
   // ////////////////////////////////////////////////////////////////////
   //
   // Helper section starts here

package/lib/edm/edmUtils.js

@@ -551,8 +551,11 @@ function mapCdsToEdmType( csn, messageFunctions, isV2 = false, isMediaType = fal
     Edm.GeometryCollection
     */
   }[cdsType];
-  if (!edmType)
-    error(null, location, { type: cdsType }, 'No EDM type available for $(TYPE)');
+  if (!edmType) {
+    error('ref-unsupported-type', location, { type: cdsType, '#': 'odata' });
+    edmType = 'Edm.PrimitiveType';
+  }
+
 
   if (isV2) {
     if (edmType === 'Edm.Date')

package/lib/gen/Dictionary.json

@@ -801,6 +801,13 @@
         "Parameter"
       ]
     },
+    "Common.ValueListShowValuesImmediately": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "Annotation"
+      ],
+      "$experimental": true
+    },
     "Common.ValueListForValidation": {
       "Type": "Edm.String",
       "AppliesTo": [
@@ -2069,6 +2076,8 @@
       "Type": "Validation.ConstraintType",
       "AppliesTo": [
         "Property",
+        "NavigationProperty",
+        "Parameter",
         "EntityType",
         "ComplexType"
       ]
@@ -2956,6 +2965,7 @@
     "Common.IntervalType": {
       "$kind": "ComplexType",
       "Properties": {
+        "Label": "Edm.String",
         "LowerBoundary": "Edm.PropertyPath",
         "LowerBoundaryIncluded": "Edm.Boolean",
         "UpperBoundary": "Edm.PropertyPath",