@sap/cds-compiler 2.13.8 → 2.15.6

package/lib/transform/odata/typesExposure.js

@@ -8,35 +8,29 @@
 
 const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsn, isBuiltinType, forEachDefinition, forEachMember, cloneCsnDictionary } = require('../../model/csnUtils');
+const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
 
-/**
- * @param {CSN.Model} csn
- * @param {function} whatsMyServiceName
- * @param {CSN.Options} options
- * @param {*} csnUtils
- * @param {object} message message object with { error } function
- */
-function typesExposure(csn, whatsMyServiceName, autoexposeSchemaName, options, csnUtils, message) {
+function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.toOdata.version === 'v4' && (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs);
   // collect in this variable all the newly exposed types
-  const exposedStructTypes = [];
   const schemas = Object.create(null);
+  const exposedTypes = 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
     const serviceName = whatsMyServiceName(defName, false);
-    if (serviceName) {
+    // run type exposure only on requested services if not in multi schema mode
+    // multi schema mode requires a proper type exposure for all services as a prerequisite
+    // for the proxy exposure
+    if (serviceName && requestedServiceNames.includes(serviceName)) {
       if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
           if (propertyName === 'elements' || propertyName === 'params') {
-            const artificialtName = `${isMultiSchema ?
-              defNameWithoutServiceOrContextName(defName, serviceName)
-              : defNameWithoutServiceOrContextName(defName, serviceName).replace(/\./g, '_')}_${elementName}`;
-            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, artificialtName, path);
+            const newTypeName = getNewTypeName(element, elementName, defName, serviceName);
+            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, newTypeName, path);
           }
         }, path);
       }
@@ -55,46 +49,26 @@ function typesExposure(csn, whatsMyServiceName, autoexposeSchemaName, options, c
   });
 
   return schemas;
-  /**
-   * General function used for exposing  a type of given element
-   * @param {object} node
-   * @param {string} memberName
-   * @param {string} service
-   * @param {string} artificialName
-   * @param {CSN.Path} path
-   */
-  function exposeTypeOf(node, isKey, memberName, defName, service, artificialName, path) {
-    if (isArrayed(node))
-      exposeArrayOfTypeOf(node, isKey, memberName, defName, service, artificialName, path);
-    else if (csnUtils.isStructured(node))
-      exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path);
-  }
-
-  /**
-   * Check if a node is arrayed
-   * @param {object} node
-   */
-  function isArrayed(node) {
-    return node.items || (node.type && csnUtils.getFinalTypeDef(node.type).items);
-  }
 
-  /**
+/**
    * If an 'action' uses structured types as parameters or return values that are not exposed in 'service'
    * (because the types are anonymous or have a definition outside of 'service'),
    * create equivalent types in 'service' and make 'action' use them instead,
    * @param {Object} action
    * @param {String} actionName
-   * @param {String} service
+   * @param {String} serviceName
    */
-  function exposeTypesOfAction(action, actionName, defName, service, path) {
+  function exposeTypesOfAction(action, actionName, defName, serviceName, path) {
     if (action.returns) {
       const artificialName = `return_${actionName.replace(/\./g, '_')}`;
-      exposeTypeOf(action.returns, false, actionName, defName, service, artificialName, path.concat(['returns']));
+      const newTypeName = getNewTypeName(action.returns, undefined, artificialName, serviceName);
+      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, path.concat(['returns']));
     }
 
     action.params && Object.entries(action.params).forEach(([paramName, param]) => {
-      const artificialName = `param_${actionName.replace(/\./g, '_')}_${paramName}`;
-      exposeTypeOf(param, false, actionName, defName, service, artificialName, path.concat(['params', paramName]));
+      const artificialName = `param_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
+      const newTypeName = getNewTypeName(param, paramName, artificialName, serviceName);
+      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, path.concat(['params', paramName]));
     });
   }
 
@@ -104,93 +78,139 @@ function typesExposure(csn, whatsMyServiceName, autoexposeSchemaName, options, c
    * for a value of the 'node.type' property.
    * @param {Object} node
    * @param {String} memberName
-   * @param {String} service
-   * @param {String} artificialName
+   * @param {String} serviceName
+   * @param {String} newTypeName
    */
-  function exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path, parentName) {
-    if (node.items) exposeStructTypeOf(node.items, isKey, 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;
-      let newTypeId = node.type ? `${isMultiSchema ? node.type : node.type.replace(/\./g, '_')}` : artificialName;
-      let newTypeFullName =
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName) {
+    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable(node);
+    if (isExposable) {
+      // this is the name used to register the new type in csn.definitions
+      let fullQualifiedNewTypeName =
         isMultiSchema
-          ? node.type ? getTypeNameInMultiSchema(node.type, service) : getAnonymousTypeNameInMultiSchema(artificialName, parentName || defName)
-          : `${service}.${newTypeId}`;
+          ? (node.type || (node.items && node.items.type)
+              ? getTypeNameInMultiSchema(node.type|| (node.items && node.items.type), serviceName)
+              : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
+          : `${serviceName}.${newTypeName}`;
 
-      // With the redirection of sub elements, the element which is of named type with an association is now expanded and contains the association
-      // 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)
+      // as soon as we leave of the anonymous world,
+      // we're no longer in a key def => don't set notNull:true on named types
+      if (!isAnonymous && isKey)
         isKey = false;
 
-      let newType = exposeStructType(newTypeFullName, newTypeElements, memberName, path);
-      if (!newType) {
-        // Error already reported
-        return;
+      // check if that type is already defined
+      let newType = csn.definitions[fullQualifiedNewTypeName];
+      if (newType) {
+        // error, if it was not exposed by us
+        if (!exposedTypes[fullQualifiedNewTypeName]) {
+          error(null, path, `Cannot create artificial type "${fullQualifiedNewTypeName}" for "${memberName}" because the name is already used`);
+          return;
+        }
       }
+      else {
+        /* Expose new structured type
+         * Treat items.elements as ordinary elements for now.
+         */
+        newType = createNewStructType(elements);
+        if (node.$location)
+          setProp(newType, '$location', node.$location);
 
-      if (node.$location) setProp(newType, '$location', node.$location);
-      setProp(newType, '$exposedBy', 'typeExposure');
+        csn.definitions[fullQualifiedNewTypeName] = newType;
+        exposedTypes[fullQualifiedNewTypeName] = 1;
 
-      // Recurse into elements of 'type' (if any) and expose them as well (is needed)
-      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,
-          isMultiSchema ? `${newTypeFullName}_${elemName}` : `${newTypeId}_${elemName}`,
-          path,
-          newTypeFullName);
-      });
-      typeDef.kind === 'type' ? copyAnnotations(typeDef, newType) : copyAnnotations(node, newType);
-      delete node.elements;
-      node.type = newTypeFullName;
+        // Recurse into elements of 'type' (if any) and expose them as well (is needed)
+        newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
+          if (node.elements && node.elements[elemName].$location)
+            setProp(newElem, '$location', node.elements[elemName].$location);
+          defName = typeDef.kind === 'type' ? typeName : defName;
+          exposeTypeOf(newElem, isKey, elemName, defName, serviceName, 
+                       getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName);
+        });
+        copyAnnotations(typeDef, newType);
+        // if the origin type had items, add items to exposed type
+        if(typeDef.kind === 'type') {
+          if(typeDef.items) {
+            newType.items = { elements: newType.elements };
+            delete newType.elements;
+          }
+        }
+      }
+      // adjust current node to new type
+      if(node.items) {
+        delete node.items.elements;
+        delete node.type;
+        node.items.type = fullQualifiedNewTypeName;
+      }
+      else {
+        delete node.elements;
+        node.type = fullQualifiedNewTypeName;
+      }
     }
 
-    /**
-     * Returns whether the 'node' is for exposing the in service.
-     * There are 2 cases when we would like to expose a type is the service:
-     *  1. If the node is of user-defined type which is not part of the service
-     *  2. When we have structured element (the object has property 'elements')
-     * @param {Object} node
+     /**
+     * Check if the node's type can be exposed:
+     * 1) If it's an anonymous structured type (items.elements || elements)
+     * 2) If it's a named type resolve to the final type definition and
+     *    check if this is a structured type
+     * Returns an object that indicates 
+     *  - wether or not the type needs exposure
+     *  - the elements dictionary that needs to be cloned
+     *  - the typeDef, either the resolved type def or the node itself
+     *  - if structured type was anonymously defined
+     * @param {object} node
+     * @returns {object} { isExposable, typeDef, typeName, elements, isAnonymous }
      */
-    function isExposableStructure(node) {
-      let finalNodeType = node.type ? csnUtils.getFinalType(node.type) : undefined;
-      return finalNodeType && isArtifactInService(finalNodeType, service)
-        ? false
-        : csnUtils.isStructured(node);
+    function isTypeExposable(node) {
+      let typeName = undefined;
+      let typeDef = node;
+      let elements = (node.items && node.items.elements || node.elements)
+      // anonymous structured type
+      if(elements)
+        return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
+      // named type, resolve the type to inspect it
+      let type = node.items && node.items.type || node.type;
+      if(type) {
+        typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+        typeDef = csnUtils.getFinalTypeDef(typeName);
+        const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
+        if(!isBuiltinType(typeName) && !isArtifactInService(typeName, serviceName)) {
+          while(!isBuiltinType(typeName)) {
+            typeDef = csnUtils.getFinalTypeDef(typeName);
+            if(typeDef) {
+              if((rc.elements = (typeDef.items && typeDef.items.elements || typeDef.elements)) !== undefined)
+                return rc;
+              type = typeDef.items && typeDef.items.type || typeDef.type;
+              typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+            }
+            else {
+              throw Error(`Please debug me: ${typeName} not found`);
+            }
+          }
+        }
+      }
+      return { isExposable: false };
     }
 
+
     /**
      * Calculate the new type name that will be exposed in multi schema,
      * in case that the element has a named type.
      *
      * @param {string} typeName type of the element
-     * @param {string} service current service name
+     * @param {string} serviceName current service name
      */
-    function getTypeNameInMultiSchema(typeName, service) {
+    function getTypeNameInMultiSchema(typeName, serviceName) {
       const typeService = whatsMyServiceName(typeName);
       if (typeService) {
         // new type name without any prefixes
         const typePlainName = defNameWithoutServiceOrContextName(typeName, typeService);
-        const newSchemaName = `${service}.${typeService}`;
+        const newSchemaName = `${serviceName}.${typeService}`;
         createSchema(newSchemaName);
         // return the new type name
         return `${newSchemaName}.${typePlainName.replace(/\./g, '_')}`;
       } else {
         const typeContext = csnUtils.getContextOfArtifact(typeName);
         const typeNamespace = csnUtils.getNamespaceOfArtifact(typeName);
-        const newSchemaName = `${service}.${typeContext || typeNamespace || autoexposeSchemaName}`;
+        const newSchemaName = `${serviceName}.${typeContext || typeNamespace || fallBackSchemaName}`;
         // new type name without any prefixes
         const typePlainName = typeContext ? defNameWithoutServiceOrContextName(typeName, typeContext)
           : typeName.replace(`${typeNamespace}.`, '');
@@ -209,7 +229,7 @@ function typesExposure(csn, whatsMyServiceName, autoexposeSchemaName, options, c
      */
     function getAnonymousTypeNameInMultiSchema(typeName, parentName) {
       let currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
-      const newSchemaName = currPrefix || autoexposeSchemaName;
+      const newSchemaName = currPrefix || fallBackSchemaName;
       // new type name without any prefixes
       const typePlainName = defNameWithoutServiceOrContextName(typeName, newSchemaName);
 
@@ -222,121 +242,49 @@ function typesExposure(csn, whatsMyServiceName, autoexposeSchemaName, options, c
      * @param {string} name
      */
     function createSchema(name) {
-      schemas[`${name}`] = { kind: 'schema', name };
+      schemas[name] = { kind: 'schema', name };
     }
 
     /**
-     * Expose a new type definition in the 'definitions' of the CSN and return that type(reusing such a type
-     * if it already exists).
-     * The new type has name 'typeName', elements which are 'elements'.
-     * 'parentName' is used for error reporting.x
-     * @param {String} typeName
+     * create a new structured type for 'elements'
      * @param {Object} elements
-     * @param {String} parentName
      */
-    function exposeStructType(typeName, elements, parentName, path) {
-      // If type already exists, reuse it (complain if not created here)
-      let type = csn.definitions[typeName];
-      if (type) {
-        if (!exposedStructTypes.includes(typeName)) {
-          error(null, path, `Cannot create artificial type "${typeName}" for "${parentName}" because the name is already used`);
-          return null;
-        }
-        return type;
-      }
-
+    function createNewStructType(elements) {
       // Create a type with empty elements
-      type = {
+      const type = {
         kind: 'type',
         elements: Object.create(null),
       };
+      setProp(type, '$exposedBy', 'typeExposure');
 
-      // Duplicate the type's elements
+      // Duplicate elements
       Object.entries(elements).forEach(([elemName, element]) => {
-        if (type.elements[elemName]) {
-          const path = ['definitions', typeName, 'elements', elemName];
-          error(null, path, `"${elemName}": Element name conflicts with existing element`);
-        }
-        let cloned = cloneCsn(element, options);
+        let cloned = cloneCsnNonDict(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;
       });
-
-      // add to the CSN
-      csn.definitions[typeName] = type;
-      // store typeName in set of exposed struct types
-      exposedStructTypes.push(typeName);
       return type;
     }
   }
 
-
-  // 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, 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, 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: { ... }'
-    // or 2. 'elem: Foo' and type Foo: array of Integer|String|...'
-    else if (node.type) {
-      let finalType = csnUtils.getFinalTypeDef(node.type);
-      if (finalType.items) {
-        if (!isArtifactInService(node.type, service)) {
-          let typeId = `${service}.${node.type.replace(/\./g, '_')}`;
-          let newType = exposeArrayedType(node.items || finalType.items, typeId);
-          // When we have in the model something like:
-          // type Foo: array of Bar; type Bar: { qux: Integer };
-          // In the type Foo we expand the first level of elements of the items like we have in CDL this:
-          // type Foo: array of { qux: Integer };
-          expandFirstLevelOfArrayed(newType);
-          node.type = typeId;
-        }
-        // case 1. - as we keep the type property, the items property is removed
-        if (node.items) delete node.items;
-      }
-    }
-
-    function exposeArrayedType(items, typeId) {
-      let newType = csn.definitions[typeId];
-      if (newType) {
-        if (!exposedStructTypes.includes(typeId)) {
-          error(null, newType.$path, `Cannot create artificial type "${typeId}" because the name is already used`);
-        }
-        return newType;
-      }
-      // create empty type
-      newType = {
-        kind: 'type',
-        items: Object.create(null),
-      }
-
-      // copy over the items
-      newType.items = cloneCsn(items, options);
-      csn.definitions[typeId] = newType;
-      exposedStructTypes.push(typeId);
-      return newType;
-    }
-  }
-
-  // In case we have in the model something like:
-  // type Foo: array of Bar; type Bar: { qux: Integer };
-  // In the type Foo we expand the first level of elements of the items like we have in CDL this:
-  // type Foo: array of { qux: Integer };
-  function expandFirstLevelOfArrayed(def) {
-    if (def.items.type && !isBuiltinType(def.items.type)) {
-      let finalType = csnUtils.getFinalTypeDef(def.items.type);
-      if (csnUtils.isStructured(finalType)) {
-        if (!def.items.elements) def.items.elements = cloneCsnDictionary(finalType.elements, options);
-        delete def.items.type;
-      }
-    }
+  /*
+   * Calculate the name of the exposed type based on the information, the element can provide
+   * If the element is typed, use the type name
+   * else assume it's a de-anonymized type, concatenate the element name to the defName
+  */
+  function getNewTypeName(element, elementName, typeNamePrefix, serviceName) {
+    // for the new type name node.type has precedence over node.items.type
+    const typeName = (!element.elements && element.type || element.items && !element.items.elements && element.items.type);
+    return typeName
+        ? `${isMultiSchema
+              ? typeName.split('.').pop() // use leaf element
+              : typeName.replace(/\./g, '_')}` // concatenate path
+        : ( elementName // returns has no elementName, return the precalculated prefix
+            ? `${defNameWithoutServiceOrContextName(typeNamePrefix, serviceName).replace(/\./g, '_')}_${elementName}`
+            : typeNamePrefix
+          );
   }
 }
 

package/lib/transform/transformUtilsNew.js

@@ -9,8 +9,9 @@ const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
-const { cloneCsn, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsnNonDict, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
 const { ModelError } = require("../base/error");
+const { forEach } = require('../utils/objectUtils');
 
 // 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).
@@ -258,7 +259,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
         result[eName] = e;
       }
     }
-    Object.entries(struct).forEach(([childName, childElem]) => {
+    forEach(struct, (childName, childElem) => {
       if (isStructured(childElem)) {
         // Descend recursively into structured children
         let grandChildElems = flattenStructuredElement(childElem, childName, elementPath, pathInCsn.concat('elements',childName));
@@ -276,7 +277,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       } else {
         // Primitive child - clone it and restore its cross references
         let flatElemName = elemName + pathDelimiter + childName;
-        let flatElem = cloneCsn(childElem, options);
+        let flatElem = cloneCsnNonDict(childElem, options);
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
@@ -285,7 +286,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     });
 
     // Fix all collected flat elements (names, annotations, properties, origin ..)
-    Object.values(result).forEach(flatElem => {
+    forEach(result, (name, flatElem) => {
       // Copy annotations from struct (not overwriting, because deep annotations should have precedence)
       copyAnnotations(elem, flatElem, false);
       // Copy selected type properties
@@ -413,11 +414,11 @@ function getTransformers(model, options, pathDelimiter = '_') {
         throw Error('Failed to obtain final base type for reference : ' + node.type.ref.join('/'));
       if(finalBaseType.elements) {
           // This changes the order - to be discussed!
-        node.elements = cloneCsn(finalBaseType, options).elements; // copy elements
+        node.elements = cloneCsnNonDict(finalBaseType, options).elements; // copy elements
         delete node.type; // delete the type reference as edm processing does not expect it
       } else if(finalBaseType.items) {
           // This changes the order - to be discussed!
-        node.items = cloneCsn(finalBaseType.items, options); // copy items
+        node.items = cloneCsnNonDict(finalBaseType.items, options); // copy items
         delete node.type;
       } else {
         node.type=finalBaseType;
@@ -431,12 +432,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
     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) {
-      // Expand structured types on entity elements for flat OData
-      if(!(options.transformation === 'hdbcds' || options.toSql))
-        return;
-
       // cloneCsn only works correctly if we start "from the top"
-      const cloneTypeDef = cloneCsn(typeDef, options);
+      const cloneTypeDef = cloneCsnNonDict(typeDef, options);
       // With hdbcds-hdbcds, don't resolve structured types - but propagate ".items", to turn into LargeString later on.
       if(typeDef.items) {
         delete node.type;
@@ -899,7 +896,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     let elements = artifact.elements;
     if (elements) {
       path.push('elements', null);
-      Object.entries(elements).forEach(([name, obj]) => {
+      forEach(elements, (name, obj) => {
         path[path.length - 1] = name;
         recurseElements(obj, path, callback);
       });

package/lib/transform/translateAssocsToJoins.js

@@ -44,7 +44,7 @@ function translateAssocsToJoinsCSN(csn, options){
   }
 
   // If A2J reports error - end! Continuing with a broken CSN makes no sense
-  makeMessageFunction(model, options).throwWithError();
+  makeMessageFunction(model, options).throwWithAnyError();
   // FIXME: Move this somewhere more appropriate
   const compact = compactModel(model, compileOptions);
   return compact;
@@ -1818,6 +1818,10 @@ function walkPath(node, env)
   // or that are parameters ($parameters or escaped paths (':')
   //path.length && path[ path.length-1 ]._artifact
   const art = path && path.length && path[path.length-1]._artifact;
+
+  // regardless of the position in the query, ignore paths that have virtual path steps
+  if(art && path.some(ps => ps._artifact && ps._artifact.virtual && ps._artifact.virtual.val))
+    return path;
   if(art && !internalArtifactKinds.includes(art.kind))
   {
     if(env.callback)

package/lib/transform/universalCsn/coreComputed.js

@@ -137,9 +137,11 @@ function setCoreComputedOnViews(csn) {
      * @returns {boolean}
      */
     function needsCoreComputed(column) {
-      return column && ( column.xpr || column.func || column.val !== undefined || column.param || column.SELECT || column.SET || column.ref && column.ref[0] in {
-        $at: 1, $now: 1, $user: 1, $session: 1,
-      });
+      return column &&
+        (
+          column.xpr || column.func || column.val !== undefined || column.param || column.SELECT || column.SET ||
+          column.ref && [ '$at', '$now', '$user', '$session' ].includes(column.ref[0])
+        );
     }
 
     /**

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -288,7 +288,11 @@ module.exports = (csn, options) => {
         if (returns.target)
           calculateForeignKeys(returns);
       },
-      items: (parent, prop, items) => propagateMemberPropsFromOrigin(items, { '@': true, doc: true }),
+      items: (parent, prop, items) => {
+        // items in items must be propagated
+        // `specialItemsRule()` does not cover this case
+        propagateMemberPropsFromOrigin(items, { '@': true, doc: true }, { items: onlyWithTypeRef });
+      },
       elements: (parent, prop, elements) => {
         forEachValue(elements, (e) => {
           // within query elements we have to propagate the `enum` prop
@@ -358,13 +362,31 @@ module.exports = (csn, options) => {
         return !origin;
       }
     }
+
+    /**
+     * Some properties must only be copied over if the target
+     * is a type reference pointing to an element of a type or
+     * an aspect.
+     *
+     * @param {string} prop
+     * @param {CSN.Element} target
+     * @param {CSN.Element} source
+     */
+    function onlyWithTypeRef(prop, target, source) {
+      const typeIsTypeRef = Boolean(typeof target.type === 'object' && target.type.ref);
+      if (typeIsTypeRef) {
+        const referencedArtifact = csn.definitions[target.type.ref[0]];
+        if (referencedArtifact.kind in { type: true, aspect: true })
+          target[prop] = source[prop];
+      }
+    }
   }
 
   /**
    * Identify the sources of the passed object and propagate the relevant
    * properties/annotations along it's $origin chain.
    *
-   * @param {Object} art Target object for propagation
+   * @param {object} art Target object for propagation
    */
   function propagateOnArtifactLevel(art) {
     // check if art was already processed by the status flag
@@ -415,7 +437,7 @@ module.exports = (csn, options) => {
           copyProperties(definition.$origin, definition, getDefinitionPropagationRuleFor);
 
         // We need to propagate .elements to type artifacts - but our direct origin might not have .elements,
-        // because they are not propagated to members. We check if our root had elements (so we know that we should have some aswell)
+        // because they are not propagated to members. We check if our root had elements (so we know that we should have some as well)
         // and then walk the origin-chain until we find the first .elements
         if (definition.kind === 'type' && root.elements && !definition.elements) {
           const firstOriginWithElements = getFirstOriginWithElements(source);
@@ -580,7 +602,7 @@ module.exports = (csn, options) => {
  * @param {Function} getCustomRule getter for the `memberProps` or `defProps`
  *                                 which shall be used for retrieving custom rules
  * @param {object} [except=null] array of properties which should not be propagated
- * @param {object} [force=null] Force propagation of the contained keys via rule "always"
+ * @param {object} [force=null] Force propagation of the contained keys via a custom rule.
  */
 function copyProperties(from, to, getCustomRule, except = null, force = null) {
   const keys = Object.keys(from);
@@ -589,7 +611,7 @@ function copyProperties(from, to, getCustomRule, except = null, force = null) {
     if (except && !(force && force[key]) && (key.charAt(0) in except || key in except))
       continue;
     if (!(key in to)) {
-      const func = force && force[key] ? always : getCustomRule(key);
+      const func = force && force[key] ? force[key] : getCustomRule(key);
       if (func)
         func(key, to, from);
     }