@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/transform/db/views.js

@@ -1,10 +1,63 @@
 'use strict';
 
-const { usesMixinAssociation, getMixinAssocOfQueryIfPublished } = require('./helpers');
-const { getUtils, cloneCsn } = require('../../model/csnUtils');
+const {
+  getUtils, cloneCsn, applyTransformationsOnNonDictionary,
+} = require('../../model/csnUtils');
 const { implicitAs, csnRefs } = require('../../model/csnRefs');
 const { isBetaEnabled } = require('../../base/model');
+const { ModelError } = require('../../base/error');
 
+/**
+ * If a mixin association is published, return the mixin association.
+ *
+ * @param {CSN.Query} query Query of the artifact to check
+ * @param {object} association Association (Element) published by the view
+ * @param {string} associationName
+ * @returns {object} The mixin association
+ */
+function getMixinAssocOfQueryIfPublished(query, association, associationName) {
+  if (query && query.SELECT && query.SELECT.mixin) {
+    const aliasedColumnsMap = Object.create(null);
+    if (query.SELECT.columns) {
+      for (const column of query.SELECT.columns) {
+        if (column.as && column.ref && column.ref.length === 1)
+          aliasedColumnsMap[column.as] = column;
+      }
+    }
+
+    for (const elem of Object.keys(query.SELECT.mixin)) {
+      const mixinElement = query.SELECT.mixin[elem];
+      let originalName = associationName;
+      if (aliasedColumnsMap[associationName])
+        originalName = aliasedColumnsMap[associationName].ref[0];
+
+      if (elem === originalName)
+        return { mixinElement, mixinName: originalName };
+    }
+  }
+  return {};
+}
+
+/**
+ * Check whether the given artifact uses the given mixin association.
+ *
+ * We can rely on the fact that there can be no usage starting with $self/$projection,
+ * since lib/checks/selectItems.js forbids that.
+ *
+ * @param {CSN.Query} query Query of the artifact to check
+ * @param {object} association Mixin association (Element) to check for
+ * @param {string} associationName
+ * @returns {boolean} True if used
+ */
+function usesMixinAssociation(query, association, associationName) {
+  if (query && query.SELECT && query.SELECT.columns) {
+    for (const column of query.SELECT.columns) {
+      if (typeof column === 'object' && column.ref && column.ref.length > 1 && (column.ref[0] === associationName || column.ref[0].id === associationName))
+        return true;
+    }
+  }
+  return false;
+}
 
 /**
  * @param {CSN.Model} csn
@@ -15,7 +68,7 @@ const { isBetaEnabled } = require('../../base/model');
  */
 function getViewTransformer(csn, options, messageFunctions, transformCommon) {
   const {
-    get$combined, cloneWithTransformations, isAssocOrComposition,
+    get$combined, isAssocOrComposition,
   } = getUtils(csn);
   const { inspectRef, queryOrMain } = csnRefs(csn);
   const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
@@ -130,10 +183,10 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
       const matchingCombined = $combined[elemName];
       // Internal errors - this should never happen!
       if (matchingCombined.length > 1) { // should already be caught by compiler
-        throw new Error(`Ambiguous name - can't be resolved: ${elemName}. Found in: ${matchingCombined.map(o => o.parent)}`);
+        throw new ModelError(`Ambiguous name - can't be resolved: ${elemName}. Found in: ${matchingCombined.map(o => o.parent)}`);
       }
       else if (matchingCombined.length === 0) { // no clue how this could happen? Invalid CSN?
-        throw new Error(`No matching entry found in UNION of all elements for: ${elemName}`);
+        throw new ModelError(`No matching entry found in UNION of all elements for: ${elemName}`);
       }
       alias = matchingCombined[0].parent;
     }
@@ -181,41 +234,38 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
    * create the __clone for publishing stuff.
    *
    * @todo Factor out the checks
-   * @todo Union, Join, Subqueries? Assoc usage in there? __clone?
    * @param {CSN.Query} query
    * @param {object} elements
    * @param {object} columnMap
    * @param {WeakMap} publishedMixins Map to collect the published mixins
    * @param {CSN.Element} elem
    * @param {string} elemName
-   * @param {CSN.Path} path
+   * @param {CSN.Path} elementsPath Path pointing to elements
+   * @param {CSN.Path} queryPath Path pointing to the query
    */
-  function handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, path) {
-    if (isUnion(path) && options.transformation === 'hdbcds') {
+  function handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath) {
+    if (isUnion(queryPath) && options.transformation === 'hdbcds') {
       if (isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J) {
         if (elem.keys)
-          info(null, path, `Managed association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, `Managed association "${elemName}", published in a UNION, will be ignored`);
         else
-          info(null, path, `Association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, `Association "${elemName}", published in a UNION, will be ignored`);
 
         elem._ignore = true;
       }
       else {
-        error(null, path, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`);
+        error(null, queryPath, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`);
       }
     }
-    else if (path.length > 4 && options.transformation === 'hdbcds') { // path.length > 4 -> is a subquery
-      error(null, path, { name: elemName },
+    else if (queryPath.length > 4 && options.transformation === 'hdbcds') { // path.length > 4 -> is a subquery
+      error(null, queryPath, { name: elemName },
             'Association $(NAME) can\'t be published in a subquery');
     }
     else {
-    /* Old implementation:
-    const isNotMixinByItself = !(elem.value && elem.value.path && elem.value.path.length == 1 && art.query && art.query.mixin && art.query.mixin[elem.value.path[0].id]);
-    */
       const isNotMixinByItself = checkIsNotMixinByItself(query, columnMap, elemName);
       const { mixinElement, mixinName } = getMixinAssocOfQueryIfPublished(query, elem, elemName);
       if (isNotMixinByItself || mixinElement !== undefined) {
-      // If the mixin is only published and not used, only display the __ clone. Kill the "original".
+        // If the mixin is only published and not used, only display the __ clone. Kill the "original".
         if (mixinElement !== undefined && !usesMixinAssociation(query, elem, elemName))
           delete query.SELECT.mixin[mixinName];
 
@@ -226,8 +276,8 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
           mixinElemName = `_${mixinElemName}`;
 
         // Copy the association element to the MIXIN clause under its alias name
-        // (shallow copy is sufficient, just fix name and value)
-        const mixinElem = Object.assign({}, elem);
+        // Needs to be a deep copy, as we transform the on-condition
+        const mixinElem = cloneCsn(elem, options);
         // Perform common transformations on the newly generated MIXIN element (won't be reached otherwise)
         transformCommon(mixinElem, mixinElemName);
 
@@ -238,30 +288,24 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
         // and fixing the association alias just created
 
         if (mixinElem.on) {
-          mixinElem.on = cloneWithTransformations(mixinElem.on, {
-            ref: (ref) => {
-            // Clone the path, without any transformations
-              const clonedPath = cloneWithTransformations(ref, {});
-              // Prepend '$projection' to the path, unless the first path step is the (mixin) element itself or starts with '$')
-              if (clonedPath[0] === elemName) {
-                clonedPath[0] = mixinElemName;
+          mixinElem.on = applyTransformationsOnNonDictionary(mixinElem, 'on', {
+            ref: (parent, prop, ref, refpath) => {
+              if (ref[0] === elemName) {
+                ref[0] = mixinElemName;
               }
-              else if (!(clonedPath[0] && clonedPath[0].startsWith('$'))) {
-                const projectionId = '$projection';
-                clonedPath.unshift(projectionId);
+              else if (!(ref[0] && ref[0].startsWith('$'))) {
+                ref.unshift('$projection');
               }
-              return clonedPath;
-            },
-            func: (func) => {
-            // Unfortunately, function names are disguised as paths, so we would prepend a '$projection'
-            // above (no way to distinguish that in the callback for 'path' above). We can only pluck it
-            // off again here ... sigh
-              if (func.ref && func.ref[0] && func.ref[0] === '$projection')
-                func.ref = func.ref.slice(1);
-
-              return func;
+              else if (ref[0] && ref[0].startsWith('$')) {
+                // TODO: I think this is non-sense. Stuff with $ is either magic or must start with $self, right?
+                const { scope } = inspectRef(refpath);
+                if (scope !== '$magic' && scope !== '$self')
+                  ref.unshift('$projection');
+              }
+              parent.ref = ref;
+              return ref;
             },
-          });
+          }, {}, elementsPath.concat(elemName));
         }
 
         if (!mixinElem._ignore)
@@ -304,6 +348,10 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
   // eslint-disable-next-line complexity
   function transformViewOrEntity(query, artifact, artName, path) {
     const { elements } = queryOrMain(query, artifact);
+    // We use the elements from the leading query/main artifact - adapt the path
+    const elementsPath = elements === artifact.elements ? path.slice(0, 2).concat('elements') : path.concat('elements');
+    const queryPath = path;
+
     let hasNonAssocElements = false;
     const isSelect = query && query.SELECT;
     const isProjection = !!artifact.projection || query && query.SELECT && !query.SELECT.columns;
@@ -338,12 +386,12 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
       // (180 b) Create MIXINs for association elements in projections or views (those that are not mixins by themselves)
       // CDXCORE-585: Allow mixin associations to be used and published in parallel
       if (query !== undefined && elem.target)
-        handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, path);
+        handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath);
     }
 
     if (query && !hasNonAssocElements) {
-    // Complain if there are no elements other than unmanaged associations
-    // Allow with plain
+      // Complain if there are no elements other than unmanaged associations
+      // Allow with plain
       error(null, [ 'definitions', artName ], { $reviewed: true },
             'Expecting view or projection to have at least one element that is not an unmanaged association');
     }

package/lib/transform/draft/.eslintrc.json

@@ -0,0 +1,38 @@
+{
+  "root": true,
+  "plugins": ["sonarjs", "jsdoc"],
+  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
+  "rules": {
+    "prefer-const": "error",
+    "quotes": ["error", "single", "avoid-escape"],
+    "prefer-template": "error",
+    "no-trailing-spaces": "error",
+    "template-curly-spacing":["error", "never"],
+    "complexity": ["warn", 30],
+    "max-len": "off",
+    // Don't enforce stupid descriptions
+    "jsdoc/require-param-description": "off",
+    "jsdoc/require-returns-description": "off",
+    // Sometimes if-else's are more specific
+    "sonarjs/prefer-single-boolean-return": "off",
+    // Very whiny and nitpicky
+    "sonarjs/cognitive-complexity": "off",
+    // Does not recognize TS types
+    "jsdoc/no-undefined-types": "off",
+    // Whiny and annoying
+    "sonarjs/no-duplicate-string": "off"
+  },
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "script"
+  },
+  "env": {
+    "es6": true,
+    "node": true
+  },
+  "settings": {
+    "jsdoc": {
+      "mode": "typescript"
+    }
+  }
+}

package/lib/transform/{db/draft.js → draft/db.js}

@@ -6,6 +6,7 @@ const {
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtilsNew');
+const { ModelError } = require('../../base/error');
 const draftAnnotation = '@odata.draft.enabled';
 const booleanBuiltin = 'cds.Boolean';
 
@@ -38,7 +39,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName
    */
   function generateDraft(artifact, artifactName) {
-    if ((artifact.kind === 'entity' || artifact.kind === 'view') &&
+    if ((artifact.kind === 'entity') &&
         hasAnnotationValue(artifact, draftAnnotation) &&
         isPartOfService(artifactName)) {
       // Determine the set of target draft nodes belonging to this draft root (the draft root
@@ -79,7 +80,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
         const draftNodeName = elem.target;
         // Sanity check
         if (!draftNode)
-          throw new Error(`Expecting target to be resolved: ${JSON.stringify(elem, null, 2)}`);
+          throw new ModelError(`Expecting target to be resolved: ${JSON.stringify(elem, null, 2)}`);
 
         // Ignore composition if not part of a service
         if (!isPartOfService(draftNodeName)) {
@@ -89,7 +90,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
         }
         // Barf if a draft node other than the root has @odata.draft.enabled itself
         if (draftNode !== rootArtifact && hasAnnotationValue(draftNode, draftAnnotation)) {
-          error(null, [ 'definitions', artifactName, 'elements', elemName ], 'Composition in draft-enabled entity can\'t lead to another entity with “@odata.draft.enabled”');
+          error('ref-unexpected-draft-enabled', [ 'definitions', artifactName, 'elements', elemName ], { anno: '@odata.draft.enabled' });
           delete draftNodes[draftNodeName];
           continue;
         }
@@ -110,7 +111,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
   function generateDraftForHana(artifact, artifactName, draftRootName) {
     // Sanity check
     if (!isPartOfService(artifactName))
-      throw new Error(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
+      throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
 
 
     // The name of the draft shadow entity we should generate
@@ -134,7 +135,8 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
       warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have one key element of type “cds.UUID”');
 
 
-    const matchingService = getMatchingService(artifactName);
+    // Ignore boolean return value. We know that we're inside a service or else we wouldn't have reached this code.
+    const matchingService = getMatchingService(artifactName) || '';
     // Generate the DraftAdministrativeData projection into the service, unless there is already one
     const draftAdminDataProjectionName = `${matchingService}.DraftAdministrativeData`;
     let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
@@ -311,7 +313,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
     function getDraftShadowEntityFor(draftNode, draftNodeName) {
       // Sanity check
       if (!draftNodes[draftNodeName])
-        throw new Error(`Not a draft node: ${draftNodeName}`);
+        throw new ModelError(`Not a draft node: ${draftNodeName}`);
 
       return { shadowTarget: csn.definitions[`${draftNodeName}${draftSuffix}`], shadowTargetName: `${draftNodeName}${draftSuffix}` };
     }
@@ -336,7 +338,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * Get the service name containing the artifact.
    *
    * @param {string} artifactName Absolute name of the artifact
-   * @returns {boolean|string} Name of the service or false if no match is found.
+   * @returns {false|string} Name of the service or false if no match is found.
    */
   function getMatchingService(artifactName) {
     const matches = [];

package/lib/transform/draft/odata.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const { forEachDefinition, getUtils, getServiceNames } = require('../../model/csnUtils');
+const { forEach } = require('../../utils/objectUtils');
+const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
+const { getTransformers } = require('../transformUtilsNew');
+const { ModelError } = require('../../base/error');
+const { makeMessageFunction } = require('../../base/messages');
+
+/**
+ * - Generate artificial draft fields if requested
+ *
+ * - Check associations for:
+ *      - exposed associations do not point to non-exposed targets
+ *      - structured types must not contain associations for OData V2
+ * - Element must not be an 'array of' for OData V2 TODO: move to the validator
+ * - Perform checks for exposed non-abstract entities and views - check media type and key-ness
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {Array} [services] Will be calculated JIT if not provided
+ * @returns {CSN.Model} Returns the transformed input model
+ * @todo should be done by the compiler - Check associations for valid foreign keys
+ * @todo check if needed at all: Remove '$projection' from paths in the element's ON-condition
+ */
+function generateDrafts(csn, options, services) {
+  const {
+    createForeignKeyElement,
+    createAndAddDraftAdminDataProjection, createScalarElement,
+    createAssociationElement, createAssociationPathComparison,
+    addElement, createAction, assignAction,
+    resetAnnotation,
+  } = getTransformers(csn, options);
+
+  const {
+    getFinalType,
+    getServiceName,
+    hasAnnotationValue,
+    getFinalBaseType,
+    getFinalTypeDef,
+  } = getUtils(csn);
+
+  const { error, info } = makeMessageFunction(csn, options, 'for.odata');
+
+  if (!services)
+    services = getServiceNames(csn);
+
+  const visitedArtifacts = Object.create(null);
+  // @ts-ignore
+  const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external']);
+  // @ts-ignore
+  const isExternalServiceMember = (_art, name) => externalServices.includes(getServiceName(name));
+
+  forEachDefinition(csn, (def, defName) => {
+    // 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 });
+
+  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.
+   * 'rootArtifact' is the root artifact where composition traversal started.
+   *
+   * Constraints
+   * Draft Root: Exactly one PK of type UUID
+   * Draft Node: One PK of type UUID + 0..1 PK of another type
+   * Draft Node: Must not be reachable from multiple draft roots
+   *
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   * @param {CSN.Artifact} rootArtifact artifact where composition traversal started
+   */
+  function generateDraftForOdata(artifact, artifactName, rootArtifact) {
+    // Sanity check
+    // @ts-ignore
+    if (!isArtifactInSomeService(artifactName, services))
+      throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
+
+    // Nothing to do if already draft-enabled (composition traversal may have circles)
+    if ((artifact['@Common.DraftRoot.PreparationAction'] || artifact['@Common.DraftNode.PreparationAction']) &&
+        artifact.actions && artifact.actions.draftPrepare)
+      return;
+
+
+    // Generate the DraftAdministrativeData projection into the service, unless there is already one
+    // @ts-ignore
+    const draftAdminDataProjectionName = `${getServiceOfArtifact(artifactName, services)}.DraftAdministrativeData`;
+    let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
+    if (!draftAdminDataProjection) {
+      // @ts-ignore
+      draftAdminDataProjection = createAndAddDraftAdminDataProjection(getServiceOfArtifact(artifactName, services));
+    }
+    // Report an error if it is not an entity or not what we expect
+    if (draftAdminDataProjection.kind !== 'entity' || !draftAdminDataProjection.elements.DraftUUID) {
+      error(null, [ 'definitions', draftAdminDataProjectionName ], { name: draftAdminDataProjectionName },
+            'Generated entity $(NAME) conflicts with existing artifact');
+    }
+    // Generate the annotations describing the draft actions (only draft roots can be activated/edited)
+    if (artifact === rootArtifact) {
+      resetAnnotation(artifact, '@Common.DraftRoot.ActivationAction', 'draftActivate', info, [ 'definitions', draftAdminDataProjectionName ]);
+      resetAnnotation(artifact, '@Common.DraftRoot.EditAction', 'draftEdit', info, [ 'definitions', draftAdminDataProjectionName ]);
+      resetAnnotation(artifact, '@Common.DraftRoot.PreparationAction', 'draftPrepare', info, [ 'definitions', draftAdminDataProjectionName ]);
+    }
+    else {
+      resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, [ 'definitions', draftAdminDataProjectionName ]);
+    }
+
+    Object.values(artifact.elements || {}).forEach( (elem) => {
+      // Make all non-key elements nullable
+      if (elem.notNull && elem.key !== true)
+        delete elem.notNull;
+    });
+    // Generate the additional elements into the draft-enabled artifact
+
+    // key IsActiveEntity : Boolean default true
+    const isActiveEntity = createScalarElement('IsActiveEntity', 'cds.Boolean', true, true, false);
+    isActiveEntity.IsActiveEntity['@UI.Hidden'] = true;
+    addElement(isActiveEntity, artifact, artifactName);
+
+    // HasActiveEntity : Boolean default false
+    const hasActiveEntity = createScalarElement('HasActiveEntity', 'cds.Boolean', false, false, true);
+    hasActiveEntity.HasActiveEntity['@UI.Hidden'] = true;
+    addElement(hasActiveEntity, artifact, artifactName);
+
+    // HasDraftEntity : Boolean default false;
+    const hasDraftEntity = createScalarElement('HasDraftEntity', 'cds.Boolean', false, false, true);
+    hasDraftEntity.HasDraftEntity['@UI.Hidden'] = true;
+    addElement(hasDraftEntity, artifact, artifactName);
+
+    // @odata.contained: true
+    // DraftAdministrativeData : Association to one DraftAdministrativeData;
+    const draftAdministrativeData = createAssociationElement('DraftAdministrativeData', draftAdminDataProjectionName, true);
+    draftAdministrativeData.DraftAdministrativeData.cardinality = { max: 1 };
+    draftAdministrativeData.DraftAdministrativeData['@odata.contained'] = true;
+    draftAdministrativeData.DraftAdministrativeData['@UI.Hidden'] = true;
+    addElement(draftAdministrativeData, artifact, artifactName);
+
+    // Note that we need to do the ODATA transformation steps for managed associations
+    // (foreign key field generation, generatedFieldName) by hand, because the corresponding
+    // transformation steps have already been done on all artifacts when we come here)
+    let uuidDraftKey = draftAdministrativeData.DraftAdministrativeData.keys.filter(key => key.ref && key.ref.length === 1 && key.ref[0] === 'DraftUUID');
+    if (uuidDraftKey && uuidDraftKey[0]) {
+      uuidDraftKey = uuidDraftKey[0]; // filter returns an array, but it has only one element
+      const path = [ 'definitions', artifactName, 'elements', 'DraftAdministrativeData', 'keys', 0 ];
+      createForeignKeyElement(draftAdministrativeData.DraftAdministrativeData, 'DraftAdministrativeData', uuidDraftKey, artifact, artifactName, path);
+    }
+    // SiblingEntity : Association to one <artifact> on (... IsActiveEntity unequal, all other key fields equal ...)
+    const siblingEntity = createAssociationElement('SiblingEntity', artifactName, false);
+    siblingEntity.SiblingEntity.cardinality = { max: 1 };
+    addElement(siblingEntity, artifact, artifactName);
+    // ... on SiblingEntity.IsActiveEntity != IsActiveEntity ...
+    siblingEntity.SiblingEntity.on = createAssociationPathComparison('SiblingEntity', 'IsActiveEntity', '!=', 'IsActiveEntity');
+
+    // Iterate elements
+    // TODO: Iterative vs recursive? What is more likely: Super deep nesting or cycles via malicious CSN?
+    if (artifact.elements) {
+      // No need to reverse the stack, not order dependent
+      const stack = [ artifact ];
+      while (stack.length > 0) {
+        const { elements } = stack.pop();
+        forEach(elements, (elemName, elem) => {
+          if (elemName !== 'IsActiveEntity' && elem.key) {
+            // Amend the ON-condition above:
+            // ... and SiblingEntity.<keyfield> = <keyfield> ... (for all key fields except 'IsActiveEntity')
+            const cond = createAssociationPathComparison('SiblingEntity', elemName, '=', elemName);
+            cond.push('and');
+            cond.push(...siblingEntity.SiblingEntity.on);
+            siblingEntity.SiblingEntity.on = cond;
+          }
+
+          // Draft-enable the targets of composition elements (draft nodes), too
+          // TODO rewrite
+          if (elem.target && elem.type && getFinalType(elem.type) === 'cds.Composition') {
+            const draftNode = csn.definitions[elem.target];
+
+            // Ignore if that is our own draft root
+            if (draftNode !== rootArtifact) {
+              // Report error when the draft node has @odata.draft.enabled itself
+              if (hasAnnotationValue(draftNode, '@odata.draft.enabled', true)) {
+                error('ref-unexpected-draft-enabled', [ 'definitions', artifactName, 'elements', elemName ], { anno: '@odata.draft.enabled' });
+              }
+              // Ignore composition if it's target is not part of a service or explicitly draft disabled
+              else if (!getServiceName(elem.target) || hasAnnotationValue(draftNode, '@odata.draft.enabled', false)) {
+                return;
+              }
+              else {
+                // Generate draft stuff into the target
+                generateDraftForOdata(draftNode, elem.target, rootArtifact);
+              }
+            }
+          }
+          else if (elem.elements) { // anonymous structure
+            stack.push(elem);
+          }
+          else if (elem.type) { // types - possibly structured
+            const typeDef = elem.type.ref ? getFinalBaseType(elem.type) : getFinalTypeDef(elem.type);
+            if (typeDef.elements)
+              stack.push(typeDef);
+          }
+        });
+      }
+    }
+
+
+    // Generate the actions into the draft-enabled artifact (only draft roots can be activated/edited)
+
+    // action draftPrepare (SideEffectsQualifier: String) return <artifact>;
+    const draftPrepare = createAction('draftPrepare', artifactName, 'SideEffectsQualifier', 'cds.String');
+    assignAction(draftPrepare, artifact);
+
+    if (artifact === rootArtifact) {
+      // action draftActivate() return <artifact>;
+      const draftActivate = createAction('draftActivate', artifactName);
+      assignAction(draftActivate, artifact);
+
+      // action draftEdit (PreserveChanges: Boolean) return <artifact>;
+      const draftEdit = createAction('draftEdit', artifactName, 'PreserveChanges', 'cds.Boolean');
+      assignAction(draftEdit, artifact);
+    }
+  }
+}
+
+module.exports = generateDrafts;