@sap/cds-compiler 6.3.6 → 6.4.6

package/lib/edm/annotations/edmJson.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const edmUtils = require('../edmUtils.js');
-const { parseExpr } = require('../../transform/parseExpr');
 const {
   EdmTypeFacetMap,
   EdmTypeFacetNames,
@@ -9,6 +8,7 @@ const {
 } = require('../EdmPrimitiveTypeDefinitions.js');
 const { isBuiltinType, isAnnotationExpression } = require('../../base/builtins');
 const { transformExpression } = require('../../transform/db/applyTransformations.js');
+const { conditionAsTree, expressionAsTree } = require('../../model/xprAsTree');
 
 /**
  * Translate a given token stream expression into an edmJson representation
@@ -77,7 +77,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Error transformer
-  const notADynExpr = (parent, op, xpr, csnPath, parentparent, parentprop, txt) => {
+  const notADynExpr = (parent, op, xpr, csnPath, parentParent, parentProp, txt) => {
     error('odata-anno-xpr', location, {
       anno, op: txt ?? op, '#': 'notadynexpr',
     });
@@ -104,15 +104,15 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
   //----------------------------------
   // list is a $Collection => []
-  transform.list = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
-    parentparent[parentprop] = xpr.filter(a => a);
-    transformExpression(parentparent, parentprop, transform);
+  transform.list = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+    parentParent[parentProp] = xpr.filter(a => a);
+    transformExpression(parentParent, parentProp, transform);
   };
   // XPR
-  transform.xpr = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+  transform.xpr = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     // eliminate 'xpr' node by pulling up xpr node to its parent
-    parentparent[parentprop] = xpr;
-    transformExpression(parentparent, parentprop, transform);
+    parentParent[parentProp] = xpr;
+    transformExpression(parentParent, parentProp, transform);
   };
   //----------------------------------
   // CASE
@@ -150,7 +150,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Cast => $Cast
-  transform.cast = (parent, prop, castExpr, csnPath, 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)) {
@@ -184,8 +184,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       typeFunc.args.push( { func: 'Scale', args: [ { val: csnType.scale } ] });
 
 
-    parentparent[parentprop] = castFunc;
-    transformExpression(parentparent, parentprop, transform);
+    parentParent[parentProp] = castFunc;
+    transformExpression(parentParent, parentProp, transform);
   };
   //----------------------------------
   const evalArgs = (argDef, args, propName) => {
@@ -261,11 +261,11 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     transformExpression(parent, undefined, transform);
   };
   transform.$In = noOp;
-  transform.between = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+  transform.between = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     evalArgs({ exact: 2 }, xpr.slice(1), prop);
     transformExpression(xpr, undefined, transform);
     delete parent[prop];
-    parentparent[parentprop]
+    parentParent[parentProp]
       = {
         $And: [
           { $Le: [ xpr[1], xpr[0] ] },
@@ -273,23 +273,23 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         ],
       };
   };
-  transform['||'] = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+  transform['||'] = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     evalArgs({ exact: 2 }, xpr, prop);
     transformExpression(xpr, undefined, transform);
     delete parent[prop];
-    parentparent[parentprop].$Apply = xpr;
-    parentparent[parentprop].$Function = 'odata.concat';
+    parentParent[parentProp].$Apply = xpr;
+    parentParent[parentProp].$Function = 'odata.concat';
   };
   //----------------------------------
   // ARITHMETICAL AND UNARY
-  transform['+'] = (parent, prop, xpr, csnPath, 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;
-      transformExpression(parentparent, parentprop, transform);
+      parentParent[parentProp] = xpr;
+      transformExpression(parentParent, parentProp, transform);
     }
   };
   transform.$Add = noOp;
@@ -305,19 +305,19 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   // $Div, $Mod are functions
   //----------------------------------
   // LITERALS
-  transform.val = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+  transform.val = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     if (xpr === null)
       parent.$Null = true;
     else
-      parentparent[parentprop] = xpr;
+      parentParent[parentProp] = xpr;
   };
-  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentprop, txt) => {
+  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentProp, txt) => {
     if (parent['#'] && parent.val) // enum reference that was resolved by the compiler
       delete parent['#'];
     else
-      notADynExpr(parent, prop, xpr, csnPath, parentParent, parentprop, txt);
+      notADynExpr(parent, prop, xpr, csnPath, parentParent, parentProp, txt);
   };
-  transform.ref = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+  transform.ref = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     // until empty filter syntax is introduced for the annotation expressions,
     // we ignore the filters in order to generate EDMX
     if (xpr.some(ps => ps.args/* || ps.where */)) {
@@ -328,11 +328,11 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     const [ head, ...tail ] = xpr;
     if ((head.id || head) === '$self')
       xpr = tail;
-    parentparent[parentprop] = { $Path: xpr.map(ps => ps.id || ps).join('/') };
+    parentParent[parentProp] = { $Path: xpr.map(ps => ps.id || ps).join('/') };
   };
   //----------------------------------
   // Functions
-  transform.func = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+  transform.func = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     const rewriteArgs = (argDefs, evalVal = true) => {
       Object.entries(argDefs).forEach(([ argName, argDef ]) => {
         const [ foundProps, newArgs ]
@@ -722,8 +722,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       UrlRef: [ oneArg, dollar ],
       // $Record ???
       $Collection: () => {
-        standard(parentparent, parentprop);
-        transformExpression(parentparent, parentprop, transform);
+        standard(parentParent, parentProp);
+        transformExpression(parentParent, parentProp, transform);
       },
       $Path: () => {
         oneArg(parent, xpr);
@@ -733,7 +733,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             anno, op: `${ xpr }(…)`, meta: 'string', '#': 'wrongval_meta',
           });
         }
-        transformExpression(parentparent, parentprop, transform);
+        transformExpression(parentParent, parentProp, transform);
       },
       $Null: () => {
         parent[xpr] = true;
@@ -766,11 +766,11 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         }
         else {
           evalArgs(argDef, parent.args, xpr);
-          parentparent[parentprop].$Apply = [ ...(parent.args || []) ];
-          parentparent[parentprop].$Function = funcName;
-          delete parentparent[parentprop].func;
-          delete parentparent[parentprop].args;
-          transformExpression(parentparent, parentprop, transform);
+          parentParent[parentProp].$Apply = [ ...(parent.args || []) ];
+          parentParent[parentProp].$Function = funcName;
+          delete parentParent[parentProp].func;
+          delete parentParent[parentProp].args;
+          transformExpression(parentParent, parentProp, transform);
         }
       }
       else {
@@ -783,13 +783,182 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
 
   return transformExpression(carrier, anno, {
-    '=': (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+    '=': (parent, prop, xpr, csnPath, parentParent, parentProp) => {
       if (isAnnotationExpression(parent)) {
         delete parent['='];
-        parentparent[parentprop] = transformExpression({ $edmJson: parseExpr( parent, { array: false }) }, undefined, transform);
+        const edmJson = preTransformXpr(parent);
+        parentParent[parentProp] = transformExpression({ $edmJson: edmJson }, undefined, transform);
       }
     },
-  });
+  }, location);
+
+  /**
+   * Pre-transform the CSN expression into a tree structure for further EDM processing.
+   * Example:
+   *  `[…, '+' …]`  ->  `{'+': [ …, … ]}`
+   *
+   * @param {object|Array} xpr
+   */
+  function preTransformXpr( xpr ) {
+    xpr = Array.isArray(xpr) ? conditionAsTree(xpr) : expressionAsTree(xpr);
+    xpr = preTransformExpression(xpr);
+    if (Array.isArray(xpr)) {
+      xpr = xpr.flat(Infinity);
+      return (xpr.length === 1) ? xpr[0] : xpr;
+    }
+    return xpr;
+  }
+
+  /**
+   * Reject any invalid expression such as `1 +`.
+   */
+  function rejectInvalidExpression( expr ) {
+    if (expr.length === 3 && expr[1] === 'is' && expr[2] === 'null') {
+      messageFunctions.error('odata-anno-xpr', location, {
+        '#': 'notadynexpr', anno, op: 'is null',
+      });
+      return;
+    }
+    if (expr.length === 4 && expr[1] === 'is' && expr[2] === 'not' && expr[3] === 'null') {
+      messageFunctions.error('odata-anno-xpr', location, {
+        '#': 'notadynexpr', anno, op: 'is not null',
+      });
+      return;
+    }
+    if (expr.length === 4 && expr[1] === 'not' && expr[2] === 'like') {
+      messageFunctions.error('odata-anno-xpr', location, {
+        '#': 'notadynexpr', anno, op: 'not like',
+      });
+      return;
+    }
+    if (expr.length === 3 && expr[1] === 'like') {
+      messageFunctions.error('odata-anno-xpr', location, {
+        '#': 'notadynexpr', anno, op: 'not like',
+      });
+      return;
+    }
+
+    // Any left-over operator is not recognized: reject it
+    for (let i = 0; i < expr.length; i++) {
+      if (expr[i] === 'not' && typeof expr[i + 1] === 'string')
+        ++i;
+
+      if (typeof expr[i] === 'string') {
+        messageFunctions.error('odata-anno-xpr', location, {
+          '#': 'invalid',
+          anno,
+          op: expr[i],
+        });
+        break;
+      }
+    }
+  }
+
+  /**
+   * Pre-transform a _structurized_ expression.
+   */
+  function preTransformExpression( xpr ) {
+    if (!xpr || typeof xpr !== 'object')
+      return xpr;
+
+    if (Array.isArray(xpr)) {
+      xpr = xpr.map(preTransformExpression); // not `preTransformXpr`, as that would re-structurize the array
+
+      if (xpr.length === 1)
+        return xpr[0]; // single entry, e.g. via structurizer
+
+      if (xpr[0]?.toLowerCase?.() === 'case')
+        return preTransformCase(xpr);
+
+      if (xpr[1]?.toLowerCase?.() === 'between')
+        return preTransformBetween(xpr);
+
+      if (xpr[1]?.toLowerCase?.() === 'not' &&
+        xpr[2]?.toLowerCase?.() === 'between')
+        return { not: preTransformExpression([ xpr[0], ...xpr.slice(2) ]) };
+
+      if (xpr[1]?.toLowerCase?.() === 'not' &&
+        xpr[2]?.toLowerCase?.() === 'in')
+        return { not: preTransformExpression([ xpr[0], ...xpr.slice(2) ]) };
+
+      // unary operators
+      if (xpr.length === 2 && (xpr[0] === '+' || xpr[0] === '-' || xpr[0] === 'not' || xpr[0] === 'new'))
+        return { [xpr[0]]: xpr[1] };
+
+      if (xpr.length === 3 && xpr[1] === 'is' && xpr[2] === 'null') {
+        rejectInvalidExpression(xpr);
+        return xpr;
+      }
+
+      // binary operators: '=', '<>', 'like', ...
+      if (xpr.length === 3 && typeof xpr[1] === 'string')
+        return { [xpr[1]]: [ xpr[0], xpr[2] ] };
+
+      rejectInvalidExpression(xpr);
+
+      return xpr;
+    }
+
+    if (xpr.list)
+      xpr.list.forEach( preTransformExpression );
+
+    if (xpr.args) {
+      if (!Array.isArray( xpr.args ))
+        Object.values( xpr.args ).forEach(preTransformExpression );
+      else if (xpr.args.length)
+        xpr.args.forEach( preTransformExpression );
+    }
+    if (xpr.ref)
+      xpr.ref.forEach( preTransformExpression );
+
+    if (xpr.xpr)
+      xpr.xpr = preTransformExpression( xpr.xpr );
+
+    if (xpr.cast) {
+      const castKeys = Object.keys(xpr).filter(k => k !== 'cast');
+      if (castKeys.length === 1)
+        return { cast: [ xpr.cast, { [castKeys[0]]: xpr[castKeys[0]] } ] };
+    }
+
+    return xpr;
+  }
+
+  function preTransformBetween( xpr ) {
+    return {
+      between: [
+        xpr[0],
+        xpr[2],
+        xpr[4],
+      ],
+    };
+  }
+
+  function preTransformCase( xpr ) {
+    const caseObj = [ ];
+    let pos = 1;
+
+    // CASE val WHEN val THEN …
+    if (xpr[pos]?.toLowerCase?.() !== 'when') {
+      caseObj.push( xpr[pos] );
+      pos++;
+    }
+
+    while (xpr[pos]?.toLowerCase?.() === 'when') {
+      if (xpr[pos + 2]?.toLowerCase?.() !== 'then')
+        return xpr;
+      caseObj.push({ when: [ xpr[pos + 1], xpr[pos + 3] ] });
+      pos += 4;
+    }
+    if (xpr[pos]?.toLowerCase?.() === 'else' ) {
+      caseObj.push(xpr[pos + 1]);
+      pos += 2;
+    }
+    if (xpr[pos++]?.toLowerCase?.() !== 'end')
+      return xpr;
+    return {
+      case: caseObj,
+    };
+  }
 }
 
 // Not everything that can occur in OData annotations can be expressed with

package/lib/edm/csn2edm.js

@@ -688,6 +688,11 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
                 props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
               }
             }
+
+            if (options.isV2() && isBetaEnabled(options, 'draftAdminDataHiddenFilter')) {
+              if (elementCsn._edmParentCsn.name === `${ elementCsn._edmParentCsn.$mySchemaName }.DraftAdministrativeData`)
+                elementCsn['@UI.HiddenFilter'] ??= true;
+            }
           });
         }
         if (options.isV2()) {
@@ -723,6 +728,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
       // add bound/unbound actions/functions for V4
       function createActionV4( actionCsn, _name, entityCsn = undefined ) {
+        if (actionCsn['@cds.api.ignore'])
+          return;
         const iAmAnAction = actionCsn.kind === 'action';
         const actionName = edmUtils.getBaseName(actionCsn.name);
         const attributes = { Name: actionName, IsBound: false };
@@ -837,6 +844,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         // Parameter Nodes
         if (actionCsn.params) {
           forEach(actionCsn.params, ( parameterName, parameterCsn ) => {
+            if (parameterCsn['@cds.api.ignore'])
+              return;
             const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
             const pLoc = [ ...location, 'params', p._edmAttributes.Name ];
             if (!edmUtils.isODataSimpleIdentifier(parameterName))
@@ -861,6 +870,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
       // add bound/unbound actions/functions for V2
       function createActionV2( actionCsn, name, entityCsn = undefined ) {
+        if (actionCsn['@cds.api.ignore'])
+          return;
         /** @type {object} */
         const attributes = { Name: name.replace(schemaNamePrefix, '') };
         const functionImport = new Edm.FunctionImport(v, attributes );
@@ -924,6 +935,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         // the client assume that Nullable is false.... Correct Nullable Handling is done inside Parameter constructor
         if (actionCsn.params) {
           Object.entries(actionCsn.params).forEach(([ parameterName, parameterCsn ], i) => {
+            if (parameterCsn['@cds.api.ignore'])
+              return;
             const type = parameterCsn?.items?.type || parameterCsn?.type;
             if (i === 0 && type === special$self) {
             // skip and remove the first parameter if it is a $self binding parameter to

package/lib/edm/edmUtils.js

@@ -292,7 +292,7 @@ function finalizeReferentialConstraints( csn, assocCsn, options, info ) {
         } );
       }
       // Remove all target elements that are not key in the principal entity
-      // and all elements that annotated with '@cds.api.ignore'
+      // and all elements that are annotated with '@cds.api.ignore'
       const remainingPrincipalRefs = [];
       foreach(assocCsn._constraints.constraints,
               (c) => {
@@ -359,7 +359,7 @@ function finalizeReferentialConstraints( csn, assocCsn, options, info ) {
     // If FK is key in target => constraint
     // Don't consider primary key associations (fks become keys on the source entity) as
     // this would impose a constraint against the target.
-    // Filter out all elements that annotated with '@cds.api.ignore'
+    // Filter out all elements that are annotated with '@cds.api.ignore'
 
     // In structured format, foreign keys of managed associations are never rendered, so
     // there are no constraints for them.