@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/transform/db/constraints.js

@@ -16,36 +16,40 @@ const ASSOCIATION = 'cds.Association';
 function createReferentialConstraints(csn, options) {
   let validated = true;
   let enforced = true;
-  if (options.constraintsNotValidated)
+  if (options.integrityNotValidated)
     validated = false;
 
-  if (options.constraintsNotEnforced)
+  if (options.integrityNotEnforced)
     enforced = false;
 
   const { inspectRef } = csnRefs(csn);
   // prepare the functions with the compositions and associations across all entities first
-  // and execute it afterwards because compositions must be processed first
+  // and execute it afterwards.
+  // compositions must be processed first, as the <up_> links for them must result in `ON DELETE CASCADE`
   const compositions = [];
   const associations = [];
   forEachDefinition(csn, (artifact, artifactName) => {
-    if (!artifact.query && artifact.kind === 'entity' ) {
+    if (!artifact.query && artifact.kind === 'entity') {
       forAllElements(artifact, artifactName, (parent, elements, path) => {
-        // Step I: iterate compositions, enrich dependent keys (in target entity)
+        // Step I: iterate compositions, enrich dependent keys for <up_> association in target entity of composition
         for (const elementName in elements) {
           const element = elements[elementName];
-          if (element.type === COMPOSITION && !treatCompositionLikeAssociation(element)) {
-            compositions.push(() => {
-              foreignKeyConstraintForComposition(element, parent, path.concat([ elementName ]));
+          if (element.type === COMPOSITION && element.$selfOnCondition) {
+            compositions.push({
+              fn: () => {
+                foreignKeyConstraintForUpLinkOfComposition(element, parent, path.concat([ elementName ]));
+              },
             });
           }
         }
         // Step II: iterate associations, enrich dependent keys (in entity containing the association)
         for (const elementName in elements) {
           const element = elements[elementName];
-          if (element.type === ASSOCIATION ||
-             element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
-            associations.push(() => {
-              foreignKeyConstraintForAssociation(element, elements, path.concat([ elementName ]), elementName);
+          if (element.keys && isToOne(element) && element.type === ASSOCIATION || element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
+            associations.push({
+              fn: () => {
+                foreignKeyConstraintForAssociation(element, path.concat([ elementName ]));
+              },
             });
           }
         }
@@ -53,39 +57,34 @@ function createReferentialConstraints(csn, options) {
     }
   });
   // create constraints on foreign keys
-  compositions.forEach(fn => fn());
-  associations.forEach(fn => fn());
+  // always process unmanaged first, up_ links must be flagged
+  // before they are processed
+  compositions.forEach(composition => composition.fn());
+  associations.forEach(association => association.fn());
+
   // Step III: Create the final referential constraints from all dependent key <-> parent key pairs stemming from the same $sourceAssociation
   forEachDefinition(csn, collectAndAttachReferentialConstraints);
 
-
   /**
-   * Calculate referential constraints for dependent keys in target entity of cds.Composition.
-   * The DELETE rule for a referential constraint stemming from a composition will be CASCADE.
-   * A managed composition with a target cardinality of one, will be treated like a regular Association.
+   * Retrieve the <up_> link of an `cds.Composition` used in an on-condition like `$self = <comp>.<up_>`
+   * and calculate a foreign key constraint for this association if it is constraint compliant.
+   * The constraint will have an `ON DELETE CASCADE`.
    *
-   * @param {CSN.Element} composition for that a constraint should be generated
+   * @param {CSN.Element} composition which might has the `$self = <comp>.<up_>` on-condition
    * @param {CSN.Artifact} parent artifact containing the composition
    * @param {CSN.Path} path
    */
-  function foreignKeyConstraintForComposition(composition, parent, path) {
-    if (skipConstraintGeneration(parent, composition))
+  function foreignKeyConstraintForUpLinkOfComposition(composition, parent, path) {
+    const dependent = csn.definitions[path[1]];
+    if (skipConstraintGeneration(parent, dependent, composition))
       return;
 
-    const { elements } = parent;
     const onCondition = composition.on;
-    if (onCondition) {
-      if (hasConstraintCompliantOnCondition(composition, elements, path)) {
-        // 1. cds.Composition has constraint compliant on-condition
-        // mark each dependent key referenced in the on-condition (in target entity)
-        const dependentKeys = Array.from(elementsOfTargetSide(onCondition, csn.definitions[composition.target].elements));
-        const parentKeys = Array.from(elementsOfSourceSide(onCondition, elements));
-        const { backlinkName } = composition.$selfOnCondition || {};
-        // sanity check; do not generate constraints for on-conditions like "dependent.idOne = id AND dependent.idTwo = id"
-        // also: no constraints for compositions of many w/o backlink
-        if (dependentKeys.length === parentKeys.length && backlinkName)
-          attachConstraintsToDependentKeys(dependentKeys, parentKeys, path[path.length - 3], path, backlinkName, 'CASCADE');
-      }
+    if (composition.$selfOnCondition && composition.$selfOnCondition.up_.length === 1) {
+      const upLinkName = composition.$selfOnCondition.up_[0];
+      const up_ = csn.definitions[composition.target].elements[upLinkName];
+      if (up_.keys && isToOne(up_)) // no constraint for unmanaged / to-many up_ links
+        foreignKeyConstraintForAssociation(up_, [ 'definitions', composition.target, 'elements', upLinkName ], path[path.length - 1]);
     }
     else if (!onCondition && composition.keys.length > 0) {
       throw new Error('Please debug me, an on-condition was expected here, but only found keys');
@@ -95,26 +94,27 @@ function createReferentialConstraints(csn, options) {
   /**
    * Calculate referential constraints for dependent keys in the entity where the cds.Associations is defined.
    * The DELETE rule for a referential constraint stemming from a cds.Association will be 'RESTRICT'
+   * If the association is used as an <up_> link in a compositions on-condition, the ON DELETE rule will be `CASCADE`
    *
    * @param {CSN.Association} association for that a constraint should be generated
-   * @param {CSN.Elements} elements of parent entity.
    * @param {CSN.Path} path
-   * @param {string} assocName passed through as proper constraint suffix
+   * @param {CSN.PathSegment} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
    */
-  function foreignKeyConstraintForAssociation(association, elements, path, assocName) {
-    const associationTarget = csn.definitions[association.target];
-    if (skipConstraintGeneration(associationTarget, association))
+  function foreignKeyConstraintForAssociation(association, path, upLinkFor = null) {
+    const parent = csn.definitions[association.target];
+    const dependent = csn.definitions[path[1]];
+    if (skipConstraintGeneration(parent, dependent, association))
       return;
-
+    const { elements } = csn.definitions[path[1]];
     const onCondition = association.on;
     if (onCondition && hasConstraintCompliantOnCondition(association, elements, path)) {
       // 1. cds.Association has constraint compliant on-condition
       // mark each dependent key - in the entity containing the association - referenced in the on-condition
       const dependentKeys = Array.from(elementsOfSourceSide(onCondition, elements));
-      const parentKeys = Array.from(elementsOfTargetSide(onCondition, associationTarget.elements));
+      const parentKeys = Array.from(elementsOfTargetSide(onCondition, parent.elements));
       // sanity check; do not generate constraints for on-conditions like "dependent.idOne = id AND dependent.idTwo = id"
       if (dependentKeys.length === parentKeys.length)
-        attachConstraintsToDependentKeys(dependentKeys, parentKeys, association.target, path, assocName);
+        attachConstraintsToDependentKeys(dependentKeys, parentKeys, association.target, path[path.length - 1], upLinkFor);
     }
     else if (!onCondition && association.keys.length > 0) {
       throw new Error('Please debug me, an on-condition was expected here, but only found keys');
@@ -129,14 +129,16 @@ function createReferentialConstraints(csn, options) {
    * @param {Array} dependentKeys array holding dependent keys in the format [['key1', 'value1'], [...], ...]
    * @param {Array} parentKeys array holding parent keys in the format [['key1', 'value1'], [...], ...]
    * @param {CSN.PathSegment} parentTable the sql-table where the foreign key constraints will be pointing to
-   * @param {CSN.Path} path
-   * @param {string | null} constraintIdentifierSuffix name of the association / the backlink association
-   * @param {string} onDelete the on delete rule which should be applied. Default for associations is 'RESTRICT'
+   * @param {CSN.PathSegment} sourceAssociation the name of the association from which the constraint originates
+   * @param {CSN.PathSegment} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
+   *                                    it is used for a comment in the constraint, which is only printed out in test-mode
    */
-  function attachConstraintsToDependentKeys(dependentKeys, parentKeys, parentTable, path, constraintIdentifierSuffix, onDelete = 'RESTRICT') {
+  function attachConstraintsToDependentKeys(dependentKeys, parentKeys, parentTable, sourceAssociation, upLinkFor = null) {
     while (dependentKeys.length > 0) {
       const dependentKeyValuePair = dependentKeys.pop();
       const dependentKey = dependentKeyValuePair[1];
+      // if it already has a dependent key assigned, do not overwrite it.
+      // this is the case for <up_> associations in on-conditions of compositions
       if (Object.prototype.hasOwnProperty.call(dependentKey, '$foreignKeyConstraint'))
         return;
 
@@ -146,9 +148,9 @@ function createReferentialConstraints(csn, options) {
       const constraint = {
         parentKey: parentKeyName,
         parentTable,
-        sourceAssociation: path[path.length - 1],
-        nameSuffix: constraintIdentifierSuffix || 'up_',
-        onDelete,
+        upLinkFor,
+        sourceAssociation,
+        onDelete: upLinkFor ? 'CASCADE' : 'RESTRICT',
         validated,
         enforced,
       };
@@ -168,7 +170,7 @@ function createReferentialConstraints(csn, options) {
    *      b) for cds.Association this is the target entity
    * 3. parent keys must be the full primary key tuple
    *
-   * @param {CSN.Association | CSN.Composition} element
+   * @param {CSN.Association} element
    * @param {CSN.Elements} siblingElements
    * @param {CSN.Path} path the path to the element
    * @returns {boolean} indicating whether the association / composition is a constraint candidate
@@ -189,65 +191,242 @@ function createReferentialConstraints(csn, options) {
     if (onCondition.some((step, index) => typeof step === 'object' && inspectRef(path.concat([ 'on', index ])).scope === '$magic'))
       return false;
 
-    // managed composition with target cardinality of one is treated like an association
-    const isComposition = element.type === COMPOSITION && !treatCompositionLikeAssociation(element);
     // for cds.Associations the parent keys are in the associations target entity
     // for cds.Composition the parent keys are in the entity, where the composition is defined
-    const parentElements = isComposition ? siblingElements : csn.definitions[element.target].elements;
-    const parentKeys = isComposition ? elementsOfSourceSide(onCondition, parentElements) : elementsOfTargetSide(onCondition, parentElements);
+    const parentElements = csn.definitions[element.target].elements;
+    const parentKeys = elementsOfTargetSide(onCondition, parentElements);
+
+    const referencesNonPrimaryKeyField = Array.from(parentKeys.values()).some(parentKey => !parentKey.key);
+    if (referencesNonPrimaryKeyField)
+      return false;
+
     // returns true if the parentKeys found in the on-condition are covering the full primary key tuple in the parent entity
     return Array.from(parentKeys.entries())
-    // check if primary key found in on-condition is present in association target / composition source
-      .filter(([ keyName, pk ]) => pk.key && parentElements[keyName].key).length === Object.keys(parentElements)
-    // compare that with the length of the primary key tuple found in association target / composition source
-      .filter(key => parentElements[key].key &&
-      parentElements[key].type !== ASSOCIATION &&
-      parentElements[key].type !== COMPOSITION)
-      .length;
+      // check if primary key found in on-condition is present in association target / composition source
+      .filter(([ keyName, pk ]) => pk.key && parentElements[keyName].key).length ===
+      Object.keys(parentElements)
+        // compare that with the length of the primary key tuple found in association target / composition source
+        .filter(key => parentElements[key].key &&
+          parentElements[key].type !== ASSOCIATION &&
+          parentElements[key].type !== COMPOSITION)
+        .length;
   }
-
   /**
    *  Skip referential constraint if the parent table (association target, or artifact where composition is defined)
    *  of the relation is:
    *    - a query
-   *    - annotated with '@cds.persistence.skip:true'
-   *    - annotated with '@cds.persistence.exists:true'
+   *    - TODO: Revisit -- annotated with '@cds.persistence.skip:true'
+   *    - TODO: Revisit -- annotated with '@cds.persistence.exists:true'
+   *
+   *  The following decision table reflects the current implementation:
    *
-   *  Skip referential constraint as well if:
-   *    - global option 'skipDbConstraints' is set and if the element is not annotated with
-   *       '@cds.persistency.assert.integrity: true'.
-   *    - the element is annotated either with '@cds.persistency.assert.integrity: false' or '@assert.integrity: false'
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | Global Switch:  | Global Check Type:  | @assert.integrity | Generate  |
+   *   |"assertIntegrity"| "assertIntegrityType"|                   | Constraint|
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | RT                 | false             | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | RT                 | true/not set      | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | RT                 | RT                | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | RT                 | DB                | yes      |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   |                 |                    |                   |          |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | DB                 | false             | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | DB                 | true/not set      | yes      |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | DB                 | RT                | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | on              | DB                 | DB                | yes      |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   |                 |                    |                   |          |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | off             | don't care         | don't care        | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   |                 |                    |                   |          |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | individual      | RT                 | true              | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | individual      | DB                 | true              | yes      |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | individual      | don't care         | RT                | no       |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | individual      | don't care         | DB                | yes      |
+   *   +-----------------+--------------------+-------------------+----------+
+   *   | individual      | don't care         | false/not set     | no       |
+   *   +-----------------+--------------------+-------------------+----------+
    *
-   * @param {CSN.Element} parent of association / composition
-   * @param {CSN.Element} element the composition or association
+   * @param {CSN.Definition} parent entity where the foreign key reference will point at
+   * @param  {CSN.Definition} dependent entity where the constraint will be defined on
+   * @param {CSN.Association} element the composition or association
    * @returns {boolean}
    */
-  function skipConstraintGeneration(parent, element) {
-    if (hasAnnotationValue(element, '@assert.integrity', false) ||
-     hasAnnotationValue(element, '@cds.persistency.assert.integrity', false)) {
-    // in case of managed composition, the 'up_' link should not result in a constraint
-      const target = csn.definitions[element.target];
-      const { up_ } = target.elements;
-      if (up_)
-        up_.$skipReferentialConstraintForUp_ = true;
+  function skipConstraintGeneration(parent, dependent, element) {
+    // if set to 'off' don't even bother, just skip all constraints
+    if (options.assertIntegrity === false || options.assertIntegrity === 'false')
       return true;
-    }
 
-    if (element.$skipReferentialConstraintForUp_) {
-      delete element.$skipReferentialConstraintForUp_;
+    if (parent.query)
+      return true;
+
+    // no constraint if either dependent or parent is not persisted
+    if (
+      hasAnnotationValue(parent, '@cds.persistence.skip') ||
+      hasAnnotationValue(dependent, '@cds.persistence.skip')
+    )
+      return true;
+
+    // some commonly used string literals
+    const RT = 'RT';
+    const DB = 'DB';
+    const CREATE_FOR_UP = '$createReferentialConstraintForUp_';
+    const SKIP_FOR_UP = '$skipReferentialConstraintForUp_';
+
+    // if the element itself is explicitly excluded from being checked
+    // skip the constraint for it (and its backlink)
+    if (isAssertIntegrityAnnotationSetTo(false) ||
+      isAssertIntegrityAnnotationSetTo(RT) ||
+      element[SKIP_FOR_UP]
+    ) {
+      // for "auto-generated" associations like for the up_ of a composition of aspects,
+      // the annotation on the composition influences the referential constraint for the
+      // up_ association
+      if (element.$selfOnCondition && element.targetAspect)
+        assignPropOnBacklinkIfPossible(SKIP_FOR_UP, true);
+
       return true;
     }
+    const runtimeChecks = options.assertIntegrityType && options.assertIntegrityType.toUpperCase() === RT;
+    const compilerChecks = options.assertIntegrityType && options.assertIntegrityType.toUpperCase() === DB;
+
+    if ((!options.assertIntegrity || options.assertIntegrity === true || options.assertIntegrity === 'true') &&
+      (!options.assertIntegrityType || runtimeChecks))
+      return assertForIntegrityTypeRT();
+
+    if ((!options.assertIntegrity || options.assertIntegrity === true || options.assertIntegrity === 'true') &&
+      compilerChecks)
+      return assertForIntegrityTypeDB();
 
-    if (hasAnnotationValue(parent, '@cds.persistence.skip', true) ||
-     hasAnnotationValue(parent, '@cds.persistence.exists', true) ||
-     parent.query)
+    if ((options.assertIntegrity === 'individual'))
+      return assertForIndividual();
+
+    // The default for the assertIntegrityType is 'RT', no constraints in that case
+    if ((!options.assertIntegrity || options.assertIntegrity === true) &&
+      (!options.assertIntegrityType || runtimeChecks))
       return true;
 
-    // '@cds.persistency.assert.integrity: true' supersedes global switch
-    if (!hasAnnotationValue(element, '@cds.persistency.assert.integrity', true) && options.forHana.skipDbConstraints)
+    if (!element.keys || !isToOne(element))
       return true;
 
     return false;
+
+    /**
+     *  if global checks are 'individual' we evaluate every association,
+     *  we create db constraints if it is annotated with @assert.integrity: 'DB' (or true)
+     *
+     * @returns {boolean}
+     */
+    function assertForIndividual() {
+      if (isAssertIntegrityAnnotationSetTo(DB) || element[CREATE_FOR_UP]) {
+        // if this is has a $self comparison, the up_ link should then result in a constraint
+        assignPropOnBacklinkIfPossible(CREATE_FOR_UP, true);
+        return false;
+      }
+      if (options.assertIntegrityType === DB && isAssertIntegrityAnnotationSetTo(true)) {
+        // if this is has a $self comparison, the up_ link should then result in a constraint
+        assignPropOnBacklinkIfPossible(CREATE_FOR_UP, true);
+        return false;
+      }
+
+      // individual and no ('DB') annotation on constraint --> skip
+      return true;
+    }
+
+    /**
+     * if global check type is 'RT' (or not provided) only generate DB constraint if element
+     * is explicitly annotated "@assert.integrity: 'DB'"
+     *
+     * @returns {boolean}
+     */
+    function assertForIntegrityTypeRT() {
+      // for "auto-generated" associations like for the up_ of a composition of aspects,
+      // the annotation on the composition influences the referential constraint for the
+      // up_ association
+      if (isAssertIntegrityAnnotationSetTo(DB)) {
+        if (element.targetAspect)
+          assignPropOnBacklinkIfPossible(CREATE_FOR_UP, true);
+        return false;
+      }
+      if (element[CREATE_FOR_UP])
+        return false;
+      return true;
+    }
+
+    /**
+     * if global checks are on and global integrity check type is 'DB'
+     * we create db constraints in any case except if annotated
+     * with @assert.integrity: 'RT' (or false, but that is rejected earlier)
+     *
+     * @returns {boolean}
+     */
+    function assertForIntegrityTypeDB() {
+      if (isAssertIntegrityAnnotationSetTo(RT))
+        return true;
+      return false;
+    }
+
+
+    /**
+     * convenience to check if value of element's @assert.integrity annotation
+     * is the same as a given value
+     *
+     * @param {string|boolean} value
+     * @returns {boolean}
+     */
+    function isAssertIntegrityAnnotationSetTo(value) {
+      return hasAnnotationValue(element, '@assert.integrity', value, true);
+    }
+
+    /**
+     * Assigns a helper key-value pair on the up_ association for a $self comparison
+     * for the current 'element', if applicable
+     *
+     * @param {string} prop
+     * @param {object} val
+     */
+    function assignPropOnBacklinkIfPossible(prop, val) {
+      if (!element.$selfOnCondition)
+        return;
+      const target = csn.definitions[element.target];
+      const backlink = target.elements[element.$selfOnCondition.up_[0]];
+      backlink[prop] = val;
+    }
+  }
+
+  /**
+   * If we have a managed composition with a target cardinality of one, we will treat it like
+   * a regular association when it comes to referential constraints.
+   * The constraint will thus be generated for the foreign key we create in the source entity.
+   *
+   * @param {CSN.Composition} composition the composition which might be treated like an association
+   * @returns {boolean} true if the composition should be treated as an association in regards to foreign key constraints
+   */
+  function treatCompositionLikeAssociation(composition) {
+    return Boolean(isToOne(composition) && composition.keys);
+  }
+
+  /**
+   * returns true if the association/composition has a max target cardinality of one
+   *
+   * @param {CSN.Association|CSN.Composition} assocOrComposition
+   * @returns {boolean}
+   */
+  function isToOne(assocOrComposition) {
+    const { min, max } = assocOrComposition.cardinality || {};
+    return !min && !max || max === 1;
   }
 
   /**
@@ -260,8 +439,8 @@ function createReferentialConstraints(csn, options) {
   function elementsOfTargetSide(on, targetElements) {
     const elements = new Map();
     on.filter(element => typeof element === 'object' &&
-        element.ref.length > 1 &&
-        targetElements[element.ref[element.ref.length - 1]])
+      element.ref.length > 1 &&
+      targetElements[element.ref[element.ref.length - 1]])
       .forEach((element) => {
         elements.set(element.ref[element.ref.length - 1], targetElements[element.ref[element.ref.length - 1]]);
       });
@@ -272,15 +451,15 @@ function createReferentialConstraints(csn, options) {
   /**
    * Finds and return elementNames and elements of source side mentioned in on-condition.
    *
-   * @param {CSN.Association.on} on the on-condition
+   * @param {CSN.OnCondition} on the on-condition
    * @param {CSN.Elements} sourceElements elements of source entity where the association/composition is defined.
    * @returns {Map} of source elements with their name as key
    */
   function elementsOfSourceSide(on, sourceElements) {
     const elements = new Map();
     on.filter(element => typeof element === 'object' &&
-          element.ref.length === 1 &&
-          sourceElements[element.ref[0]])
+      element.ref.length === 1 &&
+      sourceElements[element.ref[0]])
       .forEach((element) => {
         elements.set(element.ref[0], sourceElements[element.ref[0]]);
       });
@@ -315,8 +494,8 @@ function createReferentialConstraints(csn, options) {
       // find all other $foreignKeyConstraint with same $sourceAssociation and same parentTable
       Object.entries(artifact.elements)
         .filter(([ , e ]) => e.$foreignKeyConstraint &&
-            e.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
-            e.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable)
+          e.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
+          e.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable)
         .forEach(([ foreignKeyName, foreignKey ]) => {
           const $foreignKeyConstraintCopy = Object.assign({}, foreignKey.$foreignKeyConstraint);
           delete foreignKey.$foreignKeyConstraint;
@@ -329,9 +508,9 @@ function createReferentialConstraints(csn, options) {
       let onDeleteRemark = null;
       // comments in sqlite files are causing the JDBC driver to throw an error on deployment
       if (options.testMode && onDelete === 'CASCADE')
-        onDeleteRemark = `Composition "${$foreignKeyConstraint.sourceAssociation}" implies existential dependency`;
-      referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.nameSuffix}`] = {
-        identifier: `${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.nameSuffix}`,
+        onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
+      referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.sourceAssociation}`] = {
+        identifier: `${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
         foreignKey: dependentKey,
         parentKey,
         dependentTable: artifactName,
@@ -350,29 +529,6 @@ function createReferentialConstraints(csn, options) {
       artifact.$tableConstraints.referential = referentialConstraints;
     }
   }
-
-  /**
-   * If we have a managed composition with a target cardinality of one, we will treat it like
-   * a regular association when it comes to referential constraints.
-   * The constraints will thus be generated in the entity containing the composition and not in the target entity.
-   *
-   * @param {CSN.Composition} composition the composition which might be treated like an association
-   * @returns {boolean} true if the composition should be treated as an association in regards to foreign key constraints
-   */
-  function treatCompositionLikeAssociation(composition) {
-    return Boolean((isToOne(composition) && !composition.$selfOnCondition) || composition.keys);
-  }
-
-  /**
-   * returns true if the association/composition has a max target cardinality of one
-   *
-   * @param {CSN.Element} assocOrComposition
-   * @returns {boolean}
-   */
-  function isToOne(assocOrComposition) {
-    const { min, max } = assocOrComposition.cardinality || {};
-    return !min && !max || max === 1;
-  }
 }
 
 /**

package/lib/transform/db/draft.js

@@ -21,6 +21,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
   const draftSuffix = isDeprecatedEnabled(options, 'generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
   // All services of the model - needed for drafts
   const allServices = getServiceNames(csn);
+  const draftRoots = new WeakMap();
   const {
     createForeignKeyElement, createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
     addElement, copyAndAddElement, createAssociationPathComparison,
@@ -133,7 +134,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];
@@ -155,7 +157,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
     const persistenceName = getResultingName(csn, options.forHana.names, draftsArtifactName);
     // Duplicate the artifact as a draft shadow entity
     if (csn.definitions[persistenceName]) {
-      const definingDraftRoot = csn.definitions[persistenceName].$draftRoot;
+      const definingDraftRoot = draftRoots.get(csn.definitions[persistenceName]);
       if (!definingDraftRoot) {
         error(null, [ 'definitions', artifactName ], { name: persistenceName },
               'Generated entity name $(NAME) conflicts with existing entity');
@@ -176,7 +178,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
     // Add draft shadow entity to the csn
     csn.definitions[draftsArtifactName] = draftsArtifact;
 
-    setProp(draftsArtifact, '$draftRoot', draftRootName);
+    draftRoots.set(draftsArtifact, draftRootName);
     if (artifact.$location)
       setProp(draftsArtifact, '$location', artifact.$location);
 
@@ -335,7 +337,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 = [];