@sap/cds-compiler 2.7.0 → 2.10.2

package/lib/transform/odata/generateForeignKeyElements.js

@@ -35,7 +35,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     let generatedForeignKeyNamesForPath = Object.create(null); // map<path,[key-name]>
 
     sortedAssociations.forEach(item => {
-      const { definitionName, elementName, element, parent, path } = item;
+      const { definitionName, structuralNodeName, elementName, element, parent, path } = item;
 
       if (csnUtils.isManagedAssociationElement(element) && element.keys) {
         if (flatKeys) // tackling the ref value in assoc.keys
@@ -44,7 +44,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
         fixCardinality(element);
       }
 
-      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, elementName, element, parent, path);
+      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, structuralNodeName, elementName, element, parent, path);
       generatedForeignKeyNamesForPath[item.path.join('/')] = arrayOfGeneratedForeignKeyNames;
     })
 
@@ -111,7 +111,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
   /**
    * Generates foreign keys and returns their names as an array
    */
-  function generateForeignKeys(definitionName, assocName, assoc, parent, path) {
+  function generateForeignKeys(definitionName, structuralNodeName, assocName, assoc, parent, path) {
     let foreignKeyElements = Object.create(null);
 
     // First, loop over the keys array of the association and generate the FKs.
@@ -134,13 +134,14 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     if (parent.returns)
       parent = parent.returns.items || parent.returns;
 
-    let currElementsNames = Object.keys(parent.elements);
+    const dictionary = parent[structuralNodeName];
+    let currElementsNames = Object.keys(parent[structuralNodeName]);
     for (const [foreignKeyName, foreignKey] of Object.entries(foreignKeyElements)) {
       copyAnnotations(assoc, foreignKey, true);
       // Insert artificial element into artifact, with all cross-links
-      if (parent.elements[foreignKeyName]) {
-        if (!(parent.elements[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(parent.elements[foreignKeyName], foreignKey))) {
-          const path = parent.elements[foreignKeyName].$path;
+      if (dictionary[foreignKeyName]) {
+        if (!(dictionary[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(dictionary[foreignKeyName], foreignKey))) {
+          const path = dictionary[foreignKeyName].$path;
           error(null, path, { name: foreignKeyName, art: assocName }, 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
         }
       }
@@ -151,8 +152,8 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     // if (flatKeys)
     currElementsNames.splice(assocIndex + 1, 0, ...Object.keys(foreignKeyElements));
 
-    parent.elements = currElementsNames.reduce((previous, name) => {
-      previous[name] = parent.elements[name] || foreignKeyElements[name];
+    parent[structuralNodeName] = currElementsNames.reduce((previous, name) => {
+      previous[name] = dictionary[name] || foreignKeyElements[name];
       return previous;
     }, Object.create(null));
 
@@ -180,7 +181,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
 
     function processStucturedKey(fkArtifact, assocName, foreignKeyRef) {
       const subStruct = fkArtifact.elements ? fkArtifact : csnUtils.getFinalBaseType(fkArtifact.type);
-      const flatElements = flattenStructure(subStruct, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
+      const flatElements = flattenStructure(subStruct.elements, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
       for (const [flatElemName, flatElem] of Object.entries(flatElements)) {
         const foreignKeyElementName =
           `${assocName.replace(/\./g, '_')}_${foreignKeyRef.as ? flatElemName.replace(implicitAs(foreignKeyRef.ref), foreignKeyRef.as) : flatElemName}`;

package/lib/transform/odata/referenceFlattener.js

@@ -1,6 +1,7 @@
 const { forEachRef } = require('../../model/csnUtils');
 const { setProp } = require('../../base/model');
 const { implicitAs } = require('../../model/csnRefs');
+const { structuralPath } = require('./structuralPath');
 
 /** This class is used for generic reference flattening.
  * It provides the following functionality:
@@ -73,8 +74,7 @@ class ReferenceFlattener {
       });
       if (paths)
         setProp(node, '$paths', paths);
-      setProp(node, '$scope', resolved.scope);
-      // cache also if structured or not
+      // cache if structured or not
       let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
       this.structuredReference[path.join('/')] = structured;
     });
@@ -176,10 +176,10 @@ class ReferenceFlattener {
       if (node.$paths) {
         let newRef = []; // flattened reference
         let flattenWithPrevious = false;
-        let anythingFlattened = false; // will be set to true if at least one node is flatted
+        let lastFlattenedID = null; // The variable will be set to the index of the last flattened path
         node.$paths.forEach((path, i) => {
           if (path === undefined || !ref[i]) return;
-          let spath = path.join('/')
+          let spath = path.join('/');
           let movedTo = this.elementTransitions[spath]; // detect element transition
           let flattened = this.flattenedElementPaths[spath];
           if (flattenWithPrevious) {
@@ -190,27 +190,26 @@ class ReferenceFlattener {
               ref[i].id = newRef[newRef.length - 1];
               newRef[newRef.length - 1] = ref[i];
             }
-            anythingFlattened = true;
+            lastFlattenedID = i;
           } else if(movedTo && i===0) { // handle local scope reference which is transitioned - replace first item in reference
             let movedToElementName = movedTo[movedTo.length-1];
             newRef.push(movedToElementName);
-            anythingFlattened=true;
+            lastFlattenedID = i;
           } else {
             newRef.push(ref[i]);
           }
           flattenWithPrevious = flattened;
         });
-        if (newRef !== undefined && anythingFlattened) { // do not replace unchanged references
+        if (newRef !== undefined && lastFlattenedID !== null) { // make sure the reference changed and only then replace it with the new one
           // check if this is a column and add alias if missing
-          if (isColumnInSelect(ref.$path)) {
-            if (!node.as) {
+          let structural = structuralPath(csn, path);
+          if (isColumnInSelectOrProjection(structural)) {
+            if (!node.as && lastFlattenedID === ref.length-1) // attach alias only if there is none and it is the last item in the reference that was flattened
               node.as = node.ref[node.ref.length - 1];
-            }
           }
           setProp(newRef, '$path', path.concat('ref'));
           if (!node.as) {
-            // FIXME: rather use scope from inspectRef to determin if path leads to a key
-            if (ifKeysScope(path))
+            if (isPartOfKeysStructure(structural))
               node.as = implicitAs(node.ref);
             else
               setProp(node, 'as', implicitAs(node.ref))
@@ -223,13 +222,11 @@ class ReferenceFlattener {
 
   applyAliasesInOnCond(csn, inspectRef) {
     forEachRef(csn, (ref, node, path) => {
-      // is there a better way to detect if we are dealing with on-cond?
-      // TODO: please do not use inspectRef() results for "where am I?" info
-      if (!['$self', 'parent'].includes(node.$scope)) return;
-      // the above condition means: only handle references starting with
-      // $self or element references outside queries
-
+      // Process only on-conditions of associations
+      let structural = structuralPath(csn, path);
+      if(!isOnCondition(structural)) return;
       let { links } = inspectRef(path);
+      if(!links) return; // $user not resolvable
       let keysOfPreviousStepWhenManagedAssoc = undefined;
 
       let aliasedRef = [...ref];
@@ -253,32 +250,41 @@ class ReferenceFlattener {
   }
 }
 
-// FIXME: rather use scope from inspectRef to determin if path leads to a key
-function ifKeysScope(path) {
-  if (!path) return false;
-  if (Number.isInteger(path[path.length - 1]) && path[path.length - 2] === 'keys' && path[path.length - 4] === 'elements')
-    return true;
-  return false;
+/**
+ * Checks if the provided path is a column inside a key node
+ * by exploring the possibility of the structural path to  ends with 'elements' and 'keys'.
+ *
+ * @param structural structural path to explore
+ * @returns {boolean} True if the provided path matched the requirements to be part of a key node.
+ */
+function isPartOfKeysStructure(structural) {
+  return structural[structural.length-2] === 'elements'
+      && structural[structural.length-1] === 'keys';
 }
 
 /**
- * Checks if the provided path is a column inside a select node
- * by exploring the possibility of the path to end with ['SELECT','columns','<an integer>', <ref - not checked>].
+ * Checks if the provided path is a column inside a select or a projection node
+ * by exploring the possibility of the structural path to contain 'SELECT' or 'projection'
+ * and ends with 'columns' or 'columns' and 'expand'.
  *
- * @param {CSN.Path} path Path to explore
+ * @param structural structural path to explore
  * @returns {boolean} True if the provided path matched the requirements to be a select node.
  */
-function isColumnInSelect(path) {
-  if (!path)
-    return false;
-  const len = path.length;
-  if (path[len - 4] === 'SELECT' && path[len - 3] === 'columns') {
-    // check if -2 element is an integer / array index
-    const arrayIndex = parseInt(String(path[len - 2]), 10);
-    if (!isNaN(arrayIndex))
-      return true;
-  }
-  return false;
+function isColumnInSelectOrProjection(structural) {
+  return (structural.includes('SELECT') ||  structural.includes('projection'))
+    && (structural[structural.length-1] === 'columns' || (structural[structural.length-2] === 'columns' && structural[structural.length-1] === 'expand'));
+}
+
+/**
+ * Checks if the provided path is a column inside an on-condition of an element
+ * by exploring the possibility of the structural path to  ends with 'elements' and 'on'.
+ *
+ * @param structural structural path to explore
+ * @returns {boolean} True if the provided path matched the requirements to be part of an element's on-condition.
+ */
+function isOnCondition(structural) {
+  return structural[structural.length-2] === 'elements'
+      && structural[structural.length-1] === 'on';
 }
 
 module.exports = ReferenceFlattener;

package/lib/transform/odata/sortByAssociationDependency.js

@@ -24,7 +24,7 @@ function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember)
   forEachDefinition(csn, (def, definitionName) => {
     /** @type {CSN.Path} */
     let root = ['definitions', definitionName];
-    forEachMemberRecursively(def, (element, elementName, _prop, subpath, parent) => {
+    forEachMemberRecursively(def, (element, elementName, structuralNodeName, subpath, parent) => {
       let path = root.concat(subpath);
       // go only through managed associations and compositions
       if (isAssociationOrComposition(element) && element.keys && !element.on) { // check association FKs
@@ -44,7 +44,7 @@ function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember)
             elementDependencies.push(targetElementPath);
           }
         })
-        dependencies[path.join("/")] = { definitionName, elementName, element, path, parent, dependencies: elementDependencies };
+        dependencies[path.join("/")] = { structuralNodeName, definitionName, elementName, element, path, parent, dependencies: elementDependencies };
       }
     }) // forEachMemberRecursively
   }, { skipArtifact: isExternalServiceMember }) // forEachDefinition

package/lib/transform/odata/structuralPath.js

@@ -0,0 +1,76 @@
+// The module traverses a given CSN using a specific path, collects structural node names and returns them.
+
+const structuralNodeHandlers = {
+  definitions: traverseDict,
+  elements: traverseDict,
+  actions: traverseDict,
+  params: traverseDict,
+  items: traverseTyped,
+  enum: traverseDict,
+  returns: traverseTyped,
+  on: traverseArray,
+  keys: traverseArray,
+  ref: traverseRef,
+  query: traverseTyped,
+  SELECT: traverseTyped,
+  SET: traverseTyped,
+  args: traverseArray,
+  columns: traverseArray,
+  projection: traverseTyped,
+  from: traverseTyped,
+  mixin: traverseDict,
+  where: traverseArray,
+  orderBy: traverseArray,
+  groupBy: traverseArray,
+  having: traverseArray,
+  xpr: traverseArray,
+  expand: traverseArray,
+  inline: traverseArray,
+  cast: traverseTyped,
+}
+
+function structuralPath(csn, path) {
+  return traverseDict(csn.definitions, path, 1, ['definitions']);
+}
+
+function traverseRef(obj, path, index, typeStack) {
+  return traverseArray(obj, path, index, typeStack);
+}
+
+function traverseArray(obj, path, index, typeStack) {
+  if(!Array.isArray(obj)) return typeStack;
+  const name = path[index];
+  const element = obj[name];
+  return traverseTyped(element, path, index+1, typeStack);
+}
+
+function traverseDict(obj, path, index, typeStack) {
+  if(typeof obj !== 'object') return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  return traverseTyped(obj[name], path, index+1, typeStack);
+}
+
+function traverseDictArray(obj, path, index, typeStack) {
+  if(typeof obj !== 'object') return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  return traverseArray(obj[name], path, index+1, typeStack);
+}
+
+function traverseTyped(obj, path, index, typeStack) {
+  if(!obj) return typeStack;
+  const name = path[index];
+  if(name === undefined) return typeStack;
+  if(name[0] === '@') return typeStack; // skip annotations
+  const func = structuralNodeHandlers[name];
+  if(func) return func(obj[name], path, index+1, typeStack.concat(name));
+  // not typed -> columns?
+  if(typeStack[typeStack.length-1] === 'columns')
+    return traverseDictArray(obj, path, index, typeStack);
+  return typeStack;
+}
+
+module.exports = {
+  structuralPath
+}

package/lib/transform/odata/structureFlattener.js

@@ -74,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
@@ -93,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) {
@@ -118,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
@@ -127,7 +132,6 @@ function flattenStructure(struct, path, csnUtils, options, error, referenceFlatt
       let elementNameWithDots = elementPathInStructure.concat(elementName).join('.');
       addNewElementToResult(element, newElementName, elementNameWithDots, currPath);
     }
-
   });
 
   if (referenceFlattener) {
@@ -135,7 +139,6 @@ 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]) {

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

@@ -61,6 +61,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     recurseElements,
     renameAnnotation,
     setAnnotation,
+    resetAnnotation,
     expandStructsInExpression,
   };
 
@@ -378,9 +379,10 @@ function getTransformers(model, options, pathDelimiter = '_') {
    *
    * @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) {
+  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
@@ -440,6 +442,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);
   }
@@ -920,6 +924,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

package/lib/transform/translateAssocsToJoins.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { setProp, forEachGeneric, forEachDefinition, isBetaEnabled } = require('../base/model');
-var { handleMessages, makeMessageFunction } = require('../base/messages');
+var { makeMessageFunction } = require('../base/messages');
 const { recompileX } = require('../compiler/index');
 var { linkToOrigin } = require('../compiler/shared');
 const  {compactModel, compactExpr} = require('../json/to-csn');
@@ -14,7 +14,9 @@ const internalArtifactKinds = ['builtin'/*, '$parameters'*/, 'param'];
 function translateAssocsToJoinsCSN(csn, options){
   timetrace.start('Recompiling model');
   // Do not re-complain about localized
-  const model = recompileX(csn, { ...options, $skipNameCheck: true });
+  const compileOptions = { ...options, $skipNameCheck: true };
+  delete compileOptions.csnFlavor;
+  const model = recompileX(csn, compileOptions);
   timetrace.stop();
   timetrace.start('Translating associations to joins');
   translateAssocsToJoins(model, options);
@@ -42,9 +44,9 @@ function translateAssocsToJoinsCSN(csn, options){
   }
 
   // If A2J reports error - end! Continuing with a broken CSN makes no sense
-  handleMessages(model, options);
+  makeMessageFunction(model, options).throwWithError();
   // FIXME: Move this somewhere more appropriate
-  const compact = compactModel(model, options);
+  const compact = compactModel(model, compileOptions);
   return compact;
 }
 

package/lib/transform/universalCsnEnricher.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { forEachDefinition } = require('../base/model');
+const {
+  applyTransformations,
+  cloneCsn,
+  getUtils,
+  isBuiltinType,
+} = require('../model/csnUtils');
+
+/**
+ * Loop through a universal CSN and enrich it with the properties
+ * from the source definition - modifies the input model in-place
+ * 
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ */
+module.exports = function(csn, options) {
+  let { getOrigin, getFinalType, getFinalTypeDef } = getUtils(csn);
+  // User-defined structured types do not have the elements propagated any longer
+  // if there is no association among the elements. For that reason,
+  // as a first step propagate the elements of these
+  forEachDefinition(csn, (def) => {
+    if (def.kind === 'type' && def.type && !def.elements) {
+      const finalType = getFinalType(def.type);
+      if (isBuiltinType(finalType)) return;
+      const finalTypeDef = getFinalTypeDef(def.type);
+      if (finalTypeDef.elements)
+        def.elements = cloneCsn(finalTypeDef.elements, options);
+    }
+  });
+
+  // as a second step, loop through all the $origin properties in the model
+  // and propagate the properties from the origin definition
+  applyTransformations(csn, {
+    '$origin': (node, _$orign, $originValue, _path, parent, propName) => {
+      if (!node.kind) { // we do not want to replace whole definitions
+        if (Array.isArray($originValue))
+          propagatePropsFromOrigin(node, propName, parent);
+        else if ($originValue.$origin && Array.isArray($originValue.$origin)) {
+          // cover the case of query entity elements where we have own and ihnerited attributes/annotations
+          propagatePropsFromOrigin($originValue, propName, parent);
+        }
+
+      }
+    }
+  }, undefined, undefined, options);
+
+  function propagatePropsFromOrigin(member, memberName, construct) {
+    // TODO: shall the $origin be kept as part of the element?
+    const origin = getOrigin(member);
+    if (origin.kind) return;
+    if (member.elements && origin.type) {
+      delete member.$origin;
+      member.type = origin.type;
+      return;
+    }
+    let newMember = cloneCsn(origin, options);
+    // keep targets and keys of assoc, if it was redirected
+    if (origin.type === 'cds.Association') {
+      newMember.target = member.target || newMember.target;
+      newMember.keys = member.keys || newMember.keys;
+    }
+    // TODO: check if this works fine for items/returns/actions
+    construct[memberName] = newMember;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.7.0",
+  "version": "2.10.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",