@sap/cds-compiler 6.5.2 → 6.6.2

package/lib/edm/annotations/edmJson.js

@@ -21,7 +21,7 @@ const { conditionAsTree, expressionAsTree } = require('../../model/xprAsTree');
  * @returns {object}
  */
 
-function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
+function xpr2edmJson( carrier, anno, location, options, messageFunctions, genericTranslationHelpers ) {
   const { message, error } = messageFunctions;
 
   const annoVal = carrier[anno];
@@ -77,9 +77,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Error transformer
-  const notADynExpr = (parent, op, xpr, csnPath, parentParent, parentProp, txt) => {
+  const notADynExpr = (parent, op, xpr, csnPath, parentParent, parentProp, ctx) => {
     error('odata-anno-xpr', location, {
-      anno, op: txt ?? op, '#': 'notadynexpr',
+      anno, op: ctx.txt ?? op, '#': 'notadynexpr',
     });
     delete parent[op];
   };
@@ -95,26 +95,26 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     '.': notADynExpr,
     exists: notADynExpr,
     SELECT: notADynExpr,
-    SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
+    SET: (p, o, xpr, csnPath, parentParent, parentProp, ctx) => notADynExpr(p, o, null, null, null, null, Object.assign(ctx, { txt: 'UNION' })),
     like: notADynExpr,
     new: notADynExpr,
   };
 
   //----------------------------------
   // list is a $Collection => []
-  transform.list = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.list = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     parentParent[parentProp] = xpr.filter(a => a);
-    transformExpression(parentParent, parentProp, transform);
+    transformExpression(parentParent, parentProp, transform, csnPath, ctx);
   };
   // XPR
-  transform.xpr = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.xpr = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     // eliminate 'xpr' node by pulling up xpr node to its parent
     parentParent[parentProp] = xpr;
-    transformExpression(parentParent, parentProp, transform);
+    transformExpression(parentParent, parentProp, transform, csnPath, ctx);
   };
   //----------------------------------
   // CASE
-  transform.case = (parent, prop, caseExpr) => {
+  transform.case = (parent, prop, caseExpr, csnPath, parentParent, parentProp, ctx) => {
     // transform simple case expression into search case expression
     // case <expr1> when <expr2> ... ===> case when <expr1> = <expr2> ...
     let i = 0;
@@ -141,14 +141,14 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       curIf.$If.push(caseExpr[i]);
     parent.$If = edmIf.$If;
     delete parent.case;
-    transformExpression(parent, undefined, transform);
+    transformExpression(parent, undefined, transform, csnPath, ctx);
   };
-  transform.$If = (_parent, _prop, expr) => {
-    transformExpression(expr, undefined, transform);
+  transform.$If = (_parent, _prop, expr, csnPath, parentParent, parentProp, ctx) => {
+    transformExpression(expr, undefined, transform, csnPath, ctx);
   };
   //----------------------------------
   // Cast => $Cast
-  transform.cast = (parent, prop, castExpr, csnPath, parentParent, parentProp) => {
+  transform.cast = (parent, prop, castExpr, csnPath, parentParent, parentProp, ctx) => {
     const csnType = castExpr[0];
     // try to resolve to final scalar base type and use that instead of derived type
     if (!isBuiltinType(csnType.type)) {
@@ -183,7 +183,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
 
     parentParent[parentProp] = castFunc;
-    transformExpression(parentParent, parentProp, transform);
+    transformExpression(parentParent, parentProp, transform, csnPath, ctx);
   };
   //----------------------------------
   const evalArgs = (argDef, args, propName) => {
@@ -215,11 +215,11 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
 
   // Binary Operator Macro
-  const op = (opStr, exact = 2) => (parent, prop, xpr) => {
+  const op = (opStr, exact = 2) => (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     evalArgs({ exact }, xpr, prop);
     parent[opStr] = xpr;
     delete parent[prop];
-    transformExpression(parent, undefined, transform);
+    transformExpression(parent, undefined, transform, csnPath, ctx);
   };
   //----------------------------------
   // LOGICAL
@@ -245,7 +245,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   transform.$Lt = noOp;
   transform['<='] = op('$Le');
   transform.$Le = noOp;
-  transform.in = (parent, prop, xpr) => {
+  transform.in = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     let args = xpr[1].list;
     if (!args) {
       if (Array.isArray(xpr[1].xpr))
@@ -256,12 +256,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ min: 1 }, args, prop);
     parent.$In = [ xpr[0], args ];
     delete parent[prop];
-    transformExpression(parent, undefined, transform);
+    transformExpression(parent, undefined, transform, csnPath, ctx);
   };
   transform.$In = noOp;
-  transform.between = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.between = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     evalArgs({ exact: 2 }, xpr.slice(1), prop);
-    transformExpression(xpr, undefined, transform);
+    transformExpression(xpr, undefined, transform, csnPath, ctx);
     delete parent[prop];
     parentParent[parentProp]
       = {
@@ -271,28 +271,28 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         ],
       };
   };
-  transform['||'] = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform['||'] = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     evalArgs({ exact: 2 }, xpr, prop);
-    transformExpression(xpr, undefined, transform);
+    transformExpression(xpr, undefined, transform, csnPath, ctx);
     delete parent[prop];
     parentParent[parentProp].$Apply = xpr;
     parentParent[parentProp].$Function = 'odata.concat';
   };
   //----------------------------------
   // ARITHMETICAL AND UNARY
-  transform['+'] = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform['+'] = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     if (Array.isArray(xpr)) {
       op('$Add')(parent, prop, xpr);
     }
     else {
       delete parent[prop];
       parentParent[parentProp] = xpr;
-      transformExpression(parentParent, parentProp, transform);
+      transformExpression(parentParent, parentProp, transform, csnPath, ctx);
     }
   };
   transform.$Add = noOp;
-  transform['-'] = (parent, prop, xpr) => {
-    op(Array.isArray(xpr) ? '$Sub' : '$Neg')(parent, prop, xpr);
+  transform['-'] = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
+    op(Array.isArray(xpr) ? '$Sub' : '$Neg')(parent, prop, xpr, csnPath, parentParent, parentProp, ctx);
   };
   transform.$Sub = noOp;
   transform.$Neg = noOp;
@@ -311,12 +311,84 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     else
       parentParent[parentProp] = xpr;
   };
-  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentProp, txt) => {
-    if (parent['#'] && parent.val) // enum reference that was resolved by the compiler
-      delete parent['#'];
-    else
-      notADynExpr(parent, prop, xpr, csnPath, parentParent, parentProp, txt);
+  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentParentName, ctx) => {
+    // enum reference that was resolved by the compiler
+    if (!(parent['#'] && parent.val))
+      parent.EnumMember = getEnumMemberValue(xpr, ctx);
+    delete parent['#'];
   };
+  //----------------------------------
+  // Enum type resolving helper functions
+  function getEnumMemberValue( enumMember, ctx ) {
+    // inner annotations play a role here?
+
+    const annoNameParts = anno.slice(1).split('.');
+    // The term of an annotation is the part between the first '@' and the second '.'
+    const termName = `${ annoNameParts[0] }.${ annoNameParts[1] }`;
+    const term = genericTranslationHelpers.getDictTerm(termName, options);
+    // get term's type
+    let typeName = term?.Type;
+    let type = genericTranslationHelpers.getDictType(typeName);
+
+    ({ type, typeName } = resolveNestedTypePath(annoNameParts.slice(2), typeName, type));
+
+    if (type?.$kind === 'EnumType')
+      return valiteAndGetFullEnumMemberNameFromEnumType(enumMember, type, typeName);
+    if (type?.$kind === 'ComplexType') {
+      // If we end up with a ComplexType here, the enum member is defined in a property of the complex type, which is
+      // a collection. Only in that case the flattening of annotation stops in the core compiler.
+      // Here we need to continue resolving the substructure inside a collection item.
+      const indexOfAnnoInCsnPath = ctx.xprCsnPath.indexOf(anno);
+      // we take the part of the csnPath after the annotation and remove the numeric values, as these are the array indexes
+      const subStructAnnoNames = ctx.xprCsnPath.slice(indexOfAnnoInCsnPath + 1).filter(e => typeof e === 'string');
+      ({ type, typeName } = resolveNestedTypePath(subStructAnnoNames, typeName, type));
+      if (type?.$kind === 'EnumType')
+        return valiteAndGetFullEnumMemberNameFromEnumType(enumMember, type, typeName);
+    }
+
+    if (type && type.$kind !== 'EnumType') {
+      // resolved to not an EnumType -> warn about it and return what the input value
+      message('odata-anno-value', location, {
+        anno, value: `"#${ enumMember }"`, type: typeName, '#': 'std',
+      });
+    }
+    return enumMember;
+  }
+
+  function resolveNestedTypePath( annoNameParts, typeName, type ) {
+    for (let i = 0; i < annoNameParts.length; i++) {
+      if (type?.$kind === 'ComplexType') {
+        const properties = type.Properties;
+        const propName = Object.keys(properties).find(p => p === annoNameParts[i]);
+        if (propName) {
+          if (properties[propName].startsWith('Collection(')) {
+            // strip the 'Collection(...)' wrapper
+            typeName = properties[propName].slice(11, -1);
+            type = genericTranslationHelpers.getDictType(typeName);
+          }
+          else {
+            type = genericTranslationHelpers.getDictType(properties[propName]);
+            typeName = properties[propName];
+          }
+        }
+      }
+    }
+    return { type, typeName };
+  }
+
+  function valiteAndGetFullEnumMemberNameFromEnumType( member, enumType, typeName ) {
+    const members = enumType?.Members;
+    if (members && !members.includes(member)) {
+      message('odata-anno-value', location, {
+        anno, type: typeName, value: `"#${ member }"`, rawvalues: members.map(m => `#${ m }`), '#': 'enum',
+      });
+      return member;
+    }
+    return `${ typeName }/${ member }`;
+  }
+  //----------------------------------
+
+
   transform.ref = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     // until empty filter syntax is introduced for the annotation expressions,
     // we ignore the filters in order to generate EDMX
@@ -332,7 +404,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Functions
-  transform.func = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.func = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     const rewriteArgs = (argDefs, evalVal = true) => {
       Object.entries(argDefs).forEach(([ argName, argDef ]) => {
         const [ foundProps, newArgs ]
@@ -723,7 +795,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       // $Record ???
       $Collection: () => {
         standard(parentParent, parentProp);
-        transformExpression(parentParent, parentProp, transform);
+        transformExpression(parentParent, parentProp, transform, csnPath, ctx);
       },
       $Path: () => {
         oneArg(parent, xpr);
@@ -733,7 +805,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             anno, op: `${ xpr }(…)`, meta: 'string', '#': 'wrongval_meta',
           });
         }
-        transformExpression(parentParent, parentProp, transform);
+        transformExpression(parentParent, parentProp, transform, csnPath, ctx);
       },
       $Null: () => {
         parent[xpr] = true;
@@ -753,7 +825,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         funcDef.forEach(f => f());
       else
         funcDef();
-      transformExpression(parent, undefined, transform);
+      transformExpression(parent, undefined, transform, csnPath, ctx);
     }
     else {
       const funcName = xpr.startsWith('odata.') ? xpr : `odata.${ xpr }`;
@@ -770,7 +842,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
           parentParent[parentProp].$Function = funcName;
           delete parentParent[parentProp].func;
           delete parentParent[parentProp].args;
-          transformExpression(parentParent, parentProp, transform);
+          transformExpression(parentParent, parentProp, transform, csnPath, ctx);
         }
       }
       else {
@@ -787,7 +859,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       if (isAnnotationExpression(parent)) {
         delete parent['='];
         const edmJson = preTransformXpr(parent);
-        parentParent[parentProp] = transformExpression({ $edmJson: edmJson }, undefined, transform);
+        // csnPath to this certain expression is passed inside of the 'ctx' variable, in case it is needed for resolving types from the
+        // dictionary, for instance in enum symbols resolving, see transform['#']
+        parentParent[parentProp] = transformExpression({ $edmJson: edmJson }, undefined, transform, csnPath, { xprCsnPath: csnPath });
       }
     },
   }, location);

package/lib/edm/annotations/genericTranslation.js

@@ -468,7 +468,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             }
           },
         }, ctx.csnPath || ctx.location);
-        xpr2edmJson(carrier, knownAnno, ctx.location, options, messageFunctions);
+        xpr2edmJson(carrier, knownAnno, ctx.location, options, messageFunctions, {
+          oDataDictionary, getDictTerm, getDictType,
+        });
       }
     });
 

package/lib/main.d.ts

@@ -1023,9 +1023,6 @@ declare namespace compiler {
      *  - elements are flattened
      *  - …
      *
-     * THIS IS HIGHLY EXPERIMENTAL
-     *
-     * Beta flag `effectiveCsn` is required.
      *
      * @internal
      */

package/lib/main.js

@@ -188,9 +188,11 @@ module.exports = {
   $lsp: {
     parse: (...args) => compiler.parseX(...args),
     compile: (...args) => compiler.compileX(...args),
+    compileSync: (...args) => compiler.compileSyncX(...args),
     getArtifactName: art => base.getArtifactName(art),
     traverseSemanticTokens: (xsn, options) => lsp.traverseSemanticTokens(xsn, options),
     getSemanticTokenOrigin: obj => lsp.getSemanticTokenOrigin(obj),
+    xsnToCsn: ( xsn, options ) => toCsn.compactModel( xsn, options ),
   },
 
   // CSN Model related functionality

package/lib/transform/db/applyTransformations.js

@@ -270,7 +270,7 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
  * - the path to the property
  *
  * @param {object} parent The "parent" of which we transform a property of
- * @param {string} prop The property of parent to start at
+ * @param {string|number} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
  * @param {applyTransformationsOptions} [options={}]
  * @param {CSN.Path} path Path pointing to parent

package/lib/transform/db/associations.js

@@ -155,7 +155,6 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
    */
   function handleManagedAssocSteps( artifact, artifactName ) {
     const transformer = getTransformer();
-    const inColumnsTransformer = getTransformer(true);
 
     if (options.transformation === 'effective')
       processRefsInAnnotations(artifact, transformer, [ 'definitions', artifactName ]);
@@ -185,14 +184,13 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
       if (processOnInQueries) {
         queryTransformers.columns = (parent, prop, columns, path) => {
           for (let i = 0; i < columns.length; i++) {
-            const column = columns[i];
-            if (column.ref) {
-              inColumnsTransformer.ref(column, 'ref', column.ref, path.concat([ 'columns', i ]));
-              column.ref.forEach((step, index) => {
-                if (step.where)
-                  transform(step, 'where', step.where, path.concat([ 'columns', i, 'ref', index ]));
-              });
-            }
+            applyTransformationsOnNonDictionary(
+              columns,
+              i,
+              transformer,
+              { drillRef: true, skipStandard: { on: true } },
+              path.concat( [ 'columns' ] )
+            );
           }
         };
         queryTransformers.on = transform;
@@ -201,17 +199,27 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
       if (options.transformation === 'effective' || options.transformation === 'odata')
         queryTransformers.xpr = transform;
 
-      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, { drillRef: true }, [ 'definitions', artifactName ]);
+      applyTransformationsOnNonDictionary(
+        artifact,
+        artifact.query ? 'query' : 'projection',
+        queryTransformers,
+        {
+          drillRef: true,
+          skipDict: {
+            mixin: !(options.transformation in { odata: 1, effective: 1 }),
+          },
+        },
+        [ 'definitions', artifactName ]
+      );
     }
 
     /**
      *
-     * @param {boolean} isColumns Whether the transformation is taking place on a column
      * @returns {object}
      */
-    function getTransformer( isColumns = false ) {
+    function getTransformer() {
       return {
-        ref: (refOwner, prop, ref, path) => {
+        ref: (refOwner, prop, ref, path, grandParent) => {
           // [<assoc base>.]<managed assoc>.<field>
           if (ref.length > 1) {
             const { links } = inspectRef(path);
@@ -232,10 +240,11 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
                     fkAlias = fks[0].as || fks[0].ref[fks[0].ref.length - 1];
                     const managedAssocStepName = ref[i];
                     const newFkName = `${ managedAssocStepName }${ pathDelimiter }${ fkAlias }`;
-                    if (isColumns) {
+                    // only set alias for top level column refs
+                    if (Array.isArray(grandParent) && path.at(-2) === 'columns') {
                       refOwner.ref = [ ...ref.slice(0, i), newFkName ];
                       if (!refOwner.as)
-                        refOwner.as = implicitAs(ref);
+                        refOwner.as = ref.at(-1).id || ref.at(-1);
                     }
                     else {
                       refOwner.ref = [ ...ref.slice(0, i), newFkName ];

package/lib/transform/db/flattening.js

@@ -226,7 +226,7 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
           // Explicitly set implicit alias for things that are now flattened - but only in columns
           // TODO: Can this be done elegantly during expand phase already?
           if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
-            if (parent.ref.at(-1) === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+            if (parent.ref.at(-1) === parent.as && !parent.ref.at(-1).includes('.') ) // for a simple s that was expanded - for s.substructure this would not apply
               delete parent.as;
             delete parent.$implicitAlias;
           }

package/lib/transform/db/views.js

@@ -70,7 +70,6 @@ function getViewTransformer( csn, options, messageFunctions ) {
     get$combined, isAssocOrComposition,
     inspectRef, queryOrMain, // csnRefs
   } = csnUtils;
-  const pathDelimiter = options.forHana && (options.sqlMapping === 'hdbcds') ? '.' : '_';
   const { error, info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 
@@ -158,39 +157,6 @@ function getViewTransformer( csn, options, messageFunctions ) {
       columnMap[elemName] = { ref: [ elemName ] };
   }
 
-  /**
-   * So far, we only added foreign keys to elements - we also need to create corresponding columns
-   * and respect aliasing etc.
-   *
-   * @todo Maybe this can be done earlier, during flattening/expansion already?
-   * @param {object} columnMap
-   * @param {CSN.Element} elem
-   * @param {string} elemName
-   */
-  function addForeignKeysToColumns( columnMap, elem, elemName ) {
-    const assocCol = columnMap[elemName];
-    if (assocCol && assocCol.ref) {
-      elem.keys.forEach((foreignKey) => {
-        const ref = cloneCsnNonDict(assocCol.ref, options);
-        ref[ref.length - 1] = [ getLastRefStepString(ref) ].concat(foreignKey.as).join(pathDelimiter);
-        const result = {
-          ref,
-        };
-        if (assocCol.as) {
-          const columnName = `${ assocCol.as }${ pathDelimiter }${ foreignKey.as }`;
-          result.as = columnName;
-        }
-
-        if (assocCol.key)
-          result.key = true;
-
-        const colName = result.as || getLastRefStepString(ref);
-        columnMap[colName] = result;
-      });
-    }
-  }
-
-
   /**
    * Check for invalid association publishing (in Union or in Subquery) (for hdbcds) and
    * create the __clone for publishing stuff.
@@ -354,11 +320,6 @@ function getViewTransformer( csn, options, messageFunctions ) {
       if (isSelect) {
         if (!columnMap[elemName])
           addProjectionOrStarElement(query, isProjection, isSelectStar, $combined, columnMap, elemName);
-
-        // For associations - make sure that the foreign keys have the same "style"
-        // If A.assoc => A.assoc_id, else if assoc => assoc_id or assoc as Assoc => Assoc_id
-        if (elem.keys && doA2J)
-          addForeignKeysToColumns(columnMap, elem, elemName);
       }
       // Views must have at least one element that is not an unmanaged assoc
       if (!elem.on && !elem.$ignore)

package/lib/transform/effective/associations.js

@@ -3,11 +3,10 @@
 const { setProp } = require('../../base/model');
 const flattening = require('../db/flattening');
 const {
-  applyTransformations, forEachDefinition, forEachMemberRecursively, implicitAs, forEachMember, applyTransformationsOnNonDictionary,
+  applyTransformations, forEachDefinition, forEachMemberRecursively, forEachMember, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
 const associations = require('../db/associations');
 const backlinks = require('../db/backlinks');
-const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 
 /**
@@ -17,13 +16,14 @@ const { cloneCsnNonDict } = require('../../model/cloneCsn');
  * - adding a corresponding on-condition
  * @param {CSN.Model} csn Input CSN - will not be transformed
  * @param {CSN.Options} options
- * @param {object} csnUtils
+ * @param {object} transformerUtils
  * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @todo Remove .keys afterwards
  * @todo Add created foreign keys into .columns in case of a query?
  * @returns {CSN.Model}
  */
-function turnAssociationsIntoUnmanaged( csn, options, csnUtils, messageFunctions ) {
+function turnAssociationsIntoUnmanaged( csn, options, transformerUtils, messageFunctions ) {
+  const { csnUtils, expandManagedToFksInArray } = transformerUtils;
   // TODO: Do we really need this?
   forEachDefinition(csn, (artifact, artifactName) => {
     setProp(artifact, '$path', [ 'definitions', artifactName ]);
@@ -62,56 +62,6 @@ function turnAssociationsIntoUnmanaged( csn, options, csnUtils, messageFunctions
   associations.attachOnConditions(csn, csnUtils, '_', { allowArtifact: () => true }, options);
 
   return csn;
-
-  /**
-   * Expand managed associations in an array and insert them in-place
-   *
-   * If requested, leave out the assocs themselves
-   *
-   * @param {boolean} [killAssoc=false]
-   * @returns {Function} applyTransformationsCallback
-   */
-  function expandManagedToFksInArray( killAssoc = false ) {
-    return function expand(parent, prop, array, path) {
-      const newColumns = [];
-      for (let i = 0; i < array.length; i++) {
-        const col = array[i];
-        const element = csnUtils.getElement(col) || col.ref && csnUtils.inspectRef(path.concat(prop, i)).art;
-        if (!killAssoc || !element?.keys)
-          newColumns.push(col);
-        if (element?.keys)
-          element.keys.forEach(fk => addForeignKeyToColumns(fk, newColumns, col, options));
-      }
-      parent[prop] = newColumns;
-    };
-  }
-}
-
-
-/**
- * FKs need to be added to the .columns
- * @todo stolen from lib/transform/db/views.js
- * @todo Can we maybe do this during expansion already?
- * @param {object} foreignKey
- * @param {object[]} columns
- * @param {CSN.Column} associationColumn
- * @param {CSN.Options} options
- */
-function addForeignKeyToColumns( foreignKey, columns, associationColumn, options ) {
-  const ref = cloneCsnNonDict(associationColumn.ref, options);
-  ref[ref.length - 1] = [ implicitAs(ref) ].concat(foreignKey.as || foreignKey.ref).join('_');
-  const result = {
-    ref,
-  };
-  if (associationColumn.as) {
-    const columnName = `${ associationColumn.as }_${ foreignKey.as || implicitAs(foreignKey.ref) }`;
-    result.as = columnName;
-  }
-
-  if (associationColumn.key)
-    result.key = true;
-
-  columns.push(result);
 }
 
 /**
@@ -121,8 +71,8 @@ function addForeignKeyToColumns( foreignKey, columns, associationColumn, options
  * @param {object} csnUtils
  * @param {object} messageFunctions
  */
-function transformBacklinks( csn, options, csnUtils, messageFunctions ) {
-  forEachDefinition(csn, backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, '_', true));
+function transformBacklinks( csn, options, { csnUtils }, messageFunctions ) {
+  forEachDefinition(csn, backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, '_', true), { skip: [ 'aspect' ] });
 }
 
 module.exports = {

package/lib/transform/effective/main.js

@@ -90,8 +90,10 @@ function effectiveCsn( model, options, messageFunctions ) {
   resolveTypesInActionsAfterFlattening(csnUtils);
 
   processCalculatedElementsInEntities(csn, options);
-  associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
-  associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
+  // invalidate csnRef caches after flattening
+  transformerUtils.csnUtils = getUtils(csn, 'init-all');
+  associations.managedToUnmanaged(csn, options, transformerUtils, messageFunctions);
+  associations.transformBacklinks(csn, options, transformerUtils, messageFunctions);
   const transformers = mergeTransformers([
     options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {},
     misc.removeDefinitionsAndProperties(csn, options),

package/lib/transform/effective/misc.js

@@ -87,10 +87,10 @@ function _removeDefinitionsAndProperties( csn, options ) {
     // Set when we remove .key from temporal things, used in localized.js
     $key: killProp,
     includes: killProp,
-    enum: killProp,
     keys: killProp,
     excluding: killProp, // * is resolved, so has no effect anymore
     targetAspect: killProp,
+    $calc: killProp,
   };
 
   if (!options.keepLocalized)