@sap/cds-compiler 5.1.0 → 5.2.0

package/lib/edm/edmPreprocessor.js

@@ -5,7 +5,7 @@ const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model')
 const {
   forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isEdmPropertyRendered, getUtils,
-  applyTransformations, transformExpression, findAnnotationExpression,
+  applyTransformations, transformAnnotationExpression, findAnnotationExpression,
   cardinality2str,
 } = require('../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../base/builtins');
@@ -1890,12 +1890,12 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       mapCdsToEdmProp(def.returns);
       annotateAllowedValues(def.returns, [ ...defLocation, 'returns' ]);
     }
-    forEachMemberRecursively(def, (member, _memberName, _prop, location) => {
+    forEachMemberRecursively(def, (member, _memberName, prop, location) => {
       edmUtils.assignAnnotation(member, '@Core.Description', member.doc);
       markCollection(member);
       mapCdsToEdmProp(member);
       annotateAllowedValues(member, location);
-      ComputedDefaultValue(member);
+      ComputedDefaultValue(member, prop, location);
       rewriteAnnotationExpressions(member);
       if (member.returns) {
         edmUtils.assignAnnotation(member.returns, '@Core.Description', member.returns.doc);
@@ -2082,8 +2082,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     parameters appear rightmost.
   */
   function annotateOptionalActFuncParams( def, defName ) {
-    if (!isBetaEnabled(options, 'optionalActionFunctionParameters'))
-      return;
     // return if there is nothing to do
     const loc = [ 'definitions', defName ];
     if (def.kind === 'function' || def.kind === 'action')
@@ -2098,32 +2096,43 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     function iterateParams( action, location ) {
       let optPns = [];
       if (action.params) {
-        Object.values(action.params).forEach((p) => {
+        Object.entries(action.params).forEach(([ pn, p ]) => {
         // user assigned annotation, don't touch it
+          const defT = reqDefs.definitions[p.items?.type || p.type];
+          const isStructType = !!(defT?.items?.elements || defT?.elements);
+          const isItems = !!(p.items || defT?.items);
+
           if (Object.keys(p).some(a => a.startsWith('@Core.OptionalParameter') && p[a] !== null)) {
             optPns.push(p);
           }
           // default value automatically makes param optional
-          else if (p.default) {
-            if (p.default.val)
-              edmUtils.assignAnnotation(p, '@Core.OptionalParameter.DefaultValue', p.default.val);
-            else
+          else if (isBetaEnabled(options, 'optionalActionFunctionParameters')) {
+            if (p.default?.val !== undefined) {
+              if (p.default.val !== null && (isStructType || isItems)) {
+                warning('odata-ignoring-param-default', location.concat(pn), { '#': 'colitem' });
+              }
+              else {
+                edmUtils.assignAnnotation(p, '@Core.OptionalParameter.DefaultValue', p.default.val);
+                optPns.push(p);
+              }
+            }
+            // if no default is available, nullable makes param optional
+            else if (!p.notNull) {
               edmUtils.assignAnnotation(p, '@Core.OptionalParameter.$Type', '');
-            optPns.push(p);
-          }
-          // if no default is available, nullable makes param optional
-          else if (!p.notNull) {
-            edmUtils.assignAnnotation(p, '@Core.OptionalParameter.$Type', '');
-            optPns.push(p);
+              optPns.push(p);
+            }
+            else {
+            // this is a mandatory parameter, warn about all previously collected optional parameters
+              optPns.forEach((op) => {
+                const type = op.items?.type || op.type;
+                if (type !== special$self)
+                  error('odata-parameter-order', location.concat(op.name));
+              });
+              optPns = [];
+            }
           }
-          else {
-          // this is a mandatory parameter, warn about all previously collected optional parameters
-            optPns.forEach((op) => {
-              const type = op.items?.type || op.type;
-              if (type !== special$self)
-                error('odata-parameter-order', location.concat(op.name));
-            });
-            optPns = [];
+          else if (p.default) {
+            warning('odata-ignoring-param-default', location.concat(pn));
           }
         });
       }
@@ -2152,7 +2161,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     }
   }
 
-  function ComputedDefaultValue( member ) {
+  function ComputedDefaultValue( member, prop, location ) {
     if (member.default && !csn['@Core.ComputedDefaultValue']) {
       let def = member.default;
       let noTailExpr = false;
@@ -2166,8 +2175,12 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         def = def.xpr[i];
       }
       // it is a computed value if it is not a simple value or an annotation
-      if (!((def.val !== undefined && !noTailExpr) || def['#']))
-        edmUtils.assignAnnotation(member, '@Core.ComputedDefaultValue', true);
+      if (!((def.val !== undefined && !noTailExpr) || def['#'])) {
+        if (prop === 'params')
+          warning('odata-ignoring-param-default', location, { '#': 'xpr' });
+        else
+          edmUtils.assignAnnotation(member, '@Core.ComputedDefaultValue', true);
+      }
     }
   }
 
@@ -2258,13 +2271,13 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
       xprANames.forEach((xprAName) => {
         isSubTreeSpan = true;
-        transformExpression(carrier, xprAName, subTreeSpan);
+        transformAnnotationExpression(carrier, xprAName, subTreeSpan);
         if (isSubTreeSpan) {
-          transformExpression(carrier, xprAName, relativize);
+          transformAnnotationExpression(carrier, xprAName, relativize);
         }
         else {
           absolutize.scope = scope;
-          transformExpression(carrier, xprAName, absolutize);
+          transformAnnotationExpression(carrier, xprAName, absolutize);
           if (!def[proxyDict])
             setProp(def, proxyDict, Object.create(null));
           let proxyCarrier = def[proxyDict][eltPath];