@sap/cds-compiler 6.3.6 → 6.4.2

package/lib/compiler/xpr-rewrite.js

@@ -181,6 +181,7 @@ function xprRewriteFns( model ) {
 
   return {
     rewriteAnnotationsRefs,
+    rewriteRefsInExpression,
   };
 
   /**
@@ -189,14 +190,15 @@ function xprRewriteFns( model ) {
    * @param {string} [variant]
    */
   function reportAnnoRewriteError( expr, config, variant = 'std' ) {
-    return error('anno-missing-rewrite', [
-      weakLocation( config.target.location ), config.target,
-    ], {
-      '#': variant,
-      anno: config.anno,
-      art: config.origin,
-      elemref: expr,
-    });
+    return !config.tokenExpr || // TODO: some info message ?
+      error( 'anno-missing-rewrite', [
+        weakLocation( config.target.location ), config.target,
+      ], {
+        '#': variant,
+        anno: config.anno,
+        art: config.origin,
+        elemref: expr,
+      });
   }
 
   /**
@@ -217,21 +219,33 @@ function xprRewriteFns( model ) {
     if (!anno.kind || anno.$invalidPaths)
       return;
 
-    // Annotation comes from the target's type.  That's important to know, because
+    const hasError = rewriteRefsInExpression( target, origin, annoName );
+    target.$contains ??= {};
+    target.$contains.$annotation ??= {};
+    target.$contains.$annotation.$path ||= origin.$contains.$annotation.$path;
+    target.$contains.$annotation.$self ||= origin.$contains.$annotation.$self;
+    if (hasError)
+      anno.$invalidPaths = true; // avoid subsequent errors
+  }
+
+  function rewriteRefsInExpression( destination, origin, propName ) {
+    // Annotation comes from the destination's type.  That's important to know, because
     // path prefixes need to be adapted.
-    const fromTargetType = target.type?._artifact === origin;
-    // Annotation comes from the target's calculated element.  A special case propagation rule, e.g
+    const fromTargetType = destination.type?._artifact === origin;
+    // Annotation comes from the destination's calculated element.
+    // A special case propagation rule, e.g
     // for `calcString: String = str;`.  We also need to adapt path prefixes.
-    const fromCalcElement = !fromTargetType && target.$calcDepElement &&
-      target.value?._artifact === origin;
+    const fromCalcElement = !fromTargetType && destination.$calcDepElement &&
+      destination.value?._artifact === origin;
 
-    const { expandedRoot, expandedRootType } = !fromTargetType && getExpandRoot( target ) || {};
+    const { expandedRoot, expandedRootType }
+      = !fromTargetType && getExpandRoot( destination ) || {};
 
     const config = {
       __proto__: AnnoRewriteConfig.prototype,
-      anno: annoName,
-      target,
-      targetRoot: annoRootArt( target ),
+      anno: propName,
+      target: destination,
+      targetRoot: annoRootArt( destination ),
       origin,
       fromTargetType,
       fromCalcElement,
@@ -239,13 +253,12 @@ function xprRewriteFns( model ) {
       expandedRootType,
     };
 
-    const hasError = rewriteAnnotationExpr( target[annoName], config );
-    target.$contains ??= {};
-    target.$contains.$annotation ??= {};
-    target.$contains.$annotation.$path ||= origin.$contains.$annotation.$path;
-    target.$contains.$annotation.$self ||= origin.$contains.$annotation.$self;
-    if (hasError)
-      anno.$invalidPaths = true; // avoid subsequent errors
+    if (propName.charAt( 0 ) === '@')
+      return rewriteAnnotationExpr( destination[propName], config );
+    return traverseExpr.STOP === traverseExpr(
+      destination[propName], 'annoRewrite', destination,
+      // eslint-disable-next-line @stylistic/max-len, @stylistic/function-paren-newline
+      (e, refCtx) => (rewriteAnnoExpr( e, config, refCtx ) ? traverseExpr.STOP : traverseExpr.SKIP) );
   }
 
   /**
@@ -291,9 +304,11 @@ function xprRewriteFns( model ) {
       return reportAnnoRewriteError( expr, config, 'unsupported' );
 
     if (root.kind === 'key') {
-      // Foreign keys can't be renamed and since we don't have absolute references to foreign keys,
-      // i.e. `$self.assoc.target_id` always refers to the target side, we don't have to rewrite
-      // them.
+      // References starting with a foreign key name (only possible in an
+      // annotation on a foreign key) have length 1 + the foreign key cannot be
+      // renamed → nothing to do. Otherwise, foreign keys cannot be directly
+      // addressed, except as `annotate` target. (Even as annotation value for
+      // foreign keys, `$self.assoc.target_id` always refers to the target side.)
       return null;
     }
 
@@ -341,8 +356,10 @@ function xprRewriteFns( model ) {
       // only understand the string representation.  But we only do so for simple strings, which
       // is the case if this path expression has $tokenTexts. It then is of the form `@a: (path)`.
       const isSimpleStep = step => !step.where && !step.args && isSimpleCdlIdentifier( step.id );
-      if (expr.path.every(isSimpleStep))
-        expr.$tokenTexts = expr.path.map( step => step.id ).join('.');
+      if (expr.path.every(isSimpleStep)) {
+        expr.$tokenTexts = (expr.scope === 'param' ? ':' : '') +
+                            expr.path.map( step => step.id ).join('.');
+      }
     }
 
     if (model.options.testMode) {
@@ -454,8 +471,10 @@ function xprRewriteFns( model ) {
 
     for (let i = startIndex; i < expr.path.length; ++i) {
       if (i > startIndex && art.target) {
-        // if the current artifact is an association, we need to respect the redirection
-        // chain from original target to new one.
+        // If the current artifact is an association, we need to respect the redirection
+        // chain from original target to new one.  We need to use '_originalArtifact' due
+        // to secondary associations and their redirection chains. See comment in
+        // test3/Redirections/SecondaryAssocs/RedirectedPathRewriteOne.cds
         // FIXME: Won't work with associations in projected structures.
         const origTarget = expr.path[i - 1]?._originalArtifact?.target?._artifact;
         const chain = cachedRedirectionChain( art, origTarget );
@@ -489,9 +508,10 @@ function xprRewriteFns( model ) {
   }
 
   /**
-   * Rewrite an expression that came via type propagation.
+   * Rewrite the initial part of a path in an expression that came via type
+   * propagation or via propagation with ref-only calculated element.
    *
-   * @returns {boolean} Returns the expression if it couldn't be rewritten.
+   * @returns {boolean} Returns true if it couldn't be rewritten.
    */
   function adaptPathPrefixViaType( expr, config ) {
     const { target, origin } = config;
@@ -502,7 +522,8 @@ function xprRewriteFns( model ) {
       return true;
 
     // $self-paths via types from/to non-main artifacts always need to be rewritten.
-    config.tokenExpr.$tokenTexts = true;
+    if (config.tokenExpr)
+      config.tokenExpr.$tokenTexts = true;
 
     const wasAbsolute = isAnnoPathAbsolute( expr );
     stripAbsolutePathPrefix( expr, origin );
@@ -526,6 +547,15 @@ function xprRewriteFns( model ) {
     return false;
   }
 
+  /**
+   * Rewrite the initial part of a path in an expression starting with $self on an
+   * expanded element:
+   *
+   *  - nothing to do when not starting with $self (TODO: param?)
+   *  - otherwise error if options.beta.rewriteAnnotationExpressionsViaType is not set
+   *
+   * @returns {boolean} Returns true if it couldn't be rewritten.
+   */
   function adaptPathPrefixViaTypeExpansion( expr, config ) {
     const root = expr.path[0]?._navigation;
     if (root?.kind !== '$self') {
@@ -548,7 +578,8 @@ function xprRewriteFns( model ) {
 
     config.target[config.anno].$inferred = 'anno-rewrite';
     // $self-paths via type expansion always need to be rewritten.
-    config.tokenExpr.$tokenTexts = true;
+    if (config.tokenExpr)
+      config.tokenExpr.$tokenTexts = true;
 
     return false;
   }
@@ -586,7 +617,7 @@ function xprRewriteFns( model ) {
     if (relativeRoot >= 1)
       expr.path = expr.path.slice(relativeRoot);
     else if (relativeRoot === -1)
-      throw new CompilerAssertion('Error while rewriting annotation');
+      throw new CompilerAssertion( 'Error while rewriting annotation' );
   }
 
   /**
@@ -632,7 +663,7 @@ function xprRewriteFns( model ) {
    * @returns {number}
    */
   function findRelativeRoot( expr, origin ) {
-    if (!origin._main) // main artifacts can't have outer references
+    if (!origin._main) // main artifacts can't have outer references: $self → 0, -1 otherwise
       return expr.path[0]?._artifact === origin ? 0 : -1;
 
     const { path } = expr;
@@ -703,7 +734,8 @@ function xprRewriteFns( model ) {
     const item = expr.path[index];
     if (item.id !== found.name.id || (rewriteTarget[1] - index) !== 0) {
       // Path was rewritten; original token text string is no longer accurate
-      config.tokenExpr.$tokenTexts = true;
+      if (config.tokenExpr)
+        config.tokenExpr.$tokenTexts = true;
       item.id = found.name.id;
     }
 

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.