@sap/cds-compiler 4.9.2 → 5.0.6

package/lib/edm/annotations/genericTranslation.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isEdmPropertyRendered, transformExpression } = require('../../model/csnUtils');
-const { isBuiltinType } = require('../../base/builtins');
+const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
@@ -60,6 +60,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     if (defName.startsWith(`${serviceName}.`))
       assignParameterAnnotations(def);
   });
+
   // Crawl over the csn and trigger the annotation translation for all kinds
   //   of annotated things.
   // Note: only works for single service
@@ -103,6 +104,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     const scopeCheck = {
       ref: (elemref, prop, xpr, path) => {
         if (scopeCheck.scope === 'param' &&
+          !isMagicVariable(xpr[0]) &&
           (!elemref.param ||
            (xpr[0].id || xpr[0]) === '$self' && !def.elements.$self)) {
           error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaparam' });
@@ -221,13 +223,16 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
   function handleDefinition( defName, def, location ) {
     // definition bound annotations
-    handleAnnotations(defName, def, location);
+    handleAnnotations(defName, def, { location });
     // definition bound element annotations
     if (def.$elementsAnnoProxies) {
       Object.entries(def.$elementsAnnoProxies).forEach(([ elemPath, element ]) => {
         const edmTargetName = `${defName}/${elemPath}`;
-        handleAnnotations(edmTargetName, element, element.$path,
-                          [ ...location, '$elementsAnnoProxies', elemPath ]);
+        handleAnnotations(edmTargetName, element,
+                          {
+                            location: element.$path,
+                            csnPath: [ ...location, '$elementsAnnoProxies', elemPath ],
+                          });
       });
     }
     // element bound annotations
@@ -235,7 +240,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       Object.entries(def.elements).forEach(([ elemName, element ]) => {
         const edmTargetName = `${defName}/${elemName}`;
         const eLocation = [ ...location, 'elements', elemName ];
-        handleAnnotations(edmTargetName, element, eLocation);
+        handleAnnotations(edmTargetName, element, { location: eLocation });
       });
     }
     // bound actions
@@ -261,6 +266,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     const entityName = nameParts.pop();
 
     Object.entries(cObject.actions).forEach(([ n, action ]) => {
+      setProp(action, '$isBound', true);
       const actionName = `${serviceName}.${isV2() ? `${entityName}_` : ''}${n}`;
       handleAction(actionName, action, cObjectname, [ ...location, 'actions', n ]);
     });
@@ -273,6 +279,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   //     entityNameIfBound : qualified name of entity if bound action/function
   function handleAction( cActionName, cAction, entityNameIfBound, location ) {
     let actionName = cActionName;
+
     if (isV2()) { // Replace up to last dot with <serviceName>.EntityContainer
       const lastDotIndex = actionName.lastIndexOf('.');
       if (lastDotIndex > -1)
@@ -282,55 +289,70 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       actionName += relParList();
     }
 
-    handleAnnotations(actionName, cAction, location);
+    handleAnnotations(actionName, cAction, { location, cAction });
 
     if (cAction.params) {
       if (cAction.$paramsAnnoProxies) {
         Object.entries(cAction.$paramsAnnoProxies).forEach(([ paramPath, param ]) => {
-          const edmTargetName = `${actionName}/${paramPath}`;
-          handleAnnotations(edmTargetName, param, param.$path,
-                            [ ...location, '$paramsAnnoProxies', paramPath ]);
+          // skip explicit binding parameter in V2
+          if (!(options.isV2() && param.type === '$self' && paramPath === cAction.$bindingParam?.name)) {
+            const edmTargetName = `${actionName}/${paramPath}`;
+            handleAnnotations(edmTargetName, param,
+                              {
+                                location: param.$path,
+                                csnPath: [ ...location, '$paramsAnnoProxies', paramPath ],
+                                cAction,
+                              });
+          }
         });
       }
+      // explicit binding parameter is removed from params in V2 during
+      // createActionV2(), no need to check ;)
       Object.entries(cAction.params).forEach(([ n, p ]) => {
         const edmTargetName = `${actionName}/${n}`;
         handleAnnotations(edmTargetName, p,
-                          [ ...location, 'params', n ]);
+                          {
+                            action: true,
+                            location: [ ...location, 'params', n ],
+                            cAction,
+                          });
       });
     }
     if (cAction.returns) {
       if (cAction.$returnsAnnoProxies) {
         Object.entries(cAction.$returnsAnnoProxies).forEach(([ returnsPath, returns ]) => {
           const edmTargetName = `${actionName}/${returnsPath}`;
-          handleAnnotations(edmTargetName, returns, returns.$path,
-                            [ ...location, '$returnsAnnoProxies', returnsPath ]);
+          handleAnnotations(edmTargetName, returns,
+                            {
+                              location: returns.$path,
+                              csnPath: [ ...location, '$returnsAnnoProxies', returnsPath ],
+                              cAction,
+                            });
         });
       }
       const edmTargetName = `${actionName}/$ReturnType`;
       setProp(cAction.returns, '$appliesToReturnType', true);
       handleAnnotations(edmTargetName, cAction.returns,
-                        [ ...location, 'returns' ]);
+                        {
+                          location: [ ...location, 'returns' ],
+                          cAction,
+                        });
       delete cAction.returns.$appliesToReturnType;
     }
 
     function relParList() {
-    // we rely on the order of params in the csn being the correct one
+      // we rely on the order of params in the csn being the correct one
       const params = [];
       if (entityNameIfBound) {
         // If this is an action and has an explicit binding parameter add it here
-        if (cAction.$bindingParam && cAction.kind === 'action') {
+        if (cAction.$bindingParam && cAction.kind === 'action' ||
+            cAction.$bindingParam?.viaAnno) {
           params.push(
             cAction.$bindingParam.items
               ? `Collection(${entityNameIfBound})`
               : entityNameIfBound
           );
         }
-        // If action/function has no explicit binding parameter add it here
-        else if (!cAction.$bindingParam) {
-          params.push(cAction['@cds.odata.bindingparameter.collection']
-            ? `Collection(${entityNameIfBound})`
-            : entityNameIfBound);
-        }
       }
       // In case this is a function the explicit binding parameter is part of
       // the functions params dictionary. Only for functions all parameters must
@@ -348,12 +370,12 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           return edmUtils.mapCdsToEdmType(p, messageFunctions, false /* is only called for v4 */);
         }
         else if (options.whatsMySchemaName) {
-          const schemaName = options.whatsMySchemaName(p.type);
+          const schemaName = options.whatsMySchemaName(p._edmType || p.type);
           // strip the service namespace of from a parameter type
           if (schemaName && schemaName !== options.serviceName)
-            return p.type.replace(`${options.serviceName}.`, '');
+            return (p._edmType || p.type).replace(`${options.serviceName}.`, '');
         }
-        return p.type;
+        return p._edmType || p.type;
       }
     }
   }
@@ -363,7 +385,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   //   edmTargetName : string, name of the target in edm
   //   carrier: object, the annotated cds thing, contains all the annotations
   //                    as properties with names starting with @
-  function handleAnnotations( edmTargetName, carrier, location, csnPathResolutionLocation = location ) {
+  //   ctx: locations and other information that is required to write the
+  //        annotations
+  function handleAnnotations( edmTargetName, carrier, ctx ) {
     // collect the names of the carrier's annotation properties
     // keep only those annotations that - start with a known vocabulary name
     //                                  - have a value other than null
@@ -377,6 +401,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       (isV2() && (edmUtils.isDerivedType(carrier))))
       return;
 
+    if (ctx.location == null)
+      throw Error('location required');
 
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
@@ -396,15 +422,15 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         transformExpression(carrier, knownAnno, {
           ref: (elemref, prop, xpr, csnPath) => {
             if (options.isV2() && elemref.$bparam) {
-              error('odata-anno-xpr-ref', location, {
-                elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2',
+              error('odata-anno-xpr-ref', ctx.location, {
+                elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2_expl',
               });
               return;
             }
             const { links, scope } = reqDefsUtils.inspectRef(csnPath);
             let i = scope === '$self' ? 1 : 0;
             if (scope === '$magic') {
-              error('odata-anno-xpr-ref', location, {
+              error('odata-anno-xpr-ref', ctx.location, {
                 elemref, anno: knownAnno, '#': 'magic',
               });
               return;
@@ -412,7 +438,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             let stop = false;
             for (; i < links.length && !stop; i++) {
               if (!isEdmPropertyRendered(links[i].art, csnPath)) {
-                error('odata-anno-xpr-ref', location, {
+                error('odata-anno-xpr-ref', ctx.location, {
                   count: i + 1, elemref, anno: knownAnno, '#': 'notrendered',
                 });
                 stop = true;
@@ -421,16 +447,27 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                 const proxy = links[i].art?._target;
                 const eltName = links[i + 1].art?.name;
                 if (!proxy.elements[eltName]) {
-                  error('odata-anno-xpr-ref', location, {
+                  error('odata-anno-xpr-ref', ctx.location, {
                     count: i + 2, elemref, anno: knownAnno, '#': 'notrendered',
                   });
                   stop = true;
                 }
               }
             }
+            if (!stop && ctx.cAction?.$isBound && scope === '$self') {
+              if (options.isV2()) {
+                error('odata-anno-xpr-ref', ctx.location, {
+                  elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2_impl',
+                });
+              }
+              else {
+                xpr[0] = ctx.cAction.$bindingParam.name;
+                elemref.param = true;
+              }
+            }
           },
-        }, csnPathResolutionLocation);
-        xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
+        }, ctx.csnPath || ctx.location);
+        xpr2edmJson(carrier, knownAnno, ctx.location, options, messageFunctions);
       }
     });
 
@@ -457,7 +494,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     const alternativeAnnotations = [];
 
     // now create annotation objects for all the annotations of carrier
-    handleAnno2(addAnnotation, prefixTree, location);
+    handleAnno2(addAnnotation, prefixTree, ctx.location);
 
     // Produce Edm.Annotations and attach collected Edm.Annotation(s) to the
     // envelope (or directly to the Schema)
@@ -506,7 +543,6 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     }
 
     function initCarrierControlVars() {
-    // eslint-disable-next-line no-unused-vars
       let testToStandardEdmTargetP = () => true; // if true, assign to standard Edm Target
       let stdEdmTargetNameP = edmTargetName;
       let alternativeEdmTargetNameP = null;
@@ -516,13 +552,14 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if (carrier.kind === 'entity') {
       // If AppliesTo=[EntitySet/Singleton/Collection, EntityType], EntitySet/Singleton/Collection has precedence
         testToAlternativeEdmTargetP = ((x) => {
-          if (options.isV2())
-            return [ 'Singleton', 'EntitySet', 'Collection' ].some(y => x.includes(y));
-
-
-          return edmUtils.isSingleton(carrier)
-            ? x.includes('Singleton')
-            : [ 'EntitySet', 'Collection' ].some(y => x.includes(y));
+          if (x) {
+            if (options.isV2())
+              return [ 'Singleton', 'EntitySet', 'Collection' ].some(y => x.includes(y));
+            return edmUtils.isSingleton(carrier)
+              ? x.includes('Singleton')
+              : [ 'EntitySet', 'Collection' ].some(y => x.includes(y));
+          }
+          return true;
         });
         testToStandardEdmTargetP = (x => (x ? x.includes('EntityType') : true));
         // if carrier has an alternate 'entitySetName' use this instead of EdmTargetName
@@ -540,6 +577,23 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       else if (carrier.kind === 'type') {
         testToStandardEdmTargetP = (x => (x ? x.includes(carrier.elements ? 'ComplexType' : 'TypeDefinition') : true));
       }
+      else if (carrier.kind === 'action' || carrier.kind === 'function') {
+        const type = carrier.kind === 'action' ? 'Action' : 'Function';
+        const container = carrier.kind === 'action' ? 'ActionImport' : 'FunctionImport';
+        if (options.isV4()) {
+          testToStandardEdmTargetP = (x => (x ? x.includes(type) : true));
+          // Unbound actions/functions are Action/FunctionImports and are bound to container target
+          testToAlternativeEdmTargetP = (x => (x ? x.includes(container) && !carrier.$isBound : true));
+          const lastDotIndex = carrier.name.lastIndexOf('.');
+          alternativeEdmTargetNameP = lastDotIndex > -1
+            ? `${serviceName}.EntityContainer/${carrier.name.substring(lastDotIndex + 1)}`
+            : `${serviceName}.EntityContainer/${carrier.name}`;
+          hasAlternativeCarrierP = true;
+        }
+        if (options.isV2())
+          // same as in V4 but everything goes to standard target
+          testToStandardEdmTargetP = (x => (x ? x.includes(type) || (x.includes(container) && !carrier.$isBound) : true));
+      }
       else if (carrier.kind === 'service') {
       // if annotated object is a service, annotation goes to EntityContainer,
       //   except if AppliesTo contains Schema but not EntityContainer, then annotation goes to Schema
@@ -764,7 +818,6 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           // 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
-          // eslint-disable-next-line sonarjs/no-collapsible-if
           if (!addAnnotationFunc(anno, dictTerm && dictTerm.AppliesTo)) {
             if (dictTerm && dictTerm.AppliesTo) {
               message('odata-anno-def', location,

package/lib/edm/csn2edm.js

@@ -732,11 +732,13 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           if (type === special$self) {
             bpName = entries[0][0];
             setProp(actionCsn, '$bindingParam', firstParam);
+            // preserve the original type (as it is the key to reqDefs.defintions)
+            // for annotation path resolution (eg. for $draft.IsActiveEntity)
             if (bpType) {
               if (firstParam.items?.type)
-                firstParam.items.type = bpType;
+                setProp(firstParam.items, '_edmType', bpType);
               if (firstParam.type)
-                firstParam.type = bpType;
+                setProp(firstParam, '_edmType', bpType);
             }
             if (!edmUtils.isODataSimpleIdentifier(bpName))
               message('odata-spec-violation-id', [ ...location, 'params', bpName ], { id: bpName });
@@ -775,11 +777,20 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         if (entityCsn) {
           actionNode.setEdmAttribute('IsBound', true);
           if (!actionCsn.$bindingParam) {
+            const bpDef = {
+              name: bpName,
+              viaAnno: true,
+            };
             // Binding Parameter: 'in' at first position in sequence, this is decisive!
-            if (actionCsn['@cds.odata.bindingparameter.collection'])
+            if (actionCsn['@cds.odata.bindingparameter.collection']) {
               actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection: true/* , Nullable: false */ } ));
-            else
+              bpDef.items = { type: bpType };
+            }
+            else {
               actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType } ));
+              bpDef.type = bpType;
+            }
+            setProp(actionCsn, '$bindingParam', bpDef);
           }
         }
         else if (EntityContainer) { // unbound => produce Action/FunctionImport
@@ -891,6 +902,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             if (i === 0 && type === special$self) {
             // skip and remove the first parameter if it is a $self binding parameter to
             // omit annotation rendering later on
+              setProp(actionCsn, '$bindingParam', parameterCsn);
               delete actionCsn.params[parameterName];
             }
             else {

package/lib/edm/edm.js

@@ -625,7 +625,8 @@ function getEdm( options, messageFunctions ) {
               edmUtils.addTypeFacets(this, this._scalarType);
           }
           else {
-            this._edmAttributes[typeName] = typecsn.type;
+            // it's either _edmType or type (_edmType only used for explicit binding param)
+            this._edmAttributes[typeName] = typecsn._edmType || typecsn.type;
           }
         }
         // CDXCORE-245:
@@ -897,7 +898,6 @@ function getEdm( options, messageFunctions ) {
       super(version, attributes, csn);
       // TIPHANACDS-4180
       if (this.v2) {
-        // eslint-disable-next-line sonarjs/no-redundant-boolean
         if (csn['@odata.etag'] || csn['@cds.etag'])
           this._edmAttributes.ConcurrencyMode = 'Fixed';
 
@@ -1037,7 +1037,6 @@ function getEdm( options, messageFunctions ) {
           See csn2edm.createEntityTypeAndSet() for details
           2) ContainsTarget stems from the @odata.contained annotation
         */
-        // eslint-disable-next-line sonarjs/no-redundant-boolean
         if (csn['@odata.contained'] || csn.containsTarget)
           this._edmAttributes.ContainsTarget = true;
 

package/lib/edm/edmAnnoPreprocessor.js

@@ -59,7 +59,6 @@ function applyAppSpecificLateCsnTransformationOnElement( options, element, struc
   // runtime cannot set that okra flag (alternatively the runtime has to search
   // for @[odata|cds].etag annotations...
   if (options.isV4() && (element['@odata.etag'] || element['@cds.etag'])) {
-    // eslint-disable-next-line sonarjs/no-redundant-boolean
     // don't put element name into collection as per advice from Ralf Handl, as
     // no runtime is interested in the property itself, it is sufficient to mark
     // the entity set.
@@ -243,7 +242,7 @@ function setSAPSpecificV2AnnotationsToEntitySet( options, carrier ) {
     '@sap.updatable.path': addToSetAttr,
     '@sap.deletable.path': addToSetAttr,
     '@sap.searchable': addToSetAttr,
-    '@sap.pagable': addToSetAttr,
+    '@sap.pageable': addToSetAttr,
     '@sap.topable': addToSetAttr,
     '@sap.countable': addToSetAttr,
     '@sap.addressable': addToSetAttr,

package/lib/edm/edmPreprocessor.js

@@ -100,7 +100,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     as a step in the OData transformer with the goal to have a protocol agnostic OData CSN.
   */
   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, messageFunctions);
     expandCSNToFinalBaseType(csn, { toFinalBaseType }, csnUtils, serviceRootNames, options);
   }
@@ -704,11 +703,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         validFrom.push(element);
 
       // forward annotations from managed association element to its foreign keys
-      // TODO: Try to eliminate this code by rearranging
-      // forOdata::addCommonValueListviaAssociation(member, memberName)
-      // such that the VL annotations are distributed to the associations *before*
-      // FK creation.
-      // The FK creation already propagates the annotations from the association
       const elements = construct.items?.elements || construct.elements;
       const assoc = elements[element['@odata.foreignKey4']];
       if (assoc) {
@@ -1915,7 +1909,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     function markCollection( obj ) {
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
       if (items) {
-        edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : true);
+        edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : false);
         edmUtils.assignProp(obj, '$isCollection', true);
       }
     }

package/lib/gen/Dictionary.json

@@ -1885,9 +1885,18 @@
     "UI.Placeholder": {
       "Type": "Edm.String",
       "AppliesTo": [
-        "Property"
+        "Property",
+        "Parameter"
       ]
     },
+    "UI.InputMask": {
+      "Type": "UI.InputMaskType",
+      "AppliesTo": [
+        "Property",
+        "Parameter"
+      ],
+      "$experimental": true
+    },
     "UI.TextArrangement": {
       "Type": "UI.TextArrangementType",
       "AppliesTo": [
@@ -3823,7 +3832,8 @@
         "ResultSizeDefault": "Edm.Int32",
         "ResultSizeMaximum": "Edm.Int32",
         "IANATimezoneFormat": "Edm.Boolean",
-        "Treeview": "Edm.Boolean"
+        "Treeview": "Edm.Boolean",
+        "TextDirectionLayout": "Edm.Boolean"
       }
     },
     "PersonalData.EntitySemanticsType": {
@@ -4274,6 +4284,23 @@
         "High": "Edm.PrimitiveType"
       }
     },
+    "UI.InputMaskType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "Mask": "Edm.String",
+        "PlaceholderSymbol": "Edm.String",
+        "Rules": "Collection(UI.InputMaskRuleType)"
+      },
+      "$experimental": true
+    },
+    "UI.InputMaskRuleType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "MaskSymbol": "Edm.String",
+        "RegExp": "Edm.String"
+      },
+      "$experimental": true
+    },
     "UI.NoteType": {
       "$kind": "ComplexType",
       "Properties": {

package/lib/gen/language.checksum

@@ -1 +1 @@
-0c76b255e5fe55c0f8527a4d9f1b563f
+d2eab9ea0d46c406f6078d8a1125152e