@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/transform/odata/structureFlattener.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { copyAnnotations } = require('../../model/csnUtils');
-const { setProp } = require('../../base/model');
 const { cloneCsn, forEachDefinition } = require('../../model/csnUtils');
 const { attachPathOnPartialCSN } = require('./attachPath');
 
@@ -50,13 +49,12 @@ const { isNotNull, setNotNull, setUpNotNull } = function () {
  * During the OData transformations in flat-mode, all structured elements will be flattened.
  * This module performs the complete flattening.
  * It also provides information to the reference flattener: elements produced for specific path in the CSN structure.
- * Each generated element gets hidden attributes:
- *  - _flatElementNameWithDots - names in the element path concatenated with dot
  * @param {CSN.Model} csn CSN-object to flatten
  * @param {*} csnUtils instances of utility functions
  * @param {*} options
  * @param {*} referenceFlattener
  * @param {Function} error
+ * @param {Function} isExternalServiceMember returns true for an artifact that is part of an external service
  */
 function flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExternalServiceMember) {
   forEachDefinition(csn, (def, defName, propertyName, path) =>
@@ -76,17 +74,22 @@ function flattenDefinition(definition, definitionPath, csnUtils, options, refere
   if (definition.kind !== 'entity' && definition.kind !== 'view')
     return;
 
-  let { newFlatElements } = flattenStructure(definition, definitionPath, csnUtils, options, error, referenceFlattener);
+  let { newFlatElements } = flattenStructure(definition.elements, definitionPath, csnUtils, options, error, referenceFlattener);
 
   attachPathOnPartialCSN(newFlatElements, definitionPath.concat('elements'));
-
   definition.elements = newFlatElements;
+
+  if (definition.params) {
+    let { newFlatElements } = flattenStructure(definition.params, definitionPath, csnUtils, options, error, referenceFlattener);
+    attachPathOnPartialCSN(newFlatElements, definitionPath.concat('params'));
+    definition.params = newFlatElements;
+  }
 } // flattenDefinition
 
 /**
  * Flattens structured element by calling element flattener for each structured child.
  * Returns a dictionary containing all the new elements for the given structure.
- * @param {*} struct the structure to flatten
+ * @param {*} dictionary to flatten
  * @param {CSN.Path} path the path of the structure in the CSN tree
  * @param {*} csnUtils
  * @param {Function} error Error message function
@@ -95,14 +98,14 @@ function flattenDefinition(definition, definitionPath, csnUtils, options, refere
  * @param {*} [newFlatElements]
  * @param {boolean} [isTopLevelElement] states if this is a top level element
  */
-function flattenStructure(struct, path, csnUtils, options, error, referenceFlattener = undefined, elementPathInStructure = [],
+function flattenStructure(dictionary, path, csnUtils, options, error, referenceFlattener = undefined, elementPathInStructure = [],
   newFlatElements = Object.create(null), isTopLevelElement = true, isParentNotNull = false) {
 
-  if (!isTopLevelElement) addPropsForPropagationFromElement(struct);
+  if (!isTopLevelElement) addPropsForPropagationFromElement(dictionary);
 
   let generatedNewFlatElementsNames = []; // holds the names of all new child elements of the structure
 
-  struct.elements && Object.entries(struct.elements).forEach(([elementName, element]) => {
+  dictionary && Object.entries(dictionary).forEach(([elementName, element]) => {
     let currPath = path.concat('elements', elementName);
 
     if (isTopLevelElement) {
@@ -120,8 +123,8 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
       addPropsForPropagationFromElement(element);
 
       // if the child element is structured itself -> needs to be flattened
-      const subStruct = element.elements ? element : csnUtils.getFinalBaseType(element.type);
-      let result = flattenStructure(subStruct, currPath, csnUtils, options, error, referenceFlattener, elementPathInStructure.concat(elementName), newFlatElements, false, isNotNull());
+      const elements = element.elements || csnUtils.getFinalBaseType(element.type).elements;
+      let result = flattenStructure(elements, currPath, csnUtils, options, error, referenceFlattener, elementPathInStructure.concat(elementName), newFlatElements, false, isNotNull());
       generatedNewFlatElementsNames.push(...result.generatedNewFlatElementsNames); // accomulate names of produced elements
 
     } else { // when we do not need to flat, this is scalar or empty (cds-compiler#4337) -> needs to be registered in referenceFlattener
@@ -129,7 +132,6 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
       let elementNameWithDots = elementPathInStructure.concat(elementName).join('.');
       addNewElementToResult(element, newElementName, elementNameWithDots, currPath);
     }
-
   });
 
   if (referenceFlattener) {
@@ -137,30 +139,29 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
   }
   return { newFlatElements, generatedNewFlatElementsNames };
 
-
   // adds newly created element into the final dictionary of elements
   function addNewElementToResult(element, elementName, elementNameWithDots, path) {
     if (newFlatElements[elementName]) {
       error(null, path, `Generated element ${elementName} conflicts with other generated element`);
     } else {
-      let newElement = createNewElement(element, elementNameWithDots);
+      let newPath = path.slice(0, 2).concat('elements', elementName);
+      let newElement = createNewElement(element, elementNameWithDots, newPath);
       newFlatElements[elementName] = newElement;
       generatedNewFlatElementsNames.push(elementName);
 
       if (referenceFlattener) {
-        let newPath = path.slice(0, 2).concat('elements', elementName);
         referenceFlattener.registerElementTransition(path, newPath);
       }
     }
   } // addNewElementToResult
 
   // creates new element by copying the properties of the originating element
-  function createNewElement(element, elementNameWithDots) {
+  function createNewElement(element, elementNameWithDots, path) {
     let newElement = cloneCsn(element, options);
     if (!isTopLevelElement) propagatePropsToElement(newElement);
     if (isNotNull() === undefined) delete newElement.notNull;
-    if (!isTopLevelElement) {
-      setProp(newElement, '_flatElementNameWithDots', elementNameWithDots);
+    if (!isTopLevelElement && referenceFlattener) {
+      referenceFlattener.setElementNameWithDots(path, elementNameWithDots);
     }
     return newElement;
   } // createNewElement

package/lib/transform/odata/typesExposure.js

@@ -25,7 +25,6 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
   // collect in this variable all the newly exposed types
   const exposedStructTypes = [];
   const schemas = Object.create(null);
-
   // walk through the definitions of the given CSN and expose types where needed
   forEachDefinition(csn, (def, defName, propertyName, path) => {
     // we do expose types only for definition from inside services
@@ -33,11 +32,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
     if (serviceName) {
       if (['type', 'entity', 'view'].includes(def.kind)) {
         forEachMember(def, (element, elementName, propertyName, path) => {
-          if (propertyName === 'elements' || propertyName === 'params') {
+          if (['elements', 'params'].includes(propertyName)) {
             const artificialtName = `${isMultiSchema ?
               defNameWithoutServiceOrContextName(defName, serviceName)
               : defNameWithoutServiceOrContextName(defName, serviceName).replace(/\./g, '_')}_${elementName}`;
-            exposeTypeOf(element, elementName, defName, serviceName, artificialtName, path);
+            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, artificialtName, path);
           }
         }, path);
       }
@@ -64,11 +63,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
    * @param {string} artificialName
    * @param {CSN.Path} path
    */
-  function exposeTypeOf(node, memberName, defName, service, artificialName, path) {
+  function exposeTypeOf(node, isKey, memberName, defName, service, artificialName, path) {
     if (isArrayed(node))
-      exposeArrayOfTypeOf(node, memberName, defName, service, artificialName, path);
+      exposeArrayOfTypeOf(node, isKey, memberName, defName, service, artificialName, path);
     else if (csnUtils.isStructured(node))
-      exposeStructTypeOf(node, memberName, defName, service, artificialName, path);
+      exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path);
   }
 
   /**
@@ -90,12 +89,12 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
   function exposeTypesOfAction(action, actionName, defName, service, path) {
     if (action.returns) {
       const artificialName = `return_${actionName.replace(/\./g, '_')}`;
-      exposeTypeOf(action.returns, actionName, defName, service, artificialName, path.concat(['returns']));
+      exposeTypeOf(action.returns, false, actionName, defName, service, artificialName, path.concat(['returns']));
     }
 
     action.params && Object.entries(action.params).forEach(([paramName, param]) => {
       const artificialName = `param_${actionName.replace(/\./g, '_')}_${paramName}`;
-      exposeTypeOf(param, actionName, defName, service, artificialName, path.concat(['params', paramName]));
+      exposeTypeOf(param, false, actionName, defName, service, artificialName, path.concat(['params', paramName]));
     });
   }
 
@@ -108,9 +107,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
    * @param {String} service
    * @param {String} artificialName
    */
-  function exposeStructTypeOf(node, memberName, defName, service, artificialName, path, parentName) {
+  function exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path, parentName) {
+    if (node.items) exposeStructTypeOf(node.items, isKey, memberName, defName, service, artificialName, path);
 
-    if (node.items) exposeStructTypeOf(node.items, memberName, defName, service, artificialName, path);
+    // start conservative, assume we're in a named type
+    let isAnonymous = false;
 
     if (isExposableStructure(node)) {
       let typeDef = node.type ? csnUtils.getCsnDef(node.type) : /* structure|anonymous type */ node;
@@ -124,6 +125,11 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
       // and the new target. Consequently, we now have both type and elements properties in this case, and the elements should be taken as a priority
       // as the correct target is there and no longer in the type definition
       let newTypeElements = (node.type && node.elements) ? node.elements : typeDef.elements;
+      // if node and typeDef are identical, we're anonymous
+      isAnonymous = node === typeDef;
+      // if we've left the anonymous world, we're no longer in a key def
+      if (!isAnonymous)
+        isKey = false;
 
       let newType = exposeStructType(newTypeFullName, newTypeElements, memberName, path);
       if (!newType) {
@@ -138,6 +144,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
       newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
         if (node.elements && node.elements[elemName].$location) setProp(newElem, '$location', node.elements[elemName].$location);
         exposeStructTypeOf(newElem,
+          isKey,
           memberName,
           typeDef.kind === 'type' ? node.type : defName,
           service,
@@ -251,6 +258,9 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
           error(null, path, `"${elemName}": Element name conflicts with existing element`);
         }
         let cloned = cloneCsn(element, options);
+        // if this was an anonymous sub element of a key, mark it as not nullable
+        if(isAnonymous && isKey && !cloned.key && cloned.notNull === undefined)
+          cloned.notNull = true;
         type.elements[elemName] = cloned;
       });
 
@@ -265,12 +275,12 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
 
   // If a member is of type "array of <named type|anonymous type>", we expose the arrayed type,
   // like we expose structures in structured mode
-  function exposeArrayOfTypeOf(node, memberName, defName, service, artificialName, path) {
+  function exposeArrayOfTypeOf(node, isKey, memberName, defName, service, artificialName, path) {
     // if anonymously defined in place -> we always expose the type
     // this would be definition like 'elem: array of { ... }'
     // and we use the artificial name for the new type name
     if (node.items && !node.type) {
-      exposeStructTypeOf(node.items, memberName, defName, service, artificialName, path.concat('items'));
+      exposeStructTypeOf(node.items, isKey, memberName, defName, service, artificialName, path.concat('items'));
     }
     // we can have both of the 'type' and 'items' in the cases:
     // 1. 'elem: Foo' and 'type Foo: array of Baz' and 'type Baz: { ... }'

package/lib/transform/transformUtilsNew.js

@@ -8,9 +8,8 @@ const { hasErrors, makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
 
-const { copyAnnotations } = require('../model/csnUtils');
-const { cloneCsn, forEachMemberRecursively, forEachGeneric, forAllQueries,
-  getUtils, isBuiltinType } = require('../model/csnUtils');
+const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
+const { cloneCsn, getUtils, isBuiltinType } = require('../model/csnUtils');
 
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
@@ -62,6 +61,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     recurseElements,
     renameAnnotation,
     setAnnotation,
+    resetAnnotation,
     expandStructsInExpression,
   };
 
@@ -80,6 +80,14 @@ function getTransformers(model, options, pathDelimiter = '_') {
       else if(defStrLen5k)
         element.length = 5000;
     }
+    if (element.type === 'cds.Binary' && element.length === undefined) {
+      if(options.defaultBinaryLength) {
+        element.length = options.defaultBinaryLength;
+        setProp(element, '$default', true);
+      }
+      else if(defStrLen5k)
+        element.length = 5000;
+    }
   /*
     if (element.type === 'cds.Decimal' && element.precision === undefined && options.precision) {
       element.precision = options.precision;
@@ -287,56 +295,64 @@ function getTransformers(model, options, pathDelimiter = '_') {
     return result;
   }
 
-  // Return a copy of 'ref' where all path steps resulting from struct traversal are
-  // fused together into one step, using '_' (so that the path fits again for flattened
-  // structs), e.g.
-  //   [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
-  //   [ (Entity), (struct1_struct2_assoc), (elem) ]
-  // 'path' is the csn path to the ref
-  function flattenStructStepsInRef(ref, path) {
+  /**
+   * Return a copy of 'ref' where all path steps resulting from struct traversal are
+   * fused together into one step, using '_' (so that the path fits again for flattened
+   * structs), e.g.
+   *  [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
+   *  [ (Entity), (struct1_struct2_assoc), (elem) ]
+   *
+   * @param {string[]} ref 
+   * @param {CSN.Path} path CSN path to the ref
+   * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
+   * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
+   * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
+   * @returns {string[]}
+   */
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap()) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2) {
       return ref;
     }
 
-    try {
-      return flatten(ref, path);
-    } catch (e) {
-      if (e.message && e.message === "Scope 'ref-target' but no entity was provided.") {
-        // TODO: should not happen anymore
-        return flatten(ref, path);
-      } else {
-        throw e;
-      }
-    }
+    return flatten(ref, path);
 
     function flatten(ref, path) {
       let result = [];
       //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
-      const { links, scope } = inspectRef(path);
+      if(!links && !scope) { // calculate JIT if not supplied
+        const res = inspectRef(path);
+        links = res.links;
+        scope = res.scope;
+      }
       if (scope === '$magic')
         return ref;
       let flattenStep = false;
       links.forEach((value, idx) => {
-        if (flattenStep)
-          result[result.length - 1] += pathDelimiter + ref[idx];
+        if (flattenStep) {
+          result[result.length - 1] += pathDelimiter + (ref[idx].id ? ref[idx].id : ref[idx]);
+          // if we had a filter or args, we had an assoc so this step is done
+          // we then keep along the filter/args by updating the id of the current ref
+          if(ref[idx].id) {
+            ref[idx].id = result[result.length-1];
+            result[result.length-1] = ref[idx];
+          }
+        }
         else {
           result.push(ref[idx]);
         }
-        flattenStep = value.art && !(value.art.kind === 'entity') && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements);
+
+        flattenStep = value.art && !value.art.kind && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements || (resolvedLinkTypes.get(value)||{}).elements);
       });
-      const magicVars = ['$now']
-      // If the path starts with '$self', this is now redundant (because of flattening) and can be omitted,
-      // making life easier for consumers
-      if (result[0] === '$self' && result.length > 1 && !magicVars.includes(result[1])) {
-        result = result.slice(1);
-      }
+
       return result;
     }
   }
 
   /**
    * Copy properties of the referenced type, but don't resolve to the final base type.
+   * 
+   * Do not copy the length if it was just set via the default-value.
    *
    * @param {any} node Node to copy to
    * @returns {void}
@@ -366,24 +382,31 @@ function getTransformers(model, options, pathDelimiter = '_') {
       Object.assign(node, { srid: typeDef.srid });
   }
 
-  // Replace the type of 'node' with its final base type (in contrast to the compiler,
-  // also unravel derived enum types, i.e. take the final base type of the enum's base type.
-  // Similar with associations and compositions (we probably need a _baseType link)
-  function toFinalBaseType(node) {
+  /**
+   * Replace the type of 'node' with its final base type (in contrast to the compiler,
+   * also unravel derived enum types, i.e. take the final base type of the enum's base type.
+   * Similar with associations and compositions (we probably need a _baseType link)
+   *
+   * @param {CSN.Artifact} node 
+   * @param {WeakMap} [resolved] WeakMap containing already resolved refs
+   * @param {boolean} [keepLocalized=false] Wether to clone .localized from a type def
+   * @returns {void}
+   */
+  function toFinalBaseType(node, resolved, keepLocalized=false) {
     // Nothing to do if no type (or if array/struct type)
     if (!node || !node.type) return;
     // In case of a ref -> Follow the ref
     if (node.type && node.type.ref) {
-      let finalBaseType = getFinalBaseType(node.type);
+      const finalBaseType = getFinalBaseType(node.type, undefined, resolved);
       if(finalBaseType === null)
         throw Error('Failed to obtain final base type for reference : ' + node.type.ref.join('/'));
-      if (finalBaseType.elements) {
-        // ATTENTION: This should be cloneCsnDictionary() but that would
-        //            change the foreign key order in many tests!
-        node.elements = cloneCsn(finalBaseType.elements, options); // copy elements
+      if(finalBaseType.elements) {
+          // This changes the order - to be discussed!
+        node.elements = cloneCsn(finalBaseType, options).elements; // copy elements
         delete node.type; // delete the type reference as edm processing does not expect it
-      } else if (finalBaseType.items) {
-        node.items = cloneCsn(finalBaseType.items, options); // copy items
+      } else if(finalBaseType.items) {
+          // This changes the order - to be discussed!
+        node.items = cloneCsn(finalBaseType, options).items; // copy items
         delete node.type;
       } else {
         node.type=finalBaseType;
@@ -396,10 +419,31 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // The type might already be a full fledged type def (array of)
     let typeDef = typeof node.type === 'string' ? getCsnDef(node.type) : node.type;
     // Nothing to do if type is an array or a struct type
-    if (typeDef.items || typeDef.elements) return;
+    if (typeDef.items || typeDef.elements) {
+      if(!(options.transformation === 'hdbcds' || options.toSql))
+        return;
+
+      // cloneCsn only works correctly if we start "from the top"
+      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options);
+      // With hdbcds-hdbcds, don't resolve structured types - but propagrate ".items", to turn into LargeString later on.
+      if(typeDef.items) {
+        delete node.type;
+        Object.assign(node, {items: clone.definitions.TypeDef.items});
+      }
+      if(typeDef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
+        if(!typeDef.items)
+          delete node.type;
+        Object.assign(node, {elements: clone.definitions.TypeDef.elements});
+      }
+
+
+      return;
+    }
     // if the declared element is an enum, these values are with priority
-    if (!node.enum && typeDef.enum)
-      Object.assign(node, { enum: cloneCsn(typeDef.enum, options) });
+    if (!node.enum && typeDef.enum) {
+      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options).definitions.TypeDef.enum;
+      Object.assign(node, { enum: clone });
+    }
     if (node.length === undefined && typeDef.length !== undefined)
       Object.assign(node, { length: typeDef.length });
     if (node.precision === undefined && typeDef.precision !== undefined)
@@ -408,6 +452,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
       Object.assign(node, { scale: typeDef.scale });
     if (node.srid === undefined && typeDef.srid !== undefined)
       Object.assign(node, { srid: typeDef.srid });
+    if (keepLocalized && node.localized === undefined && typeDef.localized !== undefined)
+      Object.assign(node, { localized: typeDef.localized });
     node.type = typeDef.type;
     toFinalBaseType(node);
   }
@@ -888,6 +934,34 @@ function getTransformers(model, options, pathDelimiter = '_') {
       node[name] = value;
   }
 
+  /**
+   * Assigns unconditionally annotation to a node, which means it overwrites already existing annotation assignment.
+   * Overwritting is when the assignment differs from undefined and null, also when differs from the already set value.
+   * Setting new assignment results false as return value and overwriting - true.
+   *
+   * @param {object} node Assignee
+   * @param {string} name Annotation name
+   * @param {any} value Annotation value
+   * @param {function} info function that reports info messages
+   * @param {CSN.Path} path location of the warning
+   * @returns {boolean} wasOverwritten true when the annotation was overwritten
+   */
+  function resetAnnotation(node, name, value, info, path) {
+    if (!name.startsWith('@')) {
+      throw Error('Annotation name should start with "@": ' + name);
+    }
+    if (value === undefined) {
+      throw Error('Annotation value must not be undefined');
+    }
+
+    const wasOverwritten = node[name] !== undefined && node[name] !== null && node[name] !== value;
+    const oldValue = node[name];
+    node[name] = value;
+    if(wasOverwritten)
+      info(null, path, { anno: name, prop: value, otherprop: oldValue },
+      `Value $(OTHERPROP) of annotation $(ANNO) is overwritten with new value $(PROP)`);
+    return wasOverwritten;
+  }
 
   /*
     Resolve the type of an artifact
@@ -969,7 +1043,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function flattenPath(path, fullRef=false, followMgdAssoc=false) {
     let art = path._art;
     if(art) {
-      if(art && art.type && !((art.items && art.items.elements) || art.elements)) {
+      if(art && !((art.items && art.items.elements) || art.elements)) {
         if(followMgdAssoc && art.target && art.keys) {
           let rc = [];
           for(const k of art.keys) {
@@ -982,9 +1056,9 @@ function getTransformers(model, options, pathDelimiter = '_') {
           }
           return rc;
         }
-        if(art.type.ref)
+        if(art.type && art.type.ref)
           art = resolvePath(art.type);
-        else if(!isBuiltinType(art.type))
+        else if(art.type && !isBuiltinType(art.type))
           art = model.definitions[art.type];
       }
       const elements = art.items && art.items.elements || art.elements;
@@ -1006,41 +1080,33 @@ function getTransformers(model, options, pathDelimiter = '_') {
     return [path];
   }
 
-/*
+  /**
    * Expand structured expression arguments to flat reference paths.
    * Structured elements are real sub element lists and managed associations.
    * All unmanaged association definitions are rewritten if applicable (elements/mixins).
-   * Also, HAVING and WHERE clauses are rewritten.
+   * Also, HAVING and WHERE clauses are rewritten. We also check for infix filters and 
+   * .xpr in columns.
    *
-   * TODO: Check if can be skipped for abstract entity  and or cds.persistence.skip ?
-  */
-  function expandStructsInExpression(artifact, artifactName, prop, path) {
-    forEachMemberRecursively(artifact,
-      (elem, elemName, prop, path) => {
-        if(prop === 'elements') {
-          if(elem.target && elem.on) {
-            elem.on = expand(elem.on, path)
-          }
-        }
-      }, path);
-
-    if(artifact.query) {
-      forAllQueries(artifact.query, (query, queryPath) => {
-        if(query.SELECT) {
-          if(query.SELECT.mixin)
-            forEachGeneric(query.SELECT, 'mixin', (mixin, mixinName, prop, path) => {
-              if(mixin.target && mixin.on) {
-                mixin.on = expand(mixin.on, path);
-              }
-            },
-          path);
-          if(query.SELECT.having)
-            query.SELECT.having = expand(query.SELECT.having, queryPath.concat(['SELECT', 'having']))
-          if(query.SELECT.where)
-            query.SELECT.where = expand(query.SELECT.where, queryPath.concat(['SELECT', 'where']))
-        }
-      }, path.concat([ 'query' ]));
-    }
+   * @todo Check if can be skipped for abstract entity  and or cds.persistence.skip ?
+   * @param {CSN.Model} csn
+   * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts
+   */
+  function expandStructsInExpression(csn, options = {}) {
+    applyTransformations(csn, {
+      'on': (parent, name, on, path) => {
+        parent.on = expand(parent.on, path);
+      },
+      'having': (parent, name, having, path) => {
+        parent.having = expand(parent.having, path);
+      },
+      'where': (parent, name, where, path) => {
+        parent.where = expand(parent.where, path);
+      },
+      'xpr': (parent, name, xpr, path) => {
+        parent.xpr = expand(parent.xpr, path);
+      }
+    }, undefined, undefined, options);
+
     /*
       flatten structured leaf types and return array of paths
       Flattening stops on all non-structured types.