@sap/cds-compiler 5.1.2 → 5.2.0

package/lib/compiler/xpr-rewrite.js

@@ -355,7 +355,7 @@ function xprRewriteFns( model ) {
     // On select items, use navigation elements or table alias
     // TODO: Expand/inline paths don't have a `_navigation` property on their last
     //       path step, yet.  We need to implement expand/inline.
-    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._pathHead;
+    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._columnParent;
     if (isSimpleSelectItem) {
       const isSelfPath = (expr.path[0]?._navigation?.kind === '$self');
       if (isSelfPath) {
@@ -665,8 +665,9 @@ function xprRewriteFns( model ) {
     }
 
     const item = expr.path[index];
-    // Not a query -> no $navElement -> use `elements`
-    if (!env.query && env.kind !== 'select') {
+    // If the artifact is already in the same definition, we must not check the query.
+    // Or if it is not a query -> no $navElement -> use `elements`
+    if (item._artifact._main === env || !env.query && env.kind !== 'select') {
       if (env.elements?.[item.id])
         return [ env.elements[item.id], index ];
       return [ null, expr.path.length ];

package/lib/edm/annotations/genericTranslation.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isEdmPropertyRendered, transformExpression } = require('../../model/csnUtils');
+const { isEdmPropertyRendered, transformAnnotationExpression } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
@@ -131,7 +131,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           const knownAnnos = filterKnownAnnotations(carrier);
           knownAnnos.forEach((pn) => {
             scopeCheck.anno = pn;
-            transformExpression(carrier, pn, scopeCheck, carrier.$path);
+            transformAnnotationExpression(carrier, pn, scopeCheck, carrier.$path);
           });
         });
       }
@@ -141,7 +141,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       const knownAnnos = filterKnownAnnotations(obj);
       knownAnnos.forEach((pn) => {
         scopeCheck.anno = pn;
-        transformExpression(obj, pn, scopeCheck, obj.$path);
+        transformAnnotationExpression(obj, pn, scopeCheck, obj.$path);
       });
     };
     if (def.$isParamEntity && def._origin) {
@@ -171,7 +171,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
               if (innerAnnotation)
                 newAnno += `.@${innerAnnotation}`;
               edmUtils.assignAnnotation(def, newAnno, def._origin[attr]);
-              transformExpression(def._origin, attr, scopeCheck, def._origin.$path);
+              transformAnnotationExpression(def._origin, attr, scopeCheck, def._origin.$path);
               if (paramAnnoParts.length > 1)
                 delete def._origin[attr];
             }
@@ -419,7 +419,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     knownAnnos.forEach((knownAnno) => {
       if (knownAnno.search(/\.\$edmJson\./g) < 0) {
-        transformExpression(carrier, knownAnno, {
+        transformAnnotationExpression(carrier, knownAnno, {
           ref: (elemref, prop, xpr, csnPath) => {
             if (options.isV2() && elemref.$bparam) {
               error('odata-anno-xpr-ref', ctx.location, {
@@ -842,8 +842,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
      * */
     let newAnno;
     const omissions = { 'Aggregation.default': 1 };
-    const nullList = { 'Core.OperationAvailable': 1 };
-    if (annoValue !== null && !omissions[termName] || nullList[termName]) {
+    const nullList = { 'Core.OperationAvailable': 1, 'Core.OptionalParameter': 1 };
+    if (annoValue != null && !omissions[termName] || nullList[termName]) {
     // termName may contain a qualifier: @UI.FieldGroup#shippingStatus
     // -> remove qualifier from termName and set Qualifier attribute in newAnno
       const i = termName.indexOf('#');
@@ -989,6 +989,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     else {
       const res = handleSimpleValue(cAnnoValue, dTypeName, msg);
       if (((oTermName === 'Core.OperationAvailable' && dTypeName === 'Edm.Boolean') ||
+        (oTermName === 'Core.OptionalParameter' && dTypeName === 'Edm.String') ||
         (oTermName === 'Validation.AllowedValues' && dTypeName === 'Edm.PrimitiveType')) &&
         cAnnoValue === null) {
         oTarget.append(new Edm.ValueThing(v, 'Null'));
@@ -1230,7 +1231,10 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       }
     }
     else if (value === null) {
-      if ((resolvedType == null || resolvedType === 'Edm.PrimitiveType') && typeName === 'String') {
+      if ((resolvedType == null ||
+           resolvedType === 'Edm.PrimitiveType' ||
+           resolvedType === 'Edm.String') &&
+           typeName === 'String') {
         resolvedType = 'Edm.String';
       }
       else {
@@ -1589,7 +1593,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
   function filterKnownAnnotations( carrier ) {
     const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
-    const nullWhitelist = [ '@Core.OperationAvailable' ];
+    const nullWhitelist = [ '@Core.OperationAvailable', '@Core.OptionalParameter.DefaultValue' ];
     const knownAnnosP = annoNames.filter((n) => {
       const tns = whatsMyTermNamespace(n);
       return tns &&

package/lib/edm/csn2edm.js

@@ -266,8 +266,19 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         });
       }
     });
+    if (!options.odataNoCreator) {
+      // remove unqualified @Core.Links and #CAP
+      Object.keys(serviceCsn).forEach((key) => {
+        if (key === '@Core.Links' || key.startsWith('@Core.Links.') ||
+            key === '@Core.Links#CAP' || key.startsWith('@Core.Links#CAP.'))
+          delete serviceCsn[key];
+      });
+    }
+
     // Create annotations and distribute into Schemas, merge vocabulary cross refs into xServiceRefs
-    addAnnotations2XServiceRefs();
+    addAnnotationsAndXServiceRefs();
+    if (!options.odataNoCreator)
+      LeadSchema.prepend(waterMark());
 
     // Finally add cross service references into the EDM and extract the targetSchemaNames
     // for the type cross check
@@ -308,6 +319,18 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     return edm;
 
+    function waterMark() {
+      const rel = new Edm.PropertyValue(v, 'rel');
+      rel._xmlOnlyAttributes.String = 'author';
+      rel._jsonOnlyAttributes['Edm.String'] = 'author';
+      const href = new Edm.PropertyValue(v, 'href');
+      href._xmlOnlyAttributes.String = 'https://cap.cloud.sap';
+      href._jsonOnlyAttributes['Edm.String'] = 'https://cap.cloud.sap';
+      const watermark = new Edm.Annotation(v, 'Core.Links', new Edm.Collection(v, new Edm.Record(v, rel, href)));
+      // watermark._edmAttributes['Qualifier'] = 'CAP';
+      return watermark;
+    }
+
     // Sort definitions into their schema container
     function populateSchemas( schemas ) {
       forEach(reqDefs.definitions, ( fqName, art ) => {
@@ -1099,8 +1122,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
     }
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
-    function addAnnotations2XServiceRefs( ) {
+    function addAnnotationsAndXServiceRefs( ) {
       options.getFinalTypeInfo = csnUtils.getFinalTypeInfo;
+
       const { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csnUtils, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema

package/lib/edm/edm.js

@@ -111,8 +111,7 @@ function getEdm( options, messageFunctions ) {
         json.$Kind = this.kind;
 
       this.toJSONattributes(json);
-      this.toJSONchildren(json);
-      return json;
+      return this.toJSONchildren(json);
     }
 
     // virtual
@@ -131,6 +130,7 @@ function getEdm( options, messageFunctions ) {
       this._children.filter(c => c._edmAttributes.Name).forEach((c) => {
         json[c._edmAttributes.Name] = c.toJSON();
       });
+      return json;
     }
 
     // virtual
@@ -325,7 +325,12 @@ function getEdm( options, messageFunctions ) {
 
     toJSONchildren(json) {
       // 'edmx:DataServices' should not appear in JSON
-      super.toJSONchildren(json);
+      // Annotations first
+      this._children.filter(c => c._edmAttributes.Term).forEach((c) => {
+        json = { ...json, ...c.toJSON() };
+      });
+
+      json = super.toJSONchildren(json);
       if (this._annotations.length > 0) {
         this._annotations.filter(a => a._edmAttributes.Term).forEach((a) => {
           Object.entries(a.toJSON()).forEach(([ n, v ]) => {
@@ -445,8 +450,7 @@ function getEdm( options, messageFunctions ) {
         json.$Reference = referenceJson;
 
       this._service.toJSONattributes(json);
-      this._service.toJSONchildren(json);
-      return json;
+      return this._service.toJSONchildren(json);
     }
 
     // all(default), metadata, annotations
@@ -1154,8 +1158,7 @@ function getEdm( options, messageFunctions ) {
     toJSON() {
       const json = Object.create(null);
       this.toJSONattributes(json);
-      this.toJSONchildren(json);
-      return json;
+      return this.toJSONchildren(json);
     }
 
     getConstantExpressionValue() {
@@ -1226,6 +1229,7 @@ function getEdm( options, messageFunctions ) {
           json[n] = v;
         });
       });
+      return json;
     }
   }
 
@@ -1242,8 +1246,9 @@ function getEdm( options, messageFunctions ) {
   // since it was discovered, that in JSON the EnumMember type must be
   // transported this is no longer the case....
   class Annotation extends AnnotationBase {
-    constructor(version, termName) {
+    constructor(version, termName, ...children) {
       super(version, { Term: termName } );
+      this.append(...children);
     }
 
     toJSON() {
@@ -1263,6 +1268,11 @@ function getEdm( options, messageFunctions ) {
   }
 
   class Collection extends AnnotationBase {
+    constructor(version, ...children) {
+      super(version);
+      this.append(...children);
+    }
+
     toJSON() {
       // EDM JSON doesn't mention annotations on collections
       return this._children.map(a => a.toJSON());
@@ -1270,6 +1280,10 @@ function getEdm( options, messageFunctions ) {
   }
 
   class Record extends AnnotationBase {
+    constructor(version, ...children) {
+      super(version);
+      this.append(...children);
+    }
     toJSONattributes(json) {
       if (this._jsonOnlyAttributes.Type)
         json['@type'] = this._jsonOnlyAttributes.Type;
@@ -1300,6 +1314,7 @@ function getEdm( options, messageFunctions ) {
             error(null, `Pease debug me: Unhandled Record child: ${c.kind}`);
         }
       });
+      return json;
     }
   }
 

package/lib/edm/edmInboundChecks.js

@@ -3,7 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
   forEachDefinition, forEachMemberRecursively, getUtils,
-  transformExpression, findAnnotationExpression,
+  transformAnnotationExpression,
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { assignAnnotation } = require('./edmUtils.js');
@@ -144,14 +144,12 @@ function inboundQualificationChecks( csn, options, messageFunctions,
                 parent.$bparam = true;
             },
           };
-          let exprAnnos = Object.keys(action).filter(pn => findAnnotationExpression(action, pn));
-          exprAnnos.forEach((pn) => {
-            transformExpression(action, pn, markBindingParam, loc);
+          Object.keys(action).filter(pn => pn[0] === '@').forEach((pn) => {
+            transformAnnotationExpression(action, pn, markBindingParam, loc);
           });
           forEachMemberRecursively(action, (member, _memberName, _prop, path, _parent) => {
-            exprAnnos = Object.keys(member).filter(pn => findAnnotationExpression(member, pn));
-            exprAnnos.forEach((pn) => {
-              transformExpression(member, pn, markBindingParam, path);
+            Object.keys(member).filter(pn => pn[0] === '@').forEach((pn) => {
+              transformAnnotationExpression(member, pn, markBindingParam, path);
             });
           }, loc);
         }

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];