@sap/cds-compiler 4.6.2 → 4.7.4

package/lib/transform/odata/flattening.js

@@ -0,0 +1,419 @@
+'use strict';
+
+const { isBuiltinType, isMagicVariable, forEachDefinition,
+  copyAnnotations, forEachMemberRecursively,
+  transformExpression, findAnnotationExpression } = require('../../model/csnUtils');
+const transformUtils = require('../transformUtils');
+const { setProp, isBetaEnabled } = require('../../base/model');
+const { applyTransformationsOnDictionary,
+  applyTransformationsOnNonDictionary } = require('../db/applyTransformations.js');
+const { linkForeignKeyAnnotationExtensionsToAssociation,
+  handleManagedAssociationsAndCreateForeignKeys } = require('../db/flattening');
+const { cloneCsnNonDict } = require('../../model/cloneCsn');
+const { forEach } = require('../../utils/objectUtils');
+
+function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options) {
+
+  const isExprAnno = (obj, pn) => {
+    return isBetaEnabled(options, 'odataPathsInAnnotationExpressions') && findAnnotationExpression(obj, pn);
+  }
+
+  forEachDefinition(csn, (def, defName) => {
+    if(def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
+      ['elements', 'params'].forEach(dictName => {
+        const dict = def[dictName];
+        if(dict) {
+          const csnPath = ['definitions', defName, dictName];
+          const orderedElementList = [];
+
+          forEach(dict, (eltName, elt) => {
+            const location = [ ...csnPath, eltName ];
+            const resolvedElt = (elt.type && !elt.elements) ? csnUtils.getFinalTypeInfo(elt.type) : elt;
+            if(resolvedElt.elements) {
+              const flattenedSubTree = recurseIntoElement(dictName, elt, resolvedElt,
+                !!elt.notNull, location, [ defName, eltName ]);
+
+              flattenedSubTree.forEach(([flatEltName, flatElt]) => {
+                if (dict[flatEltName] || orderedElementList.some(elt => elt[0] === flatEltName))
+                  error('name-duplicate-element', location,
+                        { '#': 'flatten-element-exist', name: flatEltName });
+                propagateToFlatElem(elt, flatElt);
+                rewriteOnCondition(flatElt, flattenedSubTree);
+                orderedElementList.push([flatEltName, flatElt]);
+              });
+            }
+            else {
+              const flatElt = cloneElt(dictName, elt, location, [ defName, eltName ]);
+              orderedElementList.push([eltName, flatElt]);
+            }
+          });
+
+          const flatDict = orderedElementList.reduce((elements, [ flatEltName, flatElt ]) => {
+            if(flatElt.items) {
+              // rewrite annotation paths inside items.elements
+              forEachMemberRecursively(flatElt.items, (elt, _eltName, _prop, path) => {
+                const exprAnnos = Object.keys(elt).filter(pn => isExprAnno(elt, pn));
+                flattenAndPrefixExprPaths(elt, exprAnnos, elt.$path, path, 0, true);
+              }, [ flatEltName ], true, { pathWithoutProp: true } );
+            }
+            setProp(flatElt, '$path', [ ...csnPath, flatEltName ]);
+            elements[flatEltName] = flatElt;
+            return elements;
+          }, Object.create(null));
+          setProp(def, `$${dictName}`, flatDict);
+        }
+      });
+      const flatAnnos = Object.create(null);
+      const annoNames = copyAnnotations(def, flatAnnos).filter(an => isExprAnno(def, an));
+      flattenAndPrefixExprPaths(flatAnnos, annoNames, [ 'definitions', defName ], [ defName ], 0);
+      setProp(def, '$flatAnnotations', flatAnnos);
+    }
+  });
+
+  function recurseIntoElement(scope, elt, resolvedElt, rootPathIsNotNull, location, rootPrefix = [], typeIdx = 0) {
+    const eltName = rootPrefix[rootPrefix.length-1];
+    if(!resolvedElt.elements) {
+      const flatElt = cloneElt(scope, elt, location, rootPrefix, typeIdx);
+      if(rootPathIsNotNull)
+        flatElt.notNull = true;
+      else
+        delete flatElt.notNull;
+      return [[ eltName, flatElt ]];
+    }
+    else {
+      let flattenedSubTree = [];
+      forEach(resolvedElt.elements, (childName, child) => {
+        resolvedElt = child;
+        if(child.type && !child.elements) {
+          resolvedElt = csnUtils.getFinalTypeInfo(child.type);
+          if(resolvedElt.elements)
+            typeIdx = rootPrefix.length + 1;
+        }
+        flattenedSubTree = flattenedSubTree.concat(recurseIntoElement(scope, child, resolvedElt,
+          !!(child.notNull && rootPathIsNotNull),
+          [... location, 'elements', childName], 
+          [ ...rootPrefix, childName ], typeIdx));
+      });
+      // 1) rename, 2) filter duplicates and finalize new elements
+      const duplicateDict = Object.create(null);
+      return flattenedSubTree.map(([flatEltName, flatElt]) => {
+        return [ `${eltName}_${flatEltName}`, flatElt ];
+      }).filter(([name, flatElt]) =>{
+        if(duplicateDict[name]) {
+          error('name-duplicate-element', location,
+          { '#': 'flatten-element-gen', name });
+          return false;
+        }
+        else {
+          propagateToFlatElem(elt, flatElt, rootPrefix, typeIdx);
+          duplicateDict[name] = flatElt;
+          return true;
+        }
+      })
+    }
+  }
+
+  function propagateToFlatElem(elt, flatElt, rootPrefix = [], typeIdx = 0) {
+    // Copy annotations from struct
+    // (not overwriting, because deep annotations should have precedence).
+    // This has historic reasons. We don't copy doc-comments because copying annotations
+    // is questionable to begin with.  Only selected annotations should have been copied,
+    // if at all.
+    // When flattening structured elements for OData don't propagate the odata.Type annotations
+    // as these would falsify the flattened elements.
+
+    // TODO: directly refer to edmPrimitiveType facets
+    const excludes = {
+      '@odata.Type': 1,
+      '@odata.Scale': 1,
+      '@odata.Precision': 1,
+      '@odata.MaxLength': 1,
+      '@odata.SRID': 1,
+      '@odata.FixedLength': 1,
+      '@odata.Collation': 1,
+      '@odata.Unicode': 1,
+    };
+    // TODO: copy only those expression annotations that have no path into unreachable subtree, starting
+    // of typePathRoot (which could be some completely different path)
+    const exprAnnoNames = copyAnnotations(elt, flatElt, false, excludes).filter(pn => isExprAnno(flatElt, pn));
+    flattenAndPrefixExprPaths(flatElt, exprAnnoNames, elt.$path, rootPrefix, typeIdx);
+    // Copy selected type properties
+    ['key', 'virtual', 'masked', 'viaAll', 'localized'].forEach(p => {
+      if (elt[p] != null)
+        flatElt[p] = elt[p];
+    });
+  }
+
+  // Copy the original element
+  function cloneElt(scope, elt, location, rootPrefix = [], typeIdx = 0) {
+    const flatElt = cloneCsnNonDict(elt,
+      { ...options,
+        hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ]
+      } );
+
+    // needed for @cds.persistence.name
+    setProp(flatElt, '$defPath', rootPrefix);
+    setProp(flatElt, '$scope', scope);
+    retypeCloneWithFinalBaseType(flatElt, location);
+
+    const [ nonAnnoProps, exprAnnoProps ] = Object.keys(flatElt).reduce((acc, pn) => {
+      if(pn[0] !== '@' && pn !== 'value')
+        acc[0].push(pn);
+      if(isExprAnno(flatElt, pn) || pn === 'value')
+        acc[1].push(pn);
+      return acc;
+    }, [[],[]]);
+    // transform all non annotation properties for that flat element with the generic transformer
+    // we don't know what's inside the element clone (like anonymous sub elements behind 'items' etc.)
+    nonAnnoProps.forEach(pn => applyTransformationsOnNonDictionary(flatElt, pn, refFlattener, {}, elt.$path || location))
+    adaptRefs.forEach(fn => fn());
+    adaptRefs.length = 0;
+    // flatten and prefix annotations and 'value' paths
+    flattenAndPrefixExprPaths(flatElt, exprAnnoProps, elt.$path || location, rootPrefix, typeIdx);
+    return flatElt;
+
+    function retypeCloneWithFinalBaseType(elt, location) {
+      if(elt.type &&
+           !isBuiltinType(elt.type) &&
+           !isODataV4BuiltinFromService(elt.type, location)
+           && !isItemsType(elt.type)) {
+        let resolvedType = csnUtils.getFinalTypeInfo(elt);
+  
+        delete resolvedType.kind;
+        if(resolvedType.items)
+          delete resolvedType.type;
+  
+        if(elt.items) {
+          if(resolvedType.items) {
+            elt.items = resolvedType;
+            delete elt.items.type;
+          }
+          else
+            elt.items.type = resolvedType;
+        }
+        else {
+          if(resolvedType.items) {
+            elt.items = resolvedType.items;
+            delete elt.type;
+          }
+          else
+            elt.type = resolvedType;
+        }
+      }
+  
+      function isItemsType(typeName) {
+        let typeDef = csn.definitions[typeName];
+        return !!typeDef?.items;
+      }
+  
+      function isODataV4BuiltinFromService( typeName, path ) {
+        if (options.odataVersion === 'v2' || typeof typeName !== 'string')
+          return false;
+      
+        const typeServiceName = csnUtils.getServiceName(typeName);
+        let finalBaseType = csnUtils.getFinalTypeInfo(typeName).type;
+        if(!isBuiltinType(finalBaseType)) {
+          const typeDef = csn.definitions[finalBaseType];
+          finalBaseType = typeDef?.items?.type || typeDef?.type;
+        }
+        // we need the service of the current definition
+        const currDefServiceName = csnUtils.getServiceName(path[1]);
+        return typeServiceName === currDefServiceName && isBuiltinType(finalBaseType);
+      }
+    }
+  }
+
+  // The path rewriting must be done with the current CSN  path of that exact annotation location
+  // in the element tree and done exactly after the initial copy, (otherwise, csnRefs is not able 
+  // to locate the relative location of the path expression in this element).
+  // At this time both annotations and values must be rewritten.
+  //
+  // Later, the query can/must be rewritten as long as a flat OData CSN is published
+  // but this then operates on the entity/view which has all struct infos available
+  function flattenAndPrefixExprPaths(carrier, propNames, csnPath, rootPrefix, typeIdx, refParentIsItems = false) {
+    refFlattener.$refParentIsItems = refParentIsItems;
+    const refCheck = {
+      ref: (parent, prop, xpr, path) => {
+        const { art } = inspectRef(path);
+        const ft = csnUtils.getFinalTypeInfo(art?.type);
+        if(!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+          error('odata-anno-xpr-ref', path, { elemref: parent, name: refCheck.eltLocationStr, anno: refCheck.anno, '#': 'flatten_builtin' });
+        }
+      }
+    }
+
+    refCheck.eltLocationStr = (function() {
+      const [head, ...tail ] = rootPrefix;
+      return `${head}:${tail.join('.')}`;
+    })();
+
+    const absolutifier = {
+      ref : (parent, prop, xpr) => {
+        const head = xpr[0].id || xpr[0];
+        if(typeIdx > 0 && head === '$self' && !isMagicVariable(head)) {
+          const [xprHead, ...xprTail] = xpr.slice(1, xpr.length);
+          parent[prop] = [ rootPrefix.slice(1, typeIdx).concat(xprHead).join('_'), ...xprTail];
+          if(carrier.$scope === 'params')
+            parent.param = true;
+          else
+            parent[prop].unshift('$self');
+        }
+        else if(rootPrefix.length > 2 && head !== '$self' && !parent.param && !isMagicVariable(head)) {
+          const [xprHead, ...xprTail] = xpr;
+          if(!refParentIsItems)
+            parent[prop] = [ rootPrefix.slice(1, -1).concat(xprHead).join('_'), ...xprTail];
+          else
+            parent[prop] = [ ...rootPrefix.slice(0, rootPrefix.length-1), ...xpr];
+          if(carrier.$scope === 'params')
+            parent.param = true;
+          else
+            parent[prop].unshift('$self');
+        }
+      }
+    }
+    
+    propNames.forEach(pn => {
+      refCheck.anno = pn;
+      transformExpression(carrier, pn, [ refCheck, refFlattener ], csnPath);
+    });
+    adaptRefs.forEach(fn => fn());
+    adaptRefs.length = 0;
+    refFlattener.$refParentIsItems = false;
+    propNames.forEach(pn => {
+      transformExpression(carrier, pn, absolutifier, csnPath)
+    })
+  }
+
+  // TODO: This should be part of the generic path rewriting algorithm
+  // Primitive approach here does not take into account absolute paths via $self etc...
+  function rewriteOnCondition(flatElt, flattenedSubTree) {
+    if (flatElt.on) {
+      // unmanaged relations can't be primary key
+      delete flatElt.key;
+      // Make refs resolvable by fixing the first ref step
+      transformExpression(flatElt, 'on', {
+        ref: (parent, prop, xpr) => {
+          const prefix = flatElt.$defPath.slice(1, -1).join('_');
+          const possibleFlatName = `${prefix}_${xpr[0]}`;
+          if (flattenedSubTree.find(entry => entry[0] === possibleFlatName))
+            xpr[0] = possibleFlatName;
+        }
+      });
+    }
+  }
+}
+
+/**
+ * Rewrite all structured references in the model such that it matches their flat counterparts
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {WeakMap} resolved Cache for resolved refs
+ * @param {string} pathDelimiter
+ * @param {object} iterateOptions
+ */
+function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, iterateOptions = {} ) {
+
+  // All anno path flattening is already done, don't do it on locations where we don't want it!
+  forEachDefinition(csn, (def, defName) => {
+    if(def.kind === 'entity') {
+      ['query', 'projection'].forEach(dictName => {
+        applyTransformationsOnNonDictionary(csn.definitions[defName], dictName, refFlattener, iterateOptions, [ 'definitions', defName ]);
+      })
+      if(csn.definitions[defName].actions)
+        applyTransformationsOnDictionary(csn.definitions[defName].actions, refFlattener, iterateOptions, [ 'definitions', defName, 'actions' ]);
+    }
+      /*
+        TODO: In real hybrid flat/struct OData transformation, ref rewriting in types must not be done
+              together with non-rewriting ON condition refs during foreign key creation
+      */
+    if(['type'].includes(def.kind)) {
+      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, iterateOptions, [ 'definitions' ]);
+    }
+  });
+  adaptRefs.forEach(fn => fn());
+  adaptRefs.length = 0;
+}
+
+function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, pathDelimiter) {
+  const { flattenStructStepsInRef } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  /**
+   * For each step of the links, check if there is a type reference.
+   * If there is, resolve it and store the result in a WeakMap.
+   *
+   * @param {Array} [links]
+   * @todo seems too hacky
+   * @returns {WeakMap} A WeakMap where a link is the key and the type is the value
+   */
+  function resolveLinkTypes( links = [] ) {
+    const resolvedLinkTypes = new WeakMap();
+    links.forEach((link) => {
+      const { art } = link;
+      if (art && art.type)
+        resolvedLinkTypes.set(link, effectiveType(art));
+    });
+    return resolvedLinkTypes;
+  }
+  const adaptRefs = [];
+  const transformer = {
+    $refParentIsItems: false,
+    ref: (parent, prop, ref, path) => {
+      const { links, art, scope } = inspectRef(path);
+      const resolvedLinkTypes = resolveLinkTypes(links);
+      setProp(parent, '$path', [ ...path ]);
+      const lastRef = ref[ref.length - 1];
+      const fn = () => {
+        const scopedPath = [ ...parent.$path ];
+        // TODO: If foreign key annotations should be assigned via
+        //       full path into target, uncomment this line and
+        //       comment/remove setProp in expansion.js
+        // setProp(parent, '$structRef', parent.ref);
+        parent.ref = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, transformer.$refParentIsItems);
+        resolved.set(parent, { links, art, scope });
+        // Explicitly set implicit alias for things that are now flattened - but only in columns
+        // TODO: Can this be done elegantly during expand phase already?
+        if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
+          if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+            delete parent.as;
+          delete parent.$implicitAlias;
+        }
+        // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
+        else if (parent.ref[parent.ref.length - 1] !== lastRef &&
+                    (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
+                    !parent.as) {
+          parent.as = lastRef;
+        }
+
+        /**
+         * Return true if the path points inside columns
+         *
+         * @param {CSN.Path} path
+         * @returns {boolean}
+         */
+        function insideColumns( path ) {
+          return path.length >= 3 && (path[path.length - 3] === 'SELECT' || path[path.length - 3] === 'projection') && path[path.length - 2] === 'columns';
+        }
+        /**
+         * Return true if the path points inside keys
+         *
+         * @param {CSN.Path} path
+         * @returns {boolean}
+         */
+        function insideKeys( path ) {
+          return path.length >= 3 && path[path.length - 2] === 'keys' && typeof path[path.length - 1] === 'number';
+        }
+      };
+      // adapt queries later
+      adaptRefs.push(fn);
+    },
+  }
+
+  return { adaptRefs, transformer, inspectRef, effectiveType };
+}
+
+module.exports = {
+  allInOneFlattening,
+  flattenAllStructStepsInRefs,
+  linkForeignKeyAnnotationExtensionsToAssociation,
+  handleManagedAssociationsAndCreateForeignKeys,
+  getStructRefFlatteningTransformer
+};

package/lib/transform/odata/toFinalBaseType.js

@@ -1,18 +1,23 @@
 'use strict';
 
-const { isBetaEnabled } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 const {
-  forEachDefinition, forEachGeneric, forEachMemberRecursively,
-  isBuiltinType, cloneCsnDictionary, cloneCsnNonDict,
+  transformExpression,
+  forEachDefinition,
+  forEachGeneric,
+  forEachMemberRecursively,
+  isBuiltinType,
+  findAnnotationExpression, 
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
+const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
 
-function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
+function expandToFinalBaseType(csn, transformers, csnUtils, services, options, error) {
   const isV4 = options.odataVersion === 'v4';
   const special$self = !csn?.definitions?.$self && '$self';
   forEachDefinition(csn, (def, defName) => {
     // Unravel derived type chains to final one for elements, actions, action parameters (propagating annotations)
-    forEachMemberRecursively(def, (member) => {
+    forEachMemberRecursively(def, (member, _memberName) => {
       expandToFinalBaseType(member, defName);
       expandToFinalBaseType(member.items, defName);
       expandToFinalBaseType(member.returns, defName);
@@ -85,7 +90,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
     if (def.items.type && !isBuiltinType(def.items.type)) {
       let finalBaseType = csnUtils.getFinalTypeInfo(def.items.type);
       if (finalBaseType?.elements) {
-        def.items.elements = cloneCsnDictionary(finalBaseType.elements, options);
+        def.items.elements = cloneCsnDict(finalBaseType.elements, options);
         delete def.items.type;
       }
     }
@@ -138,7 +143,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
                 transformers.toFinalBaseType(node);
               }
               else if (csnUtils.isStructured(finalBaseType)) {
-                cloneElements(finalBaseType);
+                cloneElements(node, finalBaseType);
               }
               else if (node.type && node.items)
                 delete node.type;
@@ -169,8 +174,8 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
                 transformers.toFinalBaseType(node);
                 // node.type = finalType;
               }
-              else if (node.type && node.type.ref) {
-                cloneElements(finalBaseType);
+              else if (node.type.ref) {
+                cloneElements(node, finalBaseType);
               }
             }
           }
@@ -189,26 +194,78 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
       }
     }
 
-    function cloneElements(finalBaseType) {
-      // cloneCsn only works correctly if we start "from the top"
+    function cloneElements(node, finalBaseType) {
       let clone;
       // do the clone only if really needed
       if((finalBaseType.items && !node.items) ||
-         (finalBaseType.elements && !node.elements))
-        clone = cloneCsnNonDict({ definitions: { 'TypeDef': finalBaseType } }, options);
+         (finalBaseType.elements && !node.elements)) {
+        // use the 'real' type, don't clone a clone
+        let _type = node._type;
+        while(_type._type && !_type.items && !_type.elements)
+          _type = _type._type;
+        clone = cloneCsnNonDict(_type, { ...options, hiddenPropertiesToClone: [ '_type' ] });
+        fitClonedElementsIntoParent(clone, node, _type.$path);
+      }
       if (finalBaseType.items) {
         delete node.type;
         if(!node.items)
-          Object.assign(node, { items: clone.definitions.TypeDef.items });
+          Object.assign(node, { items: clone.items });
       }
       if (finalBaseType.elements) {
         if(!finalBaseType.items)
           delete node.type;
         if(!node.elements)
-          Object.assign(node, { elements: clone.definitions.TypeDef.elements });
+          Object.assign(node, { elements: clone.elements });
       }
     }
 
+    function fitClonedElementsIntoParent(clone, node, typeRefCsnPath) {
+      const f = (p) => {
+        const [h, ...t ] = p;
+        return `${h}:${t.join('.')}`;
+      }
+      const typeRefStr = f(node.type.ref);
+      const typeRefRootPath = $path2path(typeRefCsnPath);
+      forEachMemberRecursively(clone, (elt, eltName, prop, location) => {
+        const [ xprANames /*nxprANames */ ] = Object.keys(elt).reduce((acc, pn) => {
+          if (pn[0] === '@')
+            acc[findAnnotationExpression(elt, pn) ? 0 : 1].push(pn);
+          return acc;
+        }, [ [], [] ]);
+        const usingPositionStr = f($path2path(location));
+        const eltRootPath = $path2path(elt.$path);
+        xprANames.forEach(xprAName => {
+          //let isSubTreeSpan = true;
+          transformExpression(elt, xprAName, {
+            ref: (parent, prop, xpr, csnPath) => {
+              let prefixMatch = true;
+              const head = xpr[0].id || xpr[0];
+              if (head === '$self') {
+                for (let i = 1; i < typeRefRootPath.length && prefixMatch; i++){
+                  prefixMatch = (xpr[i].id || xpr[i]) === typeRefRootPath[i];
+                }
+                if(prefixMatch && xpr.length > typeRefRootPath.length) {
+                  parent[prop] = [ ...xpr.slice(eltRootPath.length-1)];
+                }
+                else {
+                  error('odata-anno-xpr-ref', csnPath,
+                  { anno: xprAName, elemref: xpr.join('.'), name: usingPositionStr, code: typeRefStr });
+                  //isSubTreeSpan = false;
+                }              
+              }
+            },
+          }, elt.$path);
+          // if(!isSubTreeSpan) {
+          //   // remove annotation and sub annotations from cloned element
+          //   delete elt[xprAName];
+          //   nxprANames.filter(an => an.startsWith(`${xprAName}.`)).forEach((nxprAName) => {
+          //     delete elt[nxprAName];
+          //   });
+          // }
+        });
+        setProp(elt, '$path', location);
+      }, node.$path);
+    }
     /*
       Check, if a type needs to be expanded into the service
 
@@ -227,6 +284,29 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options) {
       const isInCurServ = isArtifactInService(node.type, currService);
       return !isV4 || !(isBuiltin && !isAssoc && isInCurServ);
     }
+
+// convert $path to path starting at main artifact
+    function $path2path( p ) {
+      const path = [];
+      let env = csn;
+      for (let i = 0; p && env && i < p.length; i++) {
+        const ps = p[i];
+        env = env[ps];
+        if (env && env.constructor === Object) {
+          path.push(ps);
+      // jump over many items but not if this is an element
+          if (env.items) {
+            env = env.items;
+            if (p[i + 1] === 'items')
+              i++;
+          }
+          if (env.type && !isBuiltinType(env.type) && !env.elements)
+            env = csn.definitions[env.type];
+        }
+      }
+      return path;
+    }
+
   }
 }
 

package/lib/transform/odata/typesExposure.js

@@ -8,10 +8,10 @@
 
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { getNamespace, copyAnnotations, cloneCsnNonDict,
-  isBuiltinType, isAnnotationExpression, 
-  forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
+const { getNamespace, copyAnnotations, isBuiltinType, findAnnotationExpression,
+  forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered } = require('../../model/csnUtils');
 const { CompilerAssertion } = require('../../base/error');
+const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 /**
  * A given CDS model is a set of n definitions D = {v_1, ..., v_n } spanning a type dependency
@@ -144,7 +144,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} serviceName
    * @param {String} newTypeName
    */
-  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName, isTermDef=false) {
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName, isTermDef=false, ignoreInAPI=false) {
     const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable();
     if (isExposable) {
       // this is the name used to register the new type in csn.definitions
@@ -183,10 +183,12 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         if(elements) {
           newType = createNewStructType(elements);
           // if using node enforces open/closed, set it on type
-          if(node['@open'] !== undefined)
+          if (node['@open'] !== undefined)
             newType['@open'] = node['@open']
           if (node.$location)
             setProp(newType, '$location', node.$location);
+          ignoreInAPI ||= !isEdmPropertyRendered(node, options);
+          setProp(newType, '$ignoreInAPI', ignoreInAPI);
 
           csn.definitions[fullQualifiedNewTypeName] = newType;
           exposedTypes[fullQualifiedNewTypeName] = 1;
@@ -198,7 +200,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
             defName = typeDef.kind === 'type' ? typeName : defName;
             {
               const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
-                            getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName, isTermDef);
+                            getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName, isTermDef, ignoreInAPI);
               // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
               // been caught by expandToFinalBaseType() (forODataNew must not modify external imported services)
               if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
@@ -223,7 +225,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           // expression annos and their sub annotations are not propagated to type
           let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
             if (pn[0] === '@')
-              acc[isAnnotationExpression(typeDef[pn]) ? 0 : 1].push(pn);
+              acc[findAnnotationExpression(typeDef, pn) ? 0 : 1].push(pn);
             return acc;
           }, [ [], [] ]);
           nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));