@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/transform/odata/flattening.js

@@ -5,7 +5,7 @@ const { forEachDefinition,
   transformExpression, findAnnotationExpression } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { applyTransformationsOnDictionary,
   applyTransformationsOnNonDictionary } = require('../db/applyTransformations.js');
 const { linkForeignKeyAnnotationExtensionsToAssociation,
@@ -14,30 +14,25 @@ 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)) {
+    if (def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
       ['elements', 'params'].forEach(dictName => {
         const dict = def[dictName];
-        if(dict) {
+        if (dict) {
           const csnPath = ['definitions', defName, dictName];
           const orderedElementList = [];
 
           forEach(dict, (childName, child) => {
             const location = [ ...csnPath, childName ];
-            let rootPrefix = [ defName ];
+            const rootPrefix = [ defName ];
             let resolvedElt = child;
             let typeIdx = 0;
-            if(child.type && !child.elements) {
+            if (child.type && !child.elements) {
               resolvedElt = csnUtils.getFinalTypeInfo(child.type);
-              if(resolvedElt.elements)
+              if (resolvedElt.elements)
                 typeIdx = rootPrefix.length + 1;
             }
-            if(resolvedElt.elements) {
+            if (resolvedElt.elements) {
               const flattenedSubTree = recurseIntoElement(dictName, child, resolvedElt,
                 !!child.notNull, location, [ ...rootPrefix, childName ], typeIdx);
 
@@ -57,10 +52,10 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
           });
 
           const flatDict = orderedElementList.reduce((elements, [ flatEltName, flatElt ]) => {
-            if(flatElt.items) {
+            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));
+                const exprAnnos = Object.keys(elt).filter(pn => findAnnotationExpression(elt, pn));
                 flattenAndPrefixExprPaths(elt, exprAnnos, elt.$path, path, 0, true);
               }, [ flatEltName ], true, { pathWithoutProp: true } );
             }
@@ -71,18 +66,74 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
           setProp(def, `$flat${dictName}`, flatDict);
         }
       });
+      // entity annotations
       const flatAnnos = Object.create(null);
-      const annoNames = copyAnnotations(def, flatAnnos).filter(an => isExprAnno(def, an));
+      const annoNames = copyAnnotations(def, flatAnnos).filter(an => findAnnotationExpression(def, an));
       flattenAndPrefixExprPaths(flatAnnos, annoNames, [ 'definitions', defName ], [ defName ], 0);
       setProp(def, '$flatAnnotations', flatAnnos);
+      // explicit binding parameter of bound action
+      if (def.actions) {
+        const special$self = !csn?.definitions?.$self && '$self';
+        Object.entries(def.actions).forEach(([actionName, action]) => {
+          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)
+                    setProp(parent, '$bparam', true)
+                },
+              };
+              const refCheck = {
+                ref: (elemref, prop, xpr, path) => {
+                  const { art, scope } = inspectRef(path);
+                  if (scope !== '$magic' && art) {
+                    const ft = csnUtils.getFinalTypeInfo(art.type);
+                    if (!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+                      error('odata-anno-xpr-ref', path, { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
+                    }
+                  }
+                }
+              };
+
+              const flatAnnos = Object.create(null);
+              const annoNames = copyAnnotations(action, flatAnnos).filter(an => findAnnotationExpression(action, an));
+              annoNames.forEach((an) => {
+                refCheck.anno = an;
+                transformExpression(flatAnnos, an,
+                  [ markBindingParam, refCheck, refFlattener ],
+                  [ 'definitions', defName, 'actions',  actionName ]);
+                adaptRefs.forEach(fn => fn(true, 1, (parent) => parent.$bparam));
+                adaptRefs.length = 0;
+              });
+              setProp(action, '$flatAnnotations', flatAnnos);
+
+              forEachMemberRecursively(action, (member, memberName, prop, path, _parent) => {
+                const exprAnnos = Object.keys(member).filter(pn => findAnnotationExpression(member, pn));
+                exprAnnos.forEach((pn) => {
+                  refCheck.anno = pn;
+                  transformExpression(member, pn, [ markBindingParam, refCheck, refFlattener ], path);
+                  adaptRefs.forEach(fn => fn(true, 1, (parent) => parent.$bparam));
+                  adaptRefs.length = 0;
+                });
+              },
+              [ 'definitions', defName, 'actions',  actionName ]);
+            }
+          }
+        });
+      }
     }
   });
 
   function recurseIntoElement(scope, elt, resolvedElt, rootPathIsNotNull, location, rootPrefix = [], typeIdx = 0) {
     const eltName = rootPrefix[rootPrefix.length-1];
-    if(!resolvedElt.elements) {
+    if (!resolvedElt.elements) {
       const flatElt = cloneElt(scope, elt, location, rootPrefix, typeIdx);
-      if(rootPathIsNotNull)
+      if (rootPathIsNotNull)
         flatElt.notNull = true;
       else
         delete flatElt.notNull;
@@ -92,9 +143,9 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       let flattenedSubTree = [];
       forEach(resolvedElt.elements, (childName, child) => {
         resolvedElt = child;
-        if(child.type && !child.elements) {
+        if (child.type && !child.elements) {
           resolvedElt = csnUtils.getFinalTypeInfo(child.type);
-          if(resolvedElt.elements)
+          if (resolvedElt.elements)
             typeIdx = rootPrefix.length + 1;
         }
         flattenedSubTree = flattenedSubTree.concat(recurseIntoElement(scope, child, resolvedElt,
@@ -107,7 +158,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       return flattenedSubTree.map(([flatEltName, flatElt]) => {
         return [ `${eltName}_${flatEltName}`, flatElt ];
       }).filter(([name, flatElt]) =>{
-        if(duplicateDict[name]) {
+        if (duplicateDict[name]) {
           error('name-duplicate-element', location,
           { '#': 'flatten-element-gen', name });
           return false;
@@ -143,7 +194,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
     };
     // 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));
+    const exprAnnoNames = copyAnnotations(elt, flatElt, false, excludes).filter(pn => findAnnotationExpression(flatElt, pn));
     flattenAndPrefixExprPaths(flatElt, exprAnnoNames, elt.$path, rootPrefix, typeIdx);
     // Copy selected type properties
     ['key', 'virtual', 'masked', 'viaAll', 'localized'].forEach(p => {
@@ -165,9 +216,9 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
     retypeCloneWithFinalBaseType(flatElt, location);
 
     const [ nonAnnoProps, exprAnnoProps ] = Object.keys(flatElt).reduce((acc, pn) => {
-      if(pn[0] !== '@' && pn !== 'value')
+      if (pn[0] !== '@' && pn !== 'value')
         acc[0].push(pn);
-      if(isExprAnno(flatElt, pn) || pn === 'value')
+      if (findAnnotationExpression(flatElt, pn) || pn === 'value')
         acc[1].push(pn);
       return acc;
     }, [[],[]]);
@@ -181,18 +232,18 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
     return flatElt;
 
     function retypeCloneWithFinalBaseType(elt, location) {
-      if(elt.type &&
+      if (elt.type &&
            !isBuiltinType(elt.type) &&
            !isODataV4BuiltinFromService(elt.type, location)
            && !isItemsType(elt.type)) {
-        let resolvedType = csnUtils.getFinalTypeInfo(elt);
+        const resolvedType = csnUtils.getFinalTypeInfo(elt);
 
         delete resolvedType.kind;
-        if(resolvedType.items)
+        if (resolvedType.items)
           delete resolvedType.type;
 
-        if(elt.items) {
-          if(resolvedType.items) {
+        if (elt.items) {
+          if (resolvedType.items) {
             elt.items = resolvedType;
             delete elt.items.type;
           }
@@ -200,7 +251,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             elt.items.type = resolvedType;
         }
         else {
-          if(resolvedType.items) {
+          if (resolvedType.items) {
             elt.items = resolvedType.items;
             delete elt.type;
           }
@@ -210,7 +261,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       }
 
       function isItemsType(typeName) {
-        let typeDef = csn.definitions[typeName];
+        const typeDef = csn.definitions[typeName];
         return !!typeDef?.items;
       }
 
@@ -220,7 +271,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
 
         const typeServiceName = csnUtils.getServiceName(typeName);
         let finalBaseType = csnUtils.getFinalTypeInfo(typeName).type;
-        if(!isBuiltinType(finalBaseType)) {
+        if (!isBuiltinType(finalBaseType)) {
           const typeDef = csn.definitions[finalBaseType];
           finalBaseType = typeDef?.items?.type || typeDef?.type;
         }
@@ -239,66 +290,87 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
   // 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) {
+
     const refCheck = {
       ref: (elemref, prop, xpr, path) => {
-        const { art } = (elemref._art ? { art: elemref._art } : inspectRef(path));
-        const ft = csnUtils.getFinalTypeInfo(art?.type);
-        if(!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
-          error('odata-anno-xpr-ref', path, { anno: refCheck.anno, elemref, name: refCheck.eltLocationStr, '#': 'flatten_builtin' });
+        const { art, scope } = inspectRef(path);
+        if (scope !== '$magic' && art) {
+          const ft = csnUtils.getFinalTypeInfo(art.type);
+          if (!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+            error('odata-anno-xpr-ref', path,
+              {
+                anno: refCheck.anno,
+                elemref,
+                name: refCheck.eltLocationStr,
+                '#': 'flatten_builtin'
+              });
+          }
         }
       }
     }
 
     refCheck.eltLocationStr = (function() {
       const [head, ...tail ] = rootPrefix;
-      return `${head}:${tail.join('.')}`;
+      if(tail.length)
+        return `${head}:${tail.join('.')}`;
+      else
+        return `${head}`;
     })();
 
+    let refChanged = false;
     const absolutifier = {
       ref : (parent, prop, xpr) => {
         const head = xpr[0].id || xpr[0];
-        if(typeIdx < rootPrefix.length && head === '$self' && !isMagicVariable(head)) {
-          const [xprHead, ...xprTail] = xpr.slice(1, xpr.length);
-          if(xprHead.id) {
-            xprHead.id = rootPrefix.slice(1, typeIdx).concat(xprHead.id).join('_');
-            parent[prop] = [ xprHead, ...xprTail ];
+        let isPrefixed = false;
+        if(!isMagicVariable(head)) {
+          if (head === '$self' && typeIdx < rootPrefix.length) {
+            isPrefixed = true;
+            const [xprHead, ...xprTail] = xpr.slice(1, xpr.length);
+            if(xprHead) {
+              if (xprHead.id) {
+                xprHead.id = rootPrefix.slice(1, typeIdx).concat(xprHead.id).join('_');
+                parent[prop] = [ xprHead, ...xprTail ];
+              }
+              else
+                parent[prop] = [ rootPrefix.slice(1, typeIdx).concat(xprHead).join('_'), ...xprTail];
+            }
           }
-          else
-            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) {
-            if(xprHead.id) {
-              xprHead.id = rootPrefix.slice(1, -1).concat(xprHead.id).join('_');
-              parent[prop] = [ xprHead, ...xprTail ];
+          else if (head !== '$self' && !parent.param && rootPrefix.length > 2) {
+            isPrefixed = true;
+            const [xprHead, ...xprTail] = xpr;
+            if (!refParentIsItems) {
+              if (xprHead.id) {
+                xprHead.id = rootPrefix.slice(1, -1).concat(xprHead.id).join('_');
+                parent[prop] = [ xprHead, ...xprTail ];
+              }
+              else
+                parent[prop] = [ rootPrefix.slice(1, -1).concat(xprHead).join('_'), ...xprTail];
             }
             else
-              parent[prop] = [ rootPrefix.slice(1, -1).concat(xprHead).join('_'), ...xprTail];
+              parent[prop] = [ ...rootPrefix.slice(0, rootPrefix.length-1), ...xpr];
+          }
+          if(isPrefixed) {
+            if (carrier.$scope === 'params')
+              parent.param = true;
+            else
+              parent[prop].unshift('$self');
           }
-          else
-            parent[prop] = [ ...rootPrefix.slice(0, rootPrefix.length-1), ...xpr];
-          if(carrier.$scope === 'params')
-            parent.param = true;
-          else
-            parent[prop].unshift('$self');
         }
+        if(isPrefixed)
+          refChanged = isPrefixed;
       }
     }
-
     propNames.forEach(pn => {
+      refChanged = false;
       refCheck.anno = pn;
       transformExpression(carrier, pn, [ refCheck, refFlattener ], csnPath);
-    });
-    adaptRefs.forEach(fn => fn(refParentIsItems));
-    adaptRefs.length = 0;
-    propNames.forEach(pn => {
+      adaptRefs.forEach(fn =>
+        { if( fn(refParentIsItems)) refChanged = true });
+      adaptRefs.length = 0;
       transformExpression(carrier, pn, absolutifier, csnPath)
-    })
+      if(refChanged && carrier[pn]['='])
+      carrier[pn]['='] = true;
+    });
   }
 
   // TODO: This should be part of the generic path rewriting algorithm
@@ -320,57 +392,70 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
   }
 }
 
-function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef, effectiveType, csnUtils, error, options, iterateOptions = {} ) {
+function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef, effectiveType,
+    csnUtils, error, options, iterateOptions = {} ) {
 
   // All anno path flattening is already done, don't do it on locations where we don't want it!
   const typeNames = [];
   forEachDefinition(csn, (def, defName) => {
-    if(def.kind === 'entity') {
+    if (def.kind === 'entity') {
       ['query', 'projection'].forEach(dictName => {
-        applyTransformationsOnNonDictionary(csn.definitions[defName], dictName, refFlattener, iterateOptions, [ 'definitions', defName ]);
+        applyTransformationsOnNonDictionary(csn.definitions[defName],
+            dictName, refFlattener, iterateOptions,
+            [ 'definitions', defName ]);
       })
-      if(csn.definitions[defName].actions)
-        applyTransformationsOnDictionary(csn.definitions[defName].actions, refFlattener, iterateOptions, [ 'definitions', defName, 'actions' ]);
+      if (csn.definitions[defName].actions)
+        applyTransformationsOnDictionary(csn.definitions[defName].actions,
+          refFlattener, iterateOptions,
+          [ 'definitions', defName, 'actions' ]);
     }
 
-    if(['type'].includes(def.kind)) {
+    if (['type'].includes(def.kind)) {
       typeNames.push(defName);
-      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, iterateOptions, [ 'definitions' ]);
+      applyTransformationsOnNonDictionary(csn.definitions,
+        defName, refFlattener, iterateOptions, [ 'definitions' ]);
     }
   });
   adaptRefs.forEach(fn => fn());
   adaptRefs.length = 0;
-  if(isBetaEnabled(options, 'odataPathsInAnnotationExpressions')) {
-    const refCheck = {
-      ref: (elemref, prop, xpr, path) => {
-        const { links, art } = (elemref._links && elemref._art ? { links: elemref._links, art: elemref._art } : inspectRef(path) );
 
-        let i = links.length-2;
-        const getProp = (propName) =>
-          (links[i].art?.[propName] ||
-          effectiveType(links[i].art)[propName]);
-
-        const ft = csnUtils.getFinalTypeInfo(art?.type);
-        let target = undefined;
-        for(; i >= 0 && !getProp('items') && !target; i--) {
-          target = getProp('target');
-        }
-        if(target && csn.definitions[target].$flatelements && !isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
-          error('odata-anno-xpr-ref', path, { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
-        }
+  const refCheck = {
+    ref: (elemref, prop, xpr, path) => {
+      const { links, art } = (elemref._links && elemref._art
+        ? { links: elemref._links, art: elemref._art }
+        : inspectRef(path) );
+
+      let i = links.length-2;
+      const getProp = (propName) =>
+        (links[i].art?.[propName] ||
+        effectiveType(links[i].art)[propName]);
+
+      const ft = csnUtils.getFinalTypeInfo(art?.type);
+      let target = undefined;
+      for(; i >= 0 && !getProp('items') && !target; i--) {
+        target = getProp('target');
+      }
+      if (target && csn.definitions[target].$flatelements
+          && !isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+        error('odata-anno-xpr-ref', path,
+        { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
       }
     }
-    typeNames.forEach(tn => {
-      forEachMemberRecursively(csn.definitions[tn], (member, memberName, prop, csnPath) => {
-        Object.keys(member).filter(pn => pn[0] === '@').forEach(pn => {
-          refCheck.anno = pn;
-          transformExpression(member, pn, [ refCheck, refFlattener ], csnPath);
-        });
-      }, [ 'definitions', tn ]);
-    })
-    adaptRefs.forEach(fn => fn(true, 1));
-    adaptRefs.length = 0;
   }
+  typeNames.forEach(tn => {
+    forEachMemberRecursively(csn.definitions[tn], (member, memberName, prop, csnPath) => {
+      Object.keys(member).filter(pn => pn[0] === '@').forEach(pn => {
+        let refChanged = false;
+        refCheck.anno = pn;
+        transformExpression(member, pn, [ refCheck, refFlattener ], csnPath);
+        adaptRefs.forEach(fn => {
+          if (fn(true, 1)) refChanged = true });
+        adaptRefs.length = 0;
+        if(refChanged && member[pn]['='])
+          member[pn]['='] = true;
+      });
+    }, [ 'definitions', tn ]);
+  })
 }
 
 function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, pathDelimiter) {
@@ -395,32 +480,39 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
   const adaptRefs = [];
   const transformer = {
     ref: (parent, prop, ref, path) => {
+      let refChanged = false;
       const { links, art, scope } = inspectRef(path);
       const resolvedLinkTypes = resolveLinkTypes(links);
       setProp(parent, '$path', [ ...path ]);
       const lastRef = ref[ref.length - 1];
-      const fn = (suspend=false, suspendPos=0) => {
-        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, suspend, suspendPos);
-        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;
+      const fn = (suspend = false, suspendPos = 0, 
+                    refFilter = (_parent) => true) => {
+        if (refFilter(parent)) {
+          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, refChanged ] = flattenStructStepsInRef(ref,
+              scopedPath, links, scope, resolvedLinkTypes,
+              suspend, suspendPos, parent.$bparam);
+          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 refChanged;
         }
-
+        return false;
         /**
          * Return true if the path points inside columns
          *
@@ -428,7 +520,10 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
          * @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 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
@@ -437,7 +532,9 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
          * @returns {boolean}
          */
         function insideKeys( path ) {
-          return path.length >= 3 && path[path.length - 2] === 'keys' && typeof path[path.length - 1] === 'number';
+          return path.length >= 3
+            && path[path.length - 2] === 'keys'
+            && typeof path[path.length - 1] === 'number';
         }
       };
       // adapt queries later

package/lib/transform/odata/toFinalBaseType.js

@@ -88,7 +88,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
   // type Foo: array of { qux: Integer };
   function expandFirstLevelOfArrayed(def) {
     if (def.items.type && !isBuiltinType(def.items.type)) {
-      let finalBaseType = csnUtils.getFinalTypeInfo(def.items.type);
+      const finalBaseType = csnUtils.getFinalTypeInfo(def.items.type);
       if (finalBaseType?.elements) {
         def.items.elements = cloneCsnDict(finalBaseType.elements, options);
         delete def.items.type;

package/lib/transform/odata/typesExposure.js

@@ -8,7 +8,7 @@
 
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { getNamespace, copyAnnotations, findAnnotationExpression, 
+const { getNamespace, copyAnnotations, findAnnotationExpression,
   forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered } = require('../../model/csnUtils');
 const { isBuiltinType } = require('../../base/builtins');
 const { CompilerAssertion } = require('../../base/error');
@@ -77,18 +77,21 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     if (serviceName && requestedServiceNames.includes(serviceName)) {
       if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
-          if (propertyName === 'elements' || propertyName === 'params') {
+          if (propertyName === 'elements') {
             const newTypeName = getNewTypeName(element, elementName, defName, serviceName);
-            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, newTypeName, defName, path);
+            exposeTypeOf(element, element.key, elementName, defName, serviceName, newTypeName, defName, path);
+          } else if (propertyName === 'params') {
+            const newTypeName = getNewTypeName(element, elementName, `ep_${defName.replace(/\./g, '_')}`, serviceName);
+            exposeTypeOf(element, true, elementName, defName, serviceName, newTypeName, defName, path);
           }
         }, path);
       }
 
       if (def.kind === 'action' || def.kind === 'function') {
-        exposeTypesOfAction(def, defName, defName, serviceName, path);
+        exposeTypesOfAction(def, defName, defName, serviceName, path, false);
       }
       def.actions && Object.entries(def.actions).forEach(([actionName, action]) => {
-        exposeTypesOfAction(action, `${defName}_${actionName}`, defName, serviceName, path.concat(['actions', actionName]));
+        exposeTypesOfAction(action, `${defName}_${actionName}`, defName, serviceName, path.concat(['actions', actionName]), true);
       });
     }
   });
@@ -122,7 +125,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} actionName
    * @param {String} serviceName
    */
-  function exposeTypesOfAction(action, actionName, defName, serviceName, path) {
+  function exposeTypesOfAction(action, actionName, defName, serviceName, path, isBound) {
     if (action.returns) {
       const artificialName = `return_${actionName.replace(/\./g, '_')}`;
       const newTypeName = getNewTypeName(action.returns, undefined, artificialName, serviceName);
@@ -130,7 +133,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     }
 
     action.params && Object.entries(action.params).forEach(([paramName, param]) => {
-      const artificialName = `param_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
+      const artificialName = `${isBound ? 'bap' : 'ap'}_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
       const newTypeName = getNewTypeName(param, paramName, artificialName, serviceName);
       exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, defName, path.concat(['params', paramName]));
     });
@@ -254,7 +257,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         }
         else if(isTermDef) {
           newType = Object.create(null);
-          for(let n in typeDef) {
+          for(const n in typeDef) {
             newType[n] = typeDef[n];
           }
           newType.kind = 'type';
@@ -293,7 +296,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     function isTypeExposable() {
       let typeName = undefined;
       let typeDef = node;
-      let elements = (node.items?.elements || node.elements)
+      const elements = (node.items?.elements || node.elements)
       // anonymous structured type
       if(elements)
         return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
@@ -315,7 +318,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
                 typeName = (type.ref && csnUtils.artifactRef(type)) || type;
               }
               else {
-                throw new CompilerAssertion(`Please debug me: ${typeName} not found`);
+                throw new CompilerAssertion(`Debug me: ${typeName} not found`);
               }
             }
           }
@@ -372,7 +375,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
      * @param {string} parentName name of the parent def holding the element
      */
     function getAnonymousTypeNameInMultiSchema(typeName, parentName) {
-      let currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
+      const currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
       const newSchemaName = currPrefix || fallBackSchemaName;
       // new type name without any prefixes
       const typePlainName = defNameWithoutServiceOrContextName(typeName, newSchemaName);
@@ -403,7 +406,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
 
       // Duplicate elements
       Object.entries(elements).forEach(([elemName, element]) => {
-        let cloned = cloneCsnNonDict(element, options);
+        const cloned = cloneCsnNonDict(element, options);
         // if this was an anonymous sub element of a key, mark it as not nullable
         if(isAnonymous && isKey && !cloned.key) {
           if(cloned.target) {