@sap/cds-compiler 4.9.4 → 5.0.6

package/lib/transform/db/flattening.js

@@ -12,10 +12,11 @@ const {
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 const { transformExpression } = require('./applyTransformations');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
+const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
 
 /**
  * Strip off leading $self from refs where applicable.
@@ -206,9 +207,24 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
  * @param {object} iterateOptions
  */
 function flattenAllStructStepsInRefs( csn, options, messageFunctions, resolved, pathDelimiter, iterateOptions = {} ) {
+  const adaptRefs = [];
+
+  applyTransformations(csn, getStructStepsFlattener(csn, options, messageFunctions, resolved, pathDelimiter, adaptRefs), [], iterateOptions);
+
+  adaptRefs.forEach(fn => fn());
+}
+/**
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @param {WeakMap} resolved Cache for resolved refs
+ * @param {string} pathDelimiter
+ * @param {Function[]} adaptRefs
+ * @returns {object} applyTransformations transformer
+ */
+function getStructStepsFlattener( csn, options, messageFunctions, resolved, pathDelimiter, adaptRefs ) {
   const { inspectRef, effectiveType } = csnRefs(csn);
   const { flattenStructStepsInRef } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
-  const adaptRefs = [];
 
   /**
    * For each step of the links, check if there is a type reference.
@@ -229,41 +245,57 @@ function flattenAllStructStepsInRefs( csn, options, messageFunctions, resolved,
     return resolvedLinkTypes;
   }
 
-  applyTransformations(csn, {
+  const transformer = {
     // @ts-ignore
-    ref: (parent, prop, ref, path) => {
+    ref: (parent, prop, ref, path, _parent, _prop, context) => {
       const { links, art, scope } = inspectRef(path);
       const resolvedLinkTypes = resolveLinkTypes(links);
       setProp(parent, '$path', [ ...path ]);
       const lastRef = ref[ref.length - 1];
-      const fn = () => {
-        const scopedPath = [ ...parent.$path ];
-        // TODO: If foreign key annotations should be assigned via
-        //       full path into target, uncomment this line and
-        //       comment/remove setProp in expansion.js
-        // setProp(parent, '$structRef', parent.ref);
-        [ parent.ref ] = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes);
-        resolved.set(parent, { links, art, scope });
-        // Explicitly set implicit alias for things that are now flattened - but only in columns
-        // TODO: Can this be done elegantly during expand phase already?
-        if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
-          if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
-            delete parent.as;
-          delete parent.$implicitAlias;
-        }
-        // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
-        else if (parent.ref[parent.ref.length - 1] !== lastRef &&
-                (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
-                !parent.as) {
-          parent.as = lastRef;
+      const fn = (suspend = false, suspendPos = 0,
+                  refFilter = _parent => true) => {
+        let refChanged = false;
+        if (refFilter(parent)) {
+          const scopedPath = [ ...parent.$path ];
+          // TODO: If foreign key annotations should be assigned via
+          //       full path into target, uncomment this line and
+          //       comment/remove setProp in expansion.js
+          // setProp(parent, '$structRef', parent.ref);
+          [ parent.ref, refChanged ] = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, suspend, suspendPos, parent.$bparam);
+          resolved.set(parent, { links, art, scope });
+          // Explicitly set implicit alias for things that are now flattened - but only in columns
+          // TODO: Can this be done elegantly during expand phase already?
+          if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
+            if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+              delete parent.as;
+            delete parent.$implicitAlias;
+          }
+          // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
+          else if (parent.ref[parent.ref.length - 1] !== lastRef &&
+                      (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
+                      !parent.as) {
+            parent.as = lastRef;
+          }
         }
+
+        return refChanged;
       };
-      // adapt queries later
-      adaptRefs.push(fn);
+
+      if (context?.$annotation) {
+        const annotation = context.$annotation.value;
+        adaptRefs.push((...args) => {
+          const refChanged = fn(...args);
+          if (refChanged && annotation['='])
+            annotation['='] = true;
+        });
+      }
+      else {
+        // adapt queries later
+        adaptRefs.push(fn);
+      }
     },
-  }, [], iterateOptions);
+  };
 
-  adaptRefs.forEach(fn => fn());
 
   /**
    * Return true if the path points inside columns
@@ -283,6 +315,8 @@ function flattenAllStructStepsInRefs( csn, options, messageFunctions, resolved,
   function insideKeys( path ) {
     return path.length >= 3 && path[path.length - 2] === 'keys' && typeof path[path.length - 1] === 'number';
   }
+
+  return transformer;
 }
 
 /**
@@ -343,25 +377,28 @@ function flattenElements( csn, options, messageFunctions, pathDelimiter, iterate
           if (flatElement.type && isAssocOrComposition(flatElement) && flatElement.on) {
             // unmanaged relations can't be primary key
             delete flatElement.key;
-            transformExpression(flatElement, 'on', {
-              ref: (_parent, _prop, xpr) => {
-                const prefix = flatElement._flatElementNameWithDots.split('.').slice(0, -1).join(pathDelimiter);
+            if (options.transformation !== 'effective') {
+              const process = endIndex => function processRef(_parent, _prop, xpr) {
+                const prefix = flatElement._flatElementNameWithDots.split('.').slice(0, endIndex).join(pathDelimiter);
                 const possibleFlatName = prefix + pathDelimiter + xpr[0];
                 /*
-                    when element is defined in the current name resolution scope, like
-                      entity E {
-                        key x: Integer;
-                            s : {
-                            y : Integer;
-                            a3 : association to E on a3.x = y;
-                            }
-                      }
-                    We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
-                  */
+                      when element is defined in the current name resolution scope, like
+                        entity E {
+                          key x: Integer;
+                              s : {
+                              y : Integer;
+                              a3 : association to E on a3.x = y;
+                              }
+                        }
+                      We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
+                    */
                 if (flatElems[possibleFlatName])
                   xpr[0] = possibleFlatName;
-              },
-            });
+              };
+              transformExpression(flatElement, 'on', {
+                ref: process(-1),
+              });
+            }
           }
           parent[prop].$orderedElements.push([ flatElemName, flatElement ]);
           // Still add them - otherwise we might not detect collisions between generated elements.
@@ -427,36 +464,6 @@ function getBranches( element, elementName, effectiveType, pathDelimiter ) {
   return branches;
 }
 
-/**
- * Link annotate extensions to managed associations as a preparational step
- * for later annotation assignment on the final foreignkeys
- * This function must be applied on an unmodified, structured CSN in order to
- * traverse both the extensions and dictionary trees in corresponding order.
- *
- * @param {CSN.Model} csn
- * @param {object} options
- */
-function linkForeignKeyAnnotationExtensionsToAssociation( csn, options ) {
-  if (isBetaEnabled(options, 'annotateForeignKeys')) {
-    csn.extensions?.forEach(( ext ) => {
-      const defName = ext.annotate;
-
-      const traverseExtensions = (env, enode) => {
-        if (env?.target && env?.keys) {
-          setProp(env, '$fkExtensions', enode);
-        }
-        else {
-          const elements = env?.items?.elements || env?.elements;
-          if (enode?.elements && elements)
-            Object.keys(enode.elements).forEach(en => traverseExtensions(elements[en], enode.elements[en]));
-        }
-      };
-      if (ext.annotate)
-        traverseExtensions(csn.definitions[defName], ext);
-    });
-  }
-}
-
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
@@ -587,7 +594,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
      * @returns {object} The clone of base
      */
     function cloneAndExtendRef( key, base, ref ) {
-      const clone = cloneCsnNonDict(base, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
+      const clone = cloneCsnNonDict(base, options );
       if (key.ref) {
         // We build a ref that contains the aliased fk - that element will be created later on, so this ref is not resolvable yet
         // Therefore we keep it as $ref - ref is the non-aliased, resolvable "clone"
@@ -603,8 +610,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
         }
         setProp(clone, '$ref', $ref);
         clone.ref = clone.ref.concat(key.ref);
-        if (clone.$structRef && key.$structRef)
-          clone.$structRef = clone.$structRef.concat(key.$structRef);
       }
 
       if (!clone.as && clone.ref && clone.ref.length > 0) {
@@ -704,34 +709,9 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
                       'Expected target cardinality $(VALUE) and $(CODE) to match');
             }
           }
-        }
-        // assign annotations from fkExtension tree to foreign keys
-        if (isBetaEnabled(options, 'annotateForeignKeys')) {
-          const extCollector = {};
-          fks.forEach(([ _fkn, fk ]) => {
-            let ext = element.$fkExtensions;
-            let extKey = elementName;
-            for (const step of fk.$extensionPath) {
-              extKey += `.${step}`;
-              ext = ext?.elements?.[step];
-              if (!ext)
-                break;
-              // collect annotations, lowest wins
-              // eslint-disable-next-line no-loop-func
-              Object.entries(ext).forEach(([ k, v ]) => {
-                if (k[0] === '@') {
-                  fk[k] = v;
-                  extCollector[extKey] = ext;
-                }
-              });
-            }
-          });
 
-          // remove consumed annotations after applying the annotation hierarchy to each fk!
-          Object.values(extCollector).forEach(ext => Object.keys(ext).forEach((k) => {
-            if (k[0] === '@')
-              delete ext[k];
-          }));
+          if (options.transformation === 'effective')
+            delete element.default;
         }
         orderedElements.push(...fks);
       });
@@ -756,11 +736,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
  * @param {CSN.Model} csn
  * @param {object} options
  * @param {string} pathDelimiter
- * @param {object} extensionPath
  * @param {number} lvl
  * @returns {Array[]} First element of every sub-array is the foreign key name, second is the foreign key definition
  */
-function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, extensionPath = [], lvl = 0 ) {
+function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0 ) {
   const special$self = !csn?.definitions?.$self && '$self';
   const isInspectRefResult = !Array.isArray(path);
 
@@ -806,7 +785,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       const continuePath = getContinuePath([ 'keys', keyIndex ]);
       const alias = key.as || implicitAs(key.ref);
       const result = csnUtils.inspectRef(continuePath);
-      fks = fks.concat(createForeignKeys(csnUtils, result, result.art, alias, csn, options, pathDelimiter, extensionPath.concat(key.$structRef), lvl + 1));
+      fks = fks.concat(createForeignKeys(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
     });
     if (!hasKeys)
       delete finalElement.keys;
@@ -820,19 +799,18 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       // Skip already produced foreign keys
       if (!elem['@odata.foreignKey4']) {
         const continuePath = getContinuePath([ 'elements', elemName ]);
-        fks = fks.concat(createForeignKeys(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, extensionPath.concat(elemName), lvl + 1));
+        fks = fks.concat(createForeignKeys(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
       }
     });
   }
   // we have reached a leaf element, create a foreign key
   else if (finalElement.type == null || isBuiltinType(finalElement.type)) {
     const newFk = Object.create(null);
-    setProp(newFk, '$extensionPath', extensionPath);
-    for (const prop of [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type' ]) {
+    [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
       // copy props from original element to preserve derived types!
       if (element[prop] !== undefined)
         newFk[prop] = element[prop];
-    }
+    });
     return [ [ prefix, newFk ] ];
   }
 
@@ -886,7 +864,7 @@ module.exports = {
   flattenAllStructStepsInRefs,
   flattenElements,
   removeLeadingSelf,
-  linkForeignKeyAnnotationExtensionsToAssociation,
   handleManagedAssociationsAndCreateForeignKeys,
   getBranches,
+  getStructStepsFlattener,
 };

package/lib/transform/db/temporal.js

@@ -70,11 +70,10 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
               ],
             };
 
-            // Clarify: What about $valid?
-            const atFrom = { ref: [ '$at', 'from' ] };
-            const atTo = { ref: [ '$at', 'to' ] };
+            const validFrom = { ref: [ '$valid', 'from' ] };
+            const validTo = { ref: [ '$valid', 'to' ] };
 
-            const cond = [ '(', fromPath, '<', atTo, 'and', toPath, '>', atFrom, ')' ];
+            const cond = [ '(', fromPath, '<', validTo, 'and', toPath, '>', validFrom, ')' ];
 
             if (normalizedQuery.query.SELECT.where) { // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
               normalizedQuery.query.SELECT.where = [ '(', ...normalizedQuery.query.SELECT.where, ')', 'and', ...cond ];

package/lib/transform/db/views.js

@@ -324,7 +324,6 @@ function getViewTransformer( csn, options, messageFunctions ) {
    * @param {string} artName
    * @param {CSN.Path} path
    */
-  // eslint-disable-next-line complexity
   function transformViewOrEntity( query, artifact, artName, path ) {
     const ignoreAssociations = options.sqlDialect === 'hana' && options.withHanaAssociations === false;
     csnUtils.initDefinition(artifact);

package/lib/transform/draft/odata.js

@@ -1,6 +1,8 @@
 'use strict';
 
-const { forEachDefinition, getServiceNames, applyAnnotationsFromExtensions } = require('../../model/csnUtils');
+const { forEachDefinition, forEachMemberRecursively,
+  getServiceNames, applyAnnotationsFromExtensions,
+  transformExpression } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtils');
@@ -58,12 +60,13 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     // Generate artificial draft fields for entities/views if requested, ignore if not part of a service
     if (def.kind === 'entity' && def['@odata.draft.enabled'] && isArtifactInSomeService(defName, services))
       generateDraftForOdata(def, defName, def);
-
-    visitedArtifacts[defName] = true;
   }, { skipArtifact: isExternalServiceMember });
 
   applyAnnotationsFromExtensions(csn, { override: true, filter: name => filterDict[name] });
+  rewriteDollarDraft();
+
   return csn;
+
   /**
    * Generate all that is required in ODATA for draft enablement of 'artifact' into the artifact,
    * into its transitively reachable composition targets, and into the model.
@@ -84,6 +87,9 @@ function generateDrafts( csn, options, services, messageFunctions ) {
         artifact.actions && artifact.actions.draftPrepare)
       return;
 
+    if(!visitedArtifacts[artifactName])
+      visitedArtifacts[artifactName] = artifact;
+    
     const draftPrepare = createAction('draftPrepare', artifactName, 'SideEffectsQualifier', 'cds.String');
     assignAction(draftPrepare, artifact);
     // Generate the actions into the draft-enabled artifact (only draft roots can be activated/edited)
@@ -211,6 +217,48 @@ function generateDrafts( csn, options, services, messageFunctions ) {
       }
     }
   }
+
+    /*
+     * After draft decoration, all visited artifacts are supposed to have the draft state elements
+     * Is/HasActiveEntity, HasDraftEntity. Now, $draft.<postfix> (with postfix defined as magic variable
+     * in the core compiler builtins) needs to be translated into $self.<postfix>.
+     * 
+     * It has to be processed after the late 'applyAnnotationsFromExtensions' which could also merge in
+     * some $draft path expressions.
+  */
+  function rewriteDollarDraft() {
+
+    function $draft2$self(member) {
+      Object.keys(member).forEach(pn => {
+        if(pn[0] === '@')
+          transformExpression(member, pn,{
+            ref: (_parent, _prop, xpr, _path) => {
+              if(xpr[0] === '$draft') {
+                xpr[0] = '$self';
+              }
+            }
+          });
+      });
+    }
+
+    // entity parameters are not substituted as the EDM param entity is not draft enabled
+    Object.entries(visitedArtifacts).forEach(([artName, art]) => {
+      $draft2$self(art);
+      forEachMemberRecursively(art, $draft2$self,
+        [ 'definitions', artName ],
+        true, { elementsOnly: true }
+      );
+      if(art.actions) {
+        Object.entries(art.actions).forEach(([actionName, action]) => {
+          $draft2$self(action);
+          forEachMemberRecursively(action, $draft2$self,
+          [ 'definitions', artName, 'actions',  actionName ]);
+          if(action.returns)
+            $draft2$self(action.returns);
+        })
+      }
+    })
+  }
 }
 
 module.exports = generateDrafts;

package/lib/transform/effective/annotations.js

@@ -179,9 +179,10 @@ function remapODataAnnotations( csn ) {
   }
 
   return {
-    elements: (parent, prop, elements, path) => {
+    elements: (parent, prop, elements, path, _parentParent, _dummy, context) => {
       const artifact = csn.definitions[path[1]];
-      if (artifact?.kind === 'entity') {
+      // Don't process bound actions, as they are still structured
+      if (artifact?.kind === 'entity' && !context.$in_actions) {
         for (const elementName in elements)
           remapAnnotationsOnElement(artifact, elements[elementName]);
       }

package/lib/transform/effective/flattening.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const {
+  forEachDefinition, forEachMemberRecursively, findAnnotationExpression, applyTransformationsOnNonDictionary, transformExpression,
+} = require('../../model/csnUtils');
+const { getStructStepsFlattener } = require('../db/flattening');
+const { setProp } = require('../../base/model');
+const { forEach } = require('../../utils/objectUtils');
+
+
+/**
+ *
+ * @param csn
+ * @param options
+ * @param csnUtils
+ * @param messageFunctions
+ */
+function flattenRefs( csn, options, csnUtils, messageFunctions ) {
+  const cleanup = [];
+  forEachDefinition(csn, (artifact) => {
+    if (artifact.elements) {
+      const stack = [ { prefix: [], elements: artifact.elements } ];
+      while (stack.length > 0) {
+        const { prefix, elements } = stack.pop();
+        forEach(elements, (elementName, element) => {
+          if (element.elements)
+            stack.push({ prefix: prefix.concat(elementName), elements: element.elements });
+
+          const absolutifier = absolutifyPaths(prefix, cleanup);
+          // Absolutify paths in on-conditions
+          if (element.on) {
+            transformExpression(element, 'on', {
+              ref: absolutifier,
+            }, []);
+          }
+
+          // Absolutify paths in annotation expressions
+          Object.keys(element)
+            .filter(pn => findAnnotationExpression(element, pn))
+            .forEach((anno) => {
+              applyTransformationsOnNonDictionary(element, anno, {
+                xpr: (parent, prop) => {
+                  transformExpression(parent, prop, {
+                    ref: absolutifier,
+                  }, []);
+                },
+              }, {}, []);
+              if (element[anno].ref)
+                absolutifier(element[anno], 'ref', element[anno].ref);
+            });
+        });
+      }
+    }
+  });
+
+
+  const adaptRefs = [];
+  const resolved = new WeakMap();
+  const refFlattener = getStructStepsFlattener(csn, options, messageFunctions, resolved, '_', adaptRefs);
+
+  forEachDefinition(csn, (def, defName) => {
+    if (def.kind === 'entity') {
+      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: true, skipDict: { actions: 1 } }, [ 'definitions' ]);
+
+      adaptRefs.forEach(fn => fn());
+      adaptRefs.length = 0;
+
+      // explicit binding parameter of bound action
+      if (def.actions) {
+        const special$self = !csn?.definitions?.$self && '$self';
+        Object.entries(def.actions).forEach(([ an, a ]) => {
+          if (a.params) {
+            const params = Object.entries(a.params);
+            const firstParam = params[0][1];
+            const type = firstParam?.items?.type || firstParam?.type;
+            if (type === special$self) {
+              const bindingParamName = params[0][0];
+              const markBindingParam = {
+                ref: (parent, prop, xpr) => {
+                  if ((xpr[0].id || xpr[0]) === bindingParamName)
+                    setProp(parent, '$bparam', true);
+                },
+              };
+
+              Object.keys(a)
+                .filter(pn => findAnnotationExpression(a, pn))
+                .forEach((pn) => {
+                  transformExpression(a, pn, [ markBindingParam, refFlattener ], [ 'definitions', defName, 'actions', an ]);
+                  adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
+                  adaptRefs.length = 0;
+                });
+
+
+              forEachMemberRecursively(a, (member, memberName, prop, path) => {
+                Object.keys(member).filter(pn => findAnnotationExpression(member, pn)).forEach((pn) => {
+                  transformExpression(member, pn, [ markBindingParam, refFlattener ], path);
+                  adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
+                  adaptRefs.length = 0;
+                });
+              }, [ 'definitions', defName, 'actions', an ]);
+            }
+          }
+        });
+      }
+    }
+    else {
+      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: false }, [ 'definitions' ]);
+      adaptRefs.forEach(fn => fn());
+      adaptRefs.length = 0;
+    }
+  });
+
+  cleanup.forEach((obj) => {
+    if (obj.ref && obj.ref[0] === '$self')
+      obj.ref.shift();
+  });
+}
+
+function absolutifyPaths(prefix, cleanup) {
+  return function absolutify(_parent, _prop, ref) {
+    if (ref[0].id || ref[0] !== '$self' && ref[0] !== '$projection' && !ref[0].startsWith('$') && !_parent.param) {
+      _parent.ref = [ '$self', ...prefix, ...ref ];
+      cleanup.push(_parent);
+
+      return true;
+    }
+
+    return false;
+  };
+}
+
+
+module.exports = {
+  flattenRefs,
+};

package/lib/transform/effective/main.js

@@ -4,6 +4,7 @@ const {
   getUtils, isAspect, mergeTransformers, applyTransformations,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
+const effectiveFlattening = require('./flattening');
 const flattening = require('../db/flattening');
 const types = require('./types');
 // const { addLocalizationViews } = require('../../transform/localized');
@@ -11,7 +12,6 @@ const validate = require('../../checks/validator');
 const expansion = require('../db/expansion');
 const queries = require('./queries');
 const associations = require('./associations');
-const generateDrafts = require('../draft/db');
 const handleExists = require('../db/transformExists');
 const misc = require('./misc');
 const annotations = require('./annotations');
@@ -66,8 +66,9 @@ function effectiveCsn( model, options, messageFunctions ) {
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
 
-  flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, new WeakMap(), '_');
-  flattening.flattenElements(csn, options, messageFunctions, '_');
+
+  effectiveFlattening.flattenRefs(csn, options, csnUtils, messageFunctions);
+  flattening.flattenElements(csn, options, messageFunctions, '_', { skipDict: { actions: true } });
 
   resolveTypesInActionsAfterFlattening();
 
@@ -77,9 +78,8 @@ function effectiveCsn( model, options, messageFunctions ) {
   processCalculatedElementsInEntities(csn);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
-  generateDrafts(csn, options, '_', messageFunctions);
-  const transformers = mergeTransformers([ misc.attachPersistenceName(csn, options, csnUtils), options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
-  applyTransformations(csn, transformers, [], { skipIgnore: false });
+  const transformers = mergeTransformers([ options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {}, options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
+  applyTransformations(csn, transformers, [], { skipIgnore: false, processAnnotations: true });
 
   if (!options.resolveProjections)
     redoProjections.forEach(fn => fn());