@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/edm/annotations/edmJson.js

@@ -248,8 +248,15 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   transform['<='] = op('$Le');
   transform.$Le = noOp;
   transform.in = (parent, prop, xpr) => {
-    evalArgs({ min: 1 }, xpr[1].list, prop);
-    parent.$In = [ xpr[0], ...xpr[1].list ];
+    let args = xpr[1].list;
+    if (!args) {
+      if (Array.isArray(xpr[1].xpr))
+        args = xpr[1].xpr;
+      else
+        args = [ xpr[1] ];
+    }
+    evalArgs({ min: 1 }, args, prop);
+    parent.$In = [ xpr[0], args ];
     delete parent[prop];
     transformExpression(parent, undefined, transform);
   };
@@ -293,9 +300,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   transform.$Neg = noOp;
   transform['*'] = op('$Mul');
   transform.$Mul = noOp;
-  transform['/'] = op('$Div');
-  transform.$Div = noOp;
-  // $DivBy, $Mod are functions
+  transform['/'] = op('$DivBy');
+  transform.$DivBy = noOp;
+  // $Div, $Mod are functions
   //----------------------------------
   // LITERALS
   transform.val = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
@@ -575,6 +582,15 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             }
           }
           else {
+            // Error out for arbitrary types until we know better
+            // probably todo: Check for reachability of arb type names such as namespace
+            // reqDef entry etc...
+            if (typeDef) { // eslint-disable-line no-lonely-if
+              error('odata-anno-xpr-type', location, {
+                anno, op: `${xpr}(…)`, type: `${typeDef}`, '#': 'edm',
+              });
+            }
+            /*
             typeFacets.forEach((facet) => {
               if (facet.args.length === 1 && facet.args[0].val) {
                 const facetName = facet.func.startsWith('$') ? facet.func.slice(1) : facet.func;
@@ -582,6 +598,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                   parent[`$${facetName}`] = facet.args[0].val;
               }
             });
+            */
           }
 
           delete typeProp.args;
@@ -648,8 +665,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     const funcDefs = {
       $Has: twoArgs,
       Has: [ twoArgs, dollar ],
-      $DivBy: twoArgs,
-      DivBy: [ twoArgs, dollar ],
+      $Div: twoArgs,
+      Div: [ twoArgs, dollar ],
       $Mod: twoArgs,
       Mod: [ twoArgs, dollar ],
       $Apply: () => {

package/lib/edm/annotations/genericTranslation.js

@@ -102,7 +102,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     // qualified with #$parameters or if its applicable to an EntitySet or Singleton
     const scopeCheck = {
       ref: (elemref, prop, xpr, path) => {
-        if (scopeCheck.scope === 'param' && (!elemref.param || (xpr[0].id || xpr[0]) === '$self')) {
+        if (scopeCheck.scope === 'param' &&
+          (!elemref.param ||
+           (xpr[0].id || xpr[0]) === '$self' && !def.elements.$self)) {
           error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaparam' });
           // don't try to resolve those paths later on
           delete elemref[prop];
@@ -111,9 +113,13 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaneelement' });
           delete elemref[prop];
         }
-        if (scopeCheck.scope === 'param' && elemref.param)
+        if (scopeCheck.scope === 'param' && elemref.param) {
           // make sure that path is resolvable as element path later on
           delete elemref.param;
+          const head = xpr[0].id || xpr[0];
+          if (head[0] === '$')
+            xpr.unshift('$self');
+        }
       },
     };
     const checkDict = (dict, scope) => {
@@ -156,7 +162,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             const steps = prefix.replace(`@${ns}.`, '').split('.');
             const paramAnnoParts = steps[0].split('#$parameters');
             const dictTerm = getDictTerm(`${ns}.${paramAnnoParts[0]}`, options);
-            if (paramAnnoParts.length > 1 || [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
+            if (paramAnnoParts.length > 1 ||
+                [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
               steps[0] = `@${ns}.${paramAnnoParts.join('')}`;
               let newAnno = steps.join('.');
               if (innerAnnotation)
@@ -185,12 +192,14 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   There is one exception (Schema), see below
 
   carrier = service
-    the target is the EntityContainer, unless the annotation has an "AppliesTo" where only Schema is given, but not EntityContainer
-    then the <Annotation ...> is directly put into <Schema ...> without an enclosing <Annotations ...>
+    the target is the EntityContainer, unless the annotation has an "AppliesTo"
+    where only Schema is given, but not EntityContainer then the <Annotation ...>
+    is directly put into <Schema ...> without an enclosing <Annotations ...>
 
   carrier = entity (incl. view/projection)
-    the target is the corresponding EntityType, unless the annotation has an "AppliesTo" where only EntitySet is given, but not EntityType
-    then the target is the corresponding EntitySet
+    the target is the corresponding EntityType, unless the annotation has an
+    "AppliesTo" where only EntitySet is given, but not EntityType then the target
+    is the corresponding EntitySet
 
   carrier = structured type
     the target is the corresponding ComplexType
@@ -217,7 +226,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     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, element.$path,
+                          [ ...location, '$elementsAnnoProxies', elemPath ]);
       });
     }
     // element bound annotations
@@ -278,24 +288,28 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if (cAction.$paramsAnnoProxies) {
         Object.entries(cAction.$paramsAnnoProxies).forEach(([ paramPath, param ]) => {
           const edmTargetName = `${actionName}/${paramPath}`;
-          handleAnnotations(edmTargetName, param, param.$path, [ ...location, '$paramsAnnoProxies', paramPath ]);
+          handleAnnotations(edmTargetName, param, param.$path,
+                            [ ...location, '$paramsAnnoProxies', paramPath ]);
         });
       }
       Object.entries(cAction.params).forEach(([ n, p ]) => {
         const edmTargetName = `${actionName}/${n}`;
-        handleAnnotations(edmTargetName, p, [ ...location, 'params', n ]);
+        handleAnnotations(edmTargetName, p,
+                          [ ...location, 'params', n ]);
       });
     }
     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, returns.$path,
+                            [ ...location, '$returnsAnnoProxies', returnsPath ]);
         });
       }
       const edmTargetName = `${actionName}/$ReturnType`;
       setProp(cAction.returns, '$appliesToReturnType', true);
-      handleAnnotations(edmTargetName, cAction.returns, [ ...location, 'returns' ]);
+      handleAnnotations(edmTargetName, cAction.returns,
+                        [ ...location, 'returns' ]);
       delete cAction.returns.$appliesToReturnType;
     }
 
@@ -304,12 +318,19 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       const params = [];
       if (entityNameIfBound) {
         // If this is an action and has an explicit binding parameter add it here
-        if (cAction.$bindingParam && cAction.kind === 'action')
-          params.push(cAction.$bindingParam.items ? `Collection(${entityNameIfBound})` : entityNameIfBound);
-
+        if (cAction.$bindingParam && cAction.kind === 'action') {
+          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);
+        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
@@ -369,50 +390,49 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if (knownAnnos.length === 0)
         return;
     }
-    if (isBetaEnabled(options, 'odataAnnotationExpressions')) {
-      knownAnnos.forEach((knownAnno) => {
-        if (knownAnno.search(/\.\$edmJson\./g) < 0) {
-          if (isBetaEnabled(options, 'odataPathsInAnnotationExpressions')) {
-            transformExpression(carrier, knownAnno, {
-              ref: (elemref, prop, xpr, csnPath) => {
-                const { links, scope } = reqDefsUtils.inspectRef(csnPath);
-                let i = scope === '$self' ? 1 : 0;
-                const getProp = propName => (links[i].art ? (links[i].art[propName] || reqDefsUtils.effectiveType(links[i].art)[propName]) : undefined);
-                if (scope === '$magic')
-                  return;
-                let stop = false;
-                for (; i < links.length && !stop; i++) {
-                  const cardinality = getProp('cardinality');
-                  if ((cardinality && cardinality.max !== 1) || getProp('items')) {
-                    error('odata-anno-xpr-ref', location, {
-                      count: i + 1, elemref, anno: knownAnno, '#': 'tomany',
-                    });
-                    stop = true;
-                  }
-                  if (!isEdmPropertyRendered(links[i].art, csnPath)) {
-                    error('odata-anno-xpr-ref', location, {
-                      count: i + 1, elemref, anno: knownAnno, '#': 'notrendered',
-                    });
-                    stop = true;
-                  }
-                  if (links[i].art?._target?.$proxy && i < links.length - 1) {
-                    const proxy = links[i].art?._target;
-                    const eltName = links[i + 1].art?.name;
-                    if (!proxy.elements[eltName]) {
-                      error('odata-anno-xpr-ref', location, {
-                        count: i + 2, elemref, anno: knownAnno, '#': 'notrendered',
-                      });
-                      stop = true;
-                    }
-                  }
+
+    knownAnnos.forEach((knownAnno) => {
+      if (knownAnno.search(/\.\$edmJson\./g) < 0) {
+        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',
+              });
+              return;
+            }
+            const { links, scope } = reqDefsUtils.inspectRef(csnPath);
+            let i = scope === '$self' ? 1 : 0;
+            if (scope === '$magic') {
+              error('odata-anno-xpr-ref', location, {
+                elemref, anno: knownAnno, '#': 'magic',
+              });
+              return;
+            }
+            let stop = false;
+            for (; i < links.length && !stop; i++) {
+              if (!isEdmPropertyRendered(links[i].art, csnPath)) {
+                error('odata-anno-xpr-ref', location, {
+                  count: i + 1, elemref, anno: knownAnno, '#': 'notrendered',
+                });
+                stop = true;
+              }
+              if (links[i].art?._target?.$proxy && i < links.length - 1) {
+                const proxy = links[i].art?._target;
+                const eltName = links[i + 1].art?.name;
+                if (!proxy.elements[eltName]) {
+                  error('odata-anno-xpr-ref', location, {
+                    count: i + 2, elemref, anno: knownAnno, '#': 'notrendered',
+                  });
+                  stop = true;
                 }
-              },
-            }, csnPathResolutionLocation);
-          }
-          xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
-        }
-      });
-    }
+              }
+            }
+          },
+        }, csnPathResolutionLocation);
+        xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
+      }
+    });
 
     const prefixTree = createPrefixTree();
 
@@ -1014,7 +1034,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         typeName = dTypeName.split('.')[1];
     }
 
-    if (value) {
+    if (typeof value === 'string') {
       // replace all occurrences of '.' by '/' up to first '@'
       value = value.split('@').map((o, i) => (i === 0 ? o.replace(/\./g, '/') : o)).join('@');
     }

package/lib/edm/edm.js

@@ -19,11 +19,11 @@ function getEdm( options, messageFunctions ) {
      */
     constructor(version, attributes = Object.create(null), csn = undefined) {
       if (!attributes || typeof attributes !== 'object')
-        error(null, 'Please debug me: attributes must be a dictionary');
+        error(null, 'Debug me: attributes must be a dictionary');
       if (!Array.isArray(version))
-        error(null, `Please debug me: v is either undefined or not an array: ${version}`);
+        error(null, `Debug me: v is either undefined or not an array: ${version}`);
       if (version.filter(v => v).length !== 1)
-        error(null, 'Please debug me: exactly one version must be set');
+        error(null, 'Debug me: exactly one version must be set');
 
       // Common attributes of JSON and XML.
       // Note: Can't assign attributes directly, due to the input object being modified.
@@ -1108,7 +1108,7 @@ function getEdm( options, messageFunctions ) {
             json.$OnDelete = c._edmAttributes.Action;
             break;
           default:
-            error(null, `Please debug me: Unhandled NavProp child: ${c.kind}`);
+            error(null, `Debug me: Unhandled NavProp child: ${c.kind}`);
         }
       });
       // TODO Annotations

package/lib/edm/edmInboundChecks.js

@@ -3,6 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
   forEachDefinition, forEachMemberRecursively, getUtils,
+  transformExpression, findAnnotationExpression,
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { assignAnnotation } = require('./edmUtils.js');
@@ -55,8 +56,10 @@ function inboundQualificationChecks( csn, options, messageFunctions,
       Object.entries(def.actions).forEach(([ n, action ]) => {
         const aLoc = location.concat('actions', n);
         checkIfItemsOfItems(action, undefined, undefined, aLoc);
+        markBindingParamPaths(action, aLoc);
         forEachMemberRecursively(action, checkIfItemsOfItems, aLoc);
         checkIfItemsOfItems(action.returns, undefined, undefined, aLoc.concat('returns'));
+        markBindingParamPaths(action, aLoc);
       });
     }
 
@@ -124,6 +127,36 @@ function inboundQualificationChecks( csn, options, messageFunctions,
           message('chained-array-of', path);
       }
     }
+
+    // we need to know if the first path step is the bindind param
+    // for the rejection of V2 paths where the BP is ignored
+    function markBindingParamPaths( action, loc ) {
+      const special$self = !csn?.definitions?.$self && '$self';
+      if (action.params) {
+        const params = Object.entries(action.params);
+        const firstParam = params[0][1];
+        const type = firstParam?.items?.type || firstParam?.type;
+        if (type === special$self) {
+          const bindingParamName = params[0][0];
+          const markBindingParam = {
+            ref: (parent, prop, xpr) => {
+              if ((xpr[0].id || xpr[0]) === bindingParamName)
+                parent.$bparam = true;
+            },
+          };
+          let exprAnnos = Object.keys(action).filter(pn => findAnnotationExpression(action, pn));
+          exprAnnos.forEach((pn) => {
+            transformExpression(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);
+            });
+          }, loc);
+        }
+      }
+    }
   }
 
   function checkNestedContextsAndServices() {

package/lib/edm/edmPreprocessor.js

@@ -127,7 +127,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         const mySchemaName = whatsMySchemaName(defName);
         if (mySchemaName)
           setProp(def, '$mySchemaName', mySchemaName);
-        if (isMyServiceRequested(defName) && def.kind !== 'aspect')
+        if (isMyServiceRequested(defName) && def.kind !== 'aspect' && def.kind !== 'event')
           reqDefs.definitions[defName] = def;
       },
       linkAssociationTarget,
@@ -1641,7 +1641,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             if (art.type && !isBuiltinType(art.type))
               art = art._type || csnUtils.getCsnDef(art.type);
           }
-          keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter), path));
+          if (art === eltCsn)
+            error('odata-key-recursive', path, { name: prefix });
+          else
+            keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter), path));
         });
       }
       else {
@@ -2176,7 +2179,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     let isSubTreeSpan = true;
 
     let rootPrefix = absPath.slice(1, absPath.length - 1);
-    const isExprAnno = (obj, pn) => isBetaEnabled(options, 'odataPathsInAnnotationExpressions') && findAnnotationExpression(obj, pn);
 
     const subTreeSpan = {
       ref: (parent, _prop, xpr) => {
@@ -2228,7 +2230,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     if (absPath.length > 2) {
       const [ xprANames, nxprANames ] = Object.keys(carrier).reduce((acc, pn) => {
         if (pn[0] === '@')
-          acc[isExprAnno(carrier, pn) ? 0 : 1].push(pn);
+          acc[findAnnotationExpression(carrier, pn) ? 0 : 1].push(pn);
         return acc;
       }, [ [], [] ]);
 
@@ -2244,8 +2246,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       if (scope === 'actions' && def[scope][carrier.$path[3]]) {
         def = def[scope][carrier.$path[3]];
         scope = carrier.$path[4];
-        if (scope === 'params')
+        if (scope === 'params') {
           rootPrefix = absPath.slice(2, absPath.length - 1);
+          eltPath = absPath.slice(2).join('/');
+        }
         if (scope === 'returns') {
           absPath[2] = '$ReturnType';
           rootPrefix = absPath.slice(3, absPath.length - 1);
@@ -2263,7 +2267,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         else {
           absolutize.scope = scope;
           transformExpression(carrier, xprAName, absolutize);
-
           if (!def[proxyDict])
             setProp(def, proxyDict, Object.create(null));
           let proxyCarrier = def[proxyDict][eltPath];