@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/transform/db/backlinks.js

@@ -193,7 +193,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
     // Transform comparison of $self to managed association into AND-combined foreign key comparisons
     if (assoc.keys) {
       if (assoc.keys.length)
-        return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName);
+        return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName, art, path);
 
       if (options.transformation !== 'effective')
         elem.$ignore = true;
@@ -202,7 +202,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
 
     // Transform comparison of $self to unmanaged association into "reversed" ON-condition
     else if (assoc.on) {
-      return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName);
+      return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName, art, path);
     }
 
     throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${JSON.stringify(elem.on)}`);
@@ -220,9 +220,11 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {CSN.Element} assoc
    * @param {string} originalAssocName
    * @param {string} elemName
+   * @param {CSN.Artifact} art
+   * @param {CSN.Path} path
    * @returns {Array} New on-condition
    */
-  function transformDollarSelfComparisonWithManagedAssoc( assocOp, assoc, originalAssocName, elemName ) {
+  function transformDollarSelfComparisonWithManagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path) {
     const conditions = [];
     // if the element was structured then it was flattened => change of the delimiter from '.' to '_'
     // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
@@ -245,7 +247,9 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
       if (prepend$self)
         a[1].ref = [ '$self', ...a[1].ref ];
 
-
+      // Not without a2j so we can rely on a certain model state
+      if (doA2J && prepend$self && art.elements[k.ref[1]] || !prepend$self && !art.elements[k.ref[0]])
+        messageFunctions.message('ref-missing-self-counterpart', path, { prop: k.ref[0], name: assocName });
       conditions.push([ a[0], '=', a[1] ]);
     });
 
@@ -268,9 +272,11 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * @param {CSN.Element} assoc
    * @param {string} originalAssocName
    * @param {string} elemName
+   * @param {CSN.Artifact} art
+   * @param {CSN.Path} path
    * @returns {Array} New on-condition
    */
-  function transformDollarSelfComparisonWithUnmanagedAssoc( assocOp, assoc, originalAssocName, elemName ) {
+  function transformDollarSelfComparisonWithUnmanagedAssoc( assocOp, assoc, originalAssocName, elemName, art, path ) {
     // if the element was structured then it may have been flattened => change of the delimiter from '.' to '_'
     // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
     elemName = elemName.replace(/\./g, pathDelimiter);
@@ -279,11 +285,14 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
     const newOnCond = cloneCsnNonDict(assoc.on, options);
     applyTransformationsOnNonDictionary({ on: newOnCond }, 'on', {
       ref: (parent, prop, ref) => {
+        let sourceSide = false;
         // we are in the "path" from the forwarding assoc => need to remove the first part of the path
         if (ref[0] === assocName) {
           ref.shift();
           if (prepend$self)
             ref.unshift('$self');
+
+          sourceSide = true;
         }
         else if (ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
           // We could also have a $self in front of the assoc name - so we would need to shift twice
@@ -291,6 +300,8 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
           ref.shift();
           if (prepend$self)
             ref.unshift('$self');
+
+          sourceSide = true;
         }
         else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
           ref.unshift(elemName);
@@ -299,6 +310,10 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
           if (ref[1] === '$self')
             ref.splice(1, 1);
         }
+
+        // Not without a2j so we can rely on a certain model state
+        if (doA2J && sourceSide && (prepend$self && !art.elements[ref[1]] || !prepend$self && !art.elements[ref[0]]))
+          messageFunctions.message('ref-missing-self-counterpart', path, { '#': 'unmanaged', prop: ref[0], name: assocName });
       },
     });
     return newOnCond;

package/lib/transform/db/expansion.js

@@ -47,7 +47,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         const isComplexQuery = parent.from.join !== undefined;
         if (!options.toOdata)
           parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
-        // FIXME(v5): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
+        // FIXME(v6): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
         // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
         parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
       }
@@ -622,11 +622,6 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     return _expandStructCol(art, columnAlias(root), root.ref, ( currentRef, currentAlias) => {
       const obj = { ...root, ref: currentRef };
       if (withAlias) {
-        // TODO: Remove this line in case foreign key annotations should
-        //       be addressed via full path into target instead of using alias
-        //       names. See flattening.js::flattenAllStructStepsInRefs()
-        //       apply transformations on `ref` counterpart comment.
-        setProp(obj, '$structRef', currentAlias);
         obj.as = currentAlias.join(pathDelimiter);
         // alias was implicit - to later distinguish expanded s -> s.a from explicitly written s.a
         if (root.as === undefined)

package/lib/transform/db/flattening.js

@@ -12,7 +12,7 @@ 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');
@@ -207,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.
@@ -230,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
@@ -284,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;
 }
 
 /**
@@ -344,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.
@@ -428,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
@@ -588,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"
@@ -604,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) {
@@ -705,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);
       });
@@ -757,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);
 
@@ -807,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;
@@ -821,14 +799,13 @@ 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);
     [ '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)
@@ -887,7 +864,7 @@ module.exports = {
   flattenAllStructStepsInRefs,
   flattenElements,
   removeLeadingSelf,
-  linkForeignKeyAnnotationExtensionsToAssociation,
   handleManagedAssociationsAndCreateForeignKeys,
   getBranches,
+  getStructStepsFlattener,
 };

package/lib/transform/db/killAnnotations.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { sqlServiceAnnotation } = require('./processSqlServices');
+
 const requiredAnnos = {
   '@cds.persistence.skip': true,
   '@cds.persistence.exists': true,
@@ -22,6 +24,7 @@ const requiredAnnos = {
   '@cds.autoexposed': true,
   '@cds.redirection.target': true,
   '@Core.Computed': true,
+  [sqlServiceAnnotation]: true,
 };
 
 /**

package/lib/transform/db/processSqlServices.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { setProp } = require('../../base/model');
+
+const sqlServiceAnnotation = '@protocol';
+// Problem: How can we clone a Symbol when sorting?
+// const sqlServiceEntities = Symbol.for('SQL Service enabled entities');
+/**
+ * Find all entities in SQL services and mark them with an annotation and
+ * remember them in a symbol property for easier processing in toSql-rendering.
+ *
+ * @param {CSN.Model} csn
+ * @returns {Function}
+ */
+function processSqlServices(csn) {
+  setProp(csn, '$sqlServiceEntities', Object.create(null));
+  return function findAndMarkSqlServiceArtifacts(artifact, artifactName) {
+    const sqlServiceName = isEntityInSqlService(artifact, artifactName, csn);
+    if (sqlServiceName?.length > 0)
+      setProp(artifact, '$sqlService', sqlServiceName);
+  };
+}
+
+/**
+ *
+ * @param {CSN.Artifact} artifact
+ * @returns {boolean}
+ */
+function isSqlService(artifact) {
+  return artifact.kind === 'service' && artifact[sqlServiceAnnotation] === 'sql';
+}
+/**
+ *
+ * @param {CSN.Artifact} artifact
+ * @param {string} artifactName
+ * @param {CSN.Model} csn
+ * @returns {string|null}
+ */
+function isEntityInSqlService(artifact, artifactName, csn) {
+  if (artifact.kind !== 'entity' || !artifactName.includes('.'))
+    return null;
+
+  const nameParts = artifactName.split('.');
+  for (let i = nameParts.length; i >= 0; i--) {
+    const possibleServiceName = nameParts.slice(0, i).join('.');
+    if (!csn.definitions[possibleServiceName])
+      continue;
+
+    const definition = csn.definitions[possibleServiceName];
+    if (isSqlService(definition))
+      return possibleServiceName;
+
+    // We don't allow nested services/contexts - if we find one, we don't need to keep searching
+    if (definition.kind === 'service' || definition.kind === 'context')
+      return null;
+  }
+
+  return null;
+}
+
+module.exports = {
+  processSqlServices, isSqlService, sqlServiceAnnotation,
+};

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,53 @@ 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] === '@') {
+          let refChanged = false;
+          transformExpression(member, pn,{
+            ref: (_parent, _prop, xpr, _path) => {
+              if(xpr[0] === '$draft') {
+                xpr[0] = '$self';
+                refChanged = true;
+              }
+            }
+          });
+          if (refChanged)
+            member[pn]['='] = true;
+        }
+      });
+    }
+
+    // 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]);
       }