@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/render/toSql.js

@@ -7,7 +7,7 @@ const {
   forEachDefinition, getResultingName,
 } = require('../model/csnUtils');
 const {
-  renderFunc, processExprArray, cdsToSqlTypes,
+  renderFunc, beautifyExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
 } = require('./utils/common');
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -152,6 +152,24 @@ function toSqlDdl(csn, options) {
         .join(', ');
       return primaryKeys && `PRIMARY KEY(${primaryKeys})`;
     },
+    /*
+      Render entity-comment modifications as HANA SQL.
+     */
+    alterEntityComment(tableName, comment) {
+      return [ `COMMENT ON TABLE ${tableName} IS ${render.comment(comment)};` ];
+    },
+    /*
+      Render column-comment modifications as HANA SQL.
+     */
+    alterColumnComment(tableName, columnName, comment) {
+      return [ `COMMENT ON COLUMN ${tableName}.${columnName} IS ${render.comment(comment)};` ];
+    },
+    /*
+      Render comment string.
+     */
+    comment(comment) {
+      return comment && `'${comment.replace(/'/g, '\'\'')}'` || 'NULL';
+    },
     /*
       Concatenate multiple statements which are to be treated as one by the API caller.
      */
@@ -211,8 +229,9 @@ function toSqlDdl(csn, options) {
     for (const extension of options && options.testMode ? sortCsn(csn.extensions) : csn.extensions) {
       if (extension.extend) {
         const artifactName = extension.extend;
-        const env = { indent: '' };
-        renderArtifactExtensionInto(artifactName, csn.definitions[artifactName], extension, resultObj, env);
+        const _artifact = csn.definitions[artifactName];
+        const env = { indent: '', _artifact };
+        renderArtifactExtensionInto(artifactName, _artifact, extension, resultObj, env);
       }
     }
   }
@@ -223,7 +242,8 @@ function toSqlDdl(csn, options) {
     for (const migration of options && options.testMode ? sortCsn(csn.migrations) : csn.migrations) {
       if (migration.migrate) {
         const artifactName = migration.migrate;
-        const env = { indent: '' };
+        const _artifact = csn.definitions[artifactName];
+        const env = { indent: '', _artifact };
         renderArtifactMigrationInto(artifactName, migration, resultObj, env);
       }
     }
@@ -367,10 +387,30 @@ function toSqlDdl(csn, options) {
       return def.old.type === def.new.type &&
           [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
     }
+    function getEltStr(defVariant, eltName) {
+      return defVariant.target
+        ? renderAssociationElement(eltName, defVariant, env)
+        : renderElement(artifactName, eltName, defVariant, null, null, env);
+    }
+    function getEltStrNoProp(defVariant, prop, eltName) {
+      const defNoProp = Object.assign({}, defVariant);
+      delete defNoProp[prop];
+      return getEltStr(defNoProp, eltName);
+    }
 
     const tableName = renderArtifactName(artifactName);
 
-    // Drop column (unsupported in sqlite)
+    // Change entity properties
+    if (migration.properties) {
+      for (const [ prop, def ] of Object.entries(migration.properties)) {
+        if (prop === 'doc') {
+          const alterComment = render.alterEntityComment(tableName, def.new);
+          addMigration(resultObj, artifactName, false, alterComment);
+        }
+      }
+    }
+
+    // Drop columns (unsupported in sqlite)
     if (migration.remove) {
       const entries = Object.entries(migration.remove);
       if (entries.length) {
@@ -389,12 +429,28 @@ function toSqlDdl(csn, options) {
       }
     }
 
-    // Change column type (unsupported in sqlite)
+    // Change column types (unsupported in sqlite)
     if (migration.change) {
       changeElementsDuplicateChecker.addArtifact(tableName, undefined, artifactName);
       for (const [ eltName, def ] of Object.entries(migration.change)) {
         const sqlId = quoteSqlId(eltName);
         changeElementsDuplicateChecker.addElement(sqlId, undefined, eltName);
+
+        const eltStrOld = getEltStr(def.old, eltName);
+        const eltStrNew = getEltStr(def.new, eltName);
+        if (eltStrNew === eltStrOld)
+          return; // Prevent spurious migrations, where the column DDL does not change.
+
+        if (def.old.doc !== def.new.doc) {
+          const eltStrOldNoDoc = getEltStrNoProp(def.old, 'doc', eltName);
+          const eltStrNewNoDoc = getEltStrNoProp(def.new, 'doc', eltName);
+          if (eltStrOldNoDoc === eltStrNewNoDoc) { // only `doc` changed
+            const alterComment = render.alterColumnComment(tableName, sqlId, def.new.doc);
+            addMigration(resultObj, artifactName, false, alterComment);
+            continue;
+          }
+        }
+
         if (options.sqlChangeMode === 'drop' || def.old.target || def.new.target || reducesTypeSize(def)) {
           // Lossy change because either an association is removed and/or added, or the type size is reduced.
           // Drop old element and re-add it in its new shape.
@@ -408,8 +464,7 @@ function toSqlDdl(csn, options) {
         }
         else {
           // Lossless change: no associations directly affected, no size reduction.
-          const eltStr = renderElement(artifactName, eltName, def.new, null, null, env);
-          addMigration(resultObj, artifactName, false, render.alterColumns(tableName, eltStr));
+          addMigration(resultObj, artifactName, false, render.alterColumns(tableName, eltStrNew));
         }
       }
     }
@@ -425,6 +480,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    */
   function renderEntityInto(artifactName, art, resultObj, env) {
+    env._artifact = art;
     const childEnv = increaseIndent(env);
     const hanaTc = art.technicalConfig && art.technicalConfig.hana;
     let result = '';
@@ -512,6 +568,9 @@ function toSqlDdl(csn, options) {
     if (options.toSql.dialect === 'hana')
       renderIndexesInto(art.technicalConfig && art.technicalConfig.hana.indexes, artifactName, resultObj, env);
 
+    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options, art))
+      result += ` COMMENT '${getHanaComment(art)}'`;
+
     resultObj.hdbtable[artifactName] = result;
   }
 
@@ -610,6 +669,9 @@ function toSqlDdl(csn, options) {
     if (fzindex && options.toSql.dialect === 'hana')
       result += ` ${renderExpr(fzindex, env)}`;
 
+    if (options.toSql.dialect === 'hana' && hasHanaComment(elm, options, env._artifact))
+      result += ` COMMENT '${getHanaComment(elm)}'`;
+
     return result;
   }
 
@@ -991,8 +1053,13 @@ function toSqlDdl(csn, options) {
     const viewName = renderArtifactName(artifactName);
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art && art.$location, artifactName);
     let result = `VIEW ${viewName}`;
+
+    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options, art))
+      result += ` COMMENT '${getHanaComment(art)}'`;
+
     result += renderParameterDefinitions(artifactName, art.params);
     result += ` AS ${renderQuery(artifactName, getNormalizedQuery(art).query, env)}`;
+
     const childEnv = increaseIndent(env);
     const associations = Object.keys(art.elements).filter(name => !!art.elements[name].target)
       .map(name => renderAssociationElement(name, art.elements[name], childEnv))
@@ -1002,6 +1069,7 @@ function toSqlDdl(csn, options) {
       result += `${env.indent}\nWITH ASSOCIATIONS (\n${associations}\n`;
       result += `${env.indent})`;
     }
+
     return result;
   }
 
@@ -1020,8 +1088,15 @@ function toSqlDdl(csn, options) {
         const p = params[pn];
         if (p.notNull === true || p.notNull === false)
           info(null, [ 'definitions', artifactName, 'params', pn ], 'Not Null constraints on SQL view parameters are not allowed and are ignored');
-
-        let pstr = `IN ${prepareIdentifier(pn)} ${renderTypeReference(artifactName, pn, p)}`;
+        // do not quote parameter identifiers for naming mode "quoted" / "hdbcds"
+        // this would be an incompatible change, as non-uppercased, quoted identifiers
+        // are rejected by the HANA compiler.
+        let pIdentifier;
+        if (options.toSql.names === 'quoted' || options.toSql.names === 'hdbcds')
+          pIdentifier = prepareIdentifier(pn);
+        else
+          pIdentifier = quoteSqlId(pn);
+        let pstr = `IN ${pIdentifier} ${renderTypeReference(artifactName, pn, p)}`;
         if (p.default)
           pstr += ` DEFAULT ${renderExpr(p.default)}`;
 
@@ -1268,7 +1343,8 @@ function toSqlDdl(csn, options) {
   function renderExpr(x, env, inline = true, nestedExpr = false) {
     // Compound expression
     if (Array.isArray(x)) {
-      return processExprArray(x, renderExpr, env, inline, nestedExpr);
+      const tokens = x.map(item => renderExpr(item, env, inline, nestedExpr));
+      return beautifyExprArray(tokens);
     }
     else if (typeof x === 'object' && x !== null) {
       if (nestedExpr && x.cast && x.cast.type)

package/lib/render/utils/common.js

@@ -18,6 +18,9 @@ const {
   hasValidSkipOrExists, forEachDefinition, getNamespace, getUnderscoredName,
 } = require('../../model/csnUtils');
 
+const { implicitAs } = require('../../model/csnRefs');
+
+
 /**
  * Render the given function
  *
@@ -50,19 +53,14 @@ function funcWithoutParen( node, dialect ) {
 }
 
 /**
- * Process an expression array, rendering each subexpression and joining them appropriately
+ * Process already rendered expression parts by joining them nicely
  *
- * @param {Array} xpr Expression array
- * @param {Function} renderExpr Function to render expressions
- * @param {CdlRenderEnvironment} env Environment for rendering
- * @param {boolean} inline Wether to render the expression inline
- * @param {boolean} inExpr Wether to render as if a subexpression
+ * @param {Array} tokens Array of expression tokens
  *
  * @returns {string} The rendered xpr
  */
-function processExprArray(xpr, renderExpr, env, inline, inExpr) {
+function beautifyExprArray(tokens) {
   // Simply concatenate array parts with spaces (with a tiny bit of beautification)
-  const tokens = xpr.map(item => renderExpr(item, env, inline, inExpr));
   let result = '';
   for (let i = 0; i < tokens.length; i++) {
     result += tokens[i];
@@ -283,6 +281,26 @@ const cdsToSqlTypes = {
   },
 };
 
+/**
+   * Get the element matching the column
+   *
+   * @param {CSN.Elements} elements Elements of a query
+   * @param {CSN.Column} column Column from the same query
+   * @returns {CSN.Element}
+   */
+function findElement(elements, column) {
+  if (!elements)
+    return undefined;
+  if (column.as)
+    return elements[column.as];
+  else if (column.ref)
+    return elements[implicitAs(column.ref)];
+  else if (column.func)
+    return elements[column.func];
+
+  return undefined;
+}
+
 /**
   * If there is a context A and a context A.B.C without a definition A.B, create an
   * intermediate context A.B to keep the context hierarchy intact.
@@ -313,6 +331,30 @@ function addIntermediateContexts(csn, killList) {
   }
 }
 
+/**
+ * Check wether the given artifact or element has a comment that needs to be rendered.
+ * Things annotated with @cds.persistence.journal (for HANA SQL), should not get a comment.
+ *
+ * @param {CSN.Artifact} obj
+ * @param {CSN.Options} options To check for `disableHanaComments`
+ * @returns {boolean}
+ */
+function hasHanaComment(obj, options) {
+  return !options.disableHanaComments && typeof obj.doc === 'string';
+}
+/**
+   * Return the comment of the given artifact or element.
+   * Uses the first block (everything up to the first empty line (double \n)).
+   * Remove leading/trailing whitespace.
+   *
+   * @param {CSN.Artifact|CSN.Element} obj
+   * @returns {string}
+   * @todo Warning/info to user?
+   */
+function getHanaComment(obj) {
+  return obj.doc.split('\n\n')[0].trim().replace(/'/g, "''");
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
@@ -331,10 +373,14 @@ function addIntermediateContexts(csn, killList) {
 
 module.exports = {
   renderFunc,
-  processExprArray,
+  beautifyExprArray,
   getNamespace,
   getRealName,
   addIntermediateContexts,
   addContextMarkers,
   cdsToSqlTypes,
+  hasHanaComment,
+  getHanaComment,
+  findElement,
+  funcWithoutParen,
 };

package/lib/render/utils/sql.js

@@ -20,9 +20,9 @@ const { smartId, delimitedId } = require('../../sql-identifier');
 function renderReferentialConstraint(constraint, indent, toUpperCase, csn, options, alterConstraint) {
   let quoteId;
   // for to.hana we can't utilize the sql identifier utils
-  if (options.toHana) {
+  if (options.transformation === 'hdbcds') {
     quoteId = (id) => {
-      if (options.toHana.names === 'plain')
+      if (options.sqlMapping === 'plain')
         return id.replace(/\./g, '_');
       return `"${id}"`;
     };
@@ -38,7 +38,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     constraint.parentTable = constraint.parentTable.toUpperCase();
   }
 
-  const renderAsHdbconstraint = options.toHana ||
+  const renderAsHdbconstraint = options.transformation === 'hdbcds' ||
                                 (options.toSql && options.toSql.src === 'hdi') ||
                                 (options.manageConstraints && options.manageConstraints.src === 'hdi');
 

package/lib/sql-identifier.js

@@ -51,7 +51,12 @@ const sqlDialects = {
     effectiveName: name => name.toUpperCase(),
     asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
   },
-  // TODO: hdbcds for HANA CDS
+  hdbcds: {
+    regularRegex: /^[A-Za-z_][A-Za-z_0-9]*$/,
+    reservedWords: keywords.hdbcds,
+    effectiveName: name => name,
+    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+  },
 };
 
 function smartId( name, dialect ) {

package/lib/transform/{sql → db}/assertUnique.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { forEachDefinition, hasBoolAnnotation } = require('../../model/csnUtils');
+const { forEachDefinition, hasAnnotationValue } = require('../../model/csnUtils');
 const { getTransformers } = require('../transformUtilsNew');
 const { setProp } = require('../../base/model');
 
@@ -31,7 +31,7 @@ function processAssertUnique(csn, options, error, info) {
    */
   function handleAssertUnique(artifact, artifactName) {
     // operate only on real entities that are not abstract
-    if (artifact.abstract || (artifact.kind !== 'entity' || (artifact.query || artifact.projection) && !hasBoolAnnotation(artifact, '@cds.persistence.table')))
+    if (artifact.abstract || (artifact.kind !== 'entity' || (artifact.query || artifact.projection) && !hasAnnotationValue(artifact, '@cds.persistence.table')))
       return;
     const constraintXrefs = Object.create(null);
     const constraintDict = Object.create(null);
@@ -260,7 +260,7 @@ function processAssertUnique(csn, options, error, info) {
  * If the output format is SQL, the toSql renderer is responsible
  * to render the table constraints from the constraint dictionary.
  *
- * If options.toHana, no path flattening is done and  association
+ * If options.transformation === 'hdbcds', no path flattening is done and  association
  * paths are replaced with the foreign key paths by simply
  * concatenating the foreign key paths (available in element.keys).
  *
@@ -279,11 +279,10 @@ function rewriteUniqueConstraints(csn, options, pathDelimiter) {
    * @param {CSN.Artifact} artifact
    */
   function rewrite(artifact) {
-    const naming = options.forHana.names || options.toSql.names;
     if (artifact.$tableConstraints && artifact.$tableConstraints.unique) {
       const uniqueConstraints = artifact.$tableConstraints.unique;
       // it's safe to add the tc here
-      if (options.toHana) {
+      if (options.transformation === 'hdbcds') {
         if (!artifact.technicalConfig)
           artifact.technicalConfig = Object.create(null);
 
@@ -302,12 +301,12 @@ function rewriteUniqueConstraints(csn, options, pathDelimiter) {
         c.forEach((cpath) => {
           // If 'toSql' or 'toHana' and naming !== 'hdbcds'
           // concatenate path refs with appropriate delimiter
-          if (!options.toHana || (options.toHana && naming !== 'hdbcds'))
+          if (options.transformation !== 'hdbcds' || (options.transformation === 'hdbcds' && options.sqlMapping !== 'hdbcds'))
             cpath.ref = [ cpath.ref.map(p => p.id).join( pathDelimiter ) ];
 
           // Foreign key substitution
           if (cpath._art.target) {
-            if (!options.toHana || (options.toHana && naming !== 'hdbcds')) {
+            if (options.transformation !== 'hdbcds' || (options.transformation === 'hdbcds' && options.sqlMapping !== 'hdbcds')) {
               // read out new association and use $generatedFieldName
               // cpath._art still refers to the assoc definition
               // before the A2J transformation. This assoc
@@ -332,7 +331,7 @@ function rewriteUniqueConstraints(csn, options, pathDelimiter) {
         uniqueConstraints[uniqueConstraint] = rewrittenPaths;
 
         // now add the index for HANA CDS
-        if (options.toHana) {
+        if (options.transformation === 'hdbcds') {
           const index = [ 'unique', 'index', { ref: [ uniqueConstraint ] }, 'on', '(' ];
           let i = 0;
           for (const constraint of rewrittenPaths) {

package/lib/transform/{sql → db}/constraints.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { forEachDefinition } = require('../../base/model');
-const { forAllElements, hasBoolAnnotation, getResultingName } = require('../../model/csnUtils');
+const { forAllElements, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
 const { csnRefs } = require('../../model/csnRefs');
 
 const COMPOSITION = 'cds.Composition';
@@ -12,7 +12,6 @@ const ASSOCIATION = 'cds.Association';
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options are used to modify the validate / enforced flag on the constraints
- *
  */
 function createReferentialConstraints(csn, options) {
   let validated = true;
@@ -46,7 +45,7 @@ function createReferentialConstraints(csn, options) {
           if (element.type === ASSOCIATION ||
              element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
             associations.push(() => {
-              foreignKeyConstraintForAssociation(element, elements, path.concat([ elementName ]));
+              foreignKeyConstraintForAssociation(element, elements, path.concat([ elementName ]), elementName);
             });
           }
         }
@@ -81,12 +80,14 @@ function createReferentialConstraints(csn, options) {
         // 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"
-        if (dependentKeys.length === parentKeys.length)
-          attachConstraintsToDependentKeys(dependentKeys, parentKeys, path[path.length - 3], path, 'CASCADE');
+        // 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');
       }
     }
-    else if (!onCondition && composition.keys) {
+    else if (!onCondition && composition.keys.length > 0) {
       throw new Error('Please debug me, an on-condition was expected here, but only found keys');
     }
   }
@@ -98,8 +99,9 @@ function createReferentialConstraints(csn, options) {
    * @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
    */
-  function foreignKeyConstraintForAssociation(association, elements, path) {
+  function foreignKeyConstraintForAssociation(association, elements, path, assocName) {
     const associationTarget = csn.definitions[association.target];
     if (skipConstraintGeneration(associationTarget, association))
       return;
@@ -112,9 +114,9 @@ function createReferentialConstraints(csn, options) {
       const parentKeys = Array.from(elementsOfTargetSide(onCondition, associationTarget.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);
+        attachConstraintsToDependentKeys(dependentKeys, parentKeys, association.target, path, assocName);
     }
-    else if (!onCondition && association.keys) {
+    else if (!onCondition && association.keys.length > 0) {
       throw new Error('Please debug me, an on-condition was expected here, but only found keys');
     }
   }
@@ -128,9 +130,10 @@ function createReferentialConstraints(csn, options) {
    * @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'
    */
-  function attachConstraintsToDependentKeys(dependentKeys, parentKeys, parentTable, path, onDelete = 'RESTRICT') {
+  function attachConstraintsToDependentKeys(dependentKeys, parentKeys, parentTable, path, constraintIdentifierSuffix, onDelete = 'RESTRICT') {
     while (dependentKeys.length > 0) {
       const dependentKeyValuePair = dependentKeys.pop();
       const dependentKey = dependentKeyValuePair[1];
@@ -144,7 +147,7 @@ function createReferentialConstraints(csn, options) {
         parentKey: parentKeyName,
         parentTable,
         sourceAssociation: path[path.length - 1],
-        nameSuffix: dependentKey['@odata.foreignKey4'] || 'up_',
+        nameSuffix: constraintIdentifierSuffix || 'up_',
         onDelete,
         validated,
         enforced,
@@ -220,8 +223,8 @@ function createReferentialConstraints(csn, options) {
    * @returns {boolean}
    */
   function skipConstraintGeneration(parent, element) {
-    if (hasBoolAnnotation(element, '@assert.integrity', false) ||
-     hasBoolAnnotation(element, '@cds.persistency.assert.integrity', false)) {
+    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;
@@ -230,16 +233,18 @@ function createReferentialConstraints(csn, options) {
       return true;
     }
 
-    if (element.$skipReferentialConstraintForUp_)
+    if (element.$skipReferentialConstraintForUp_) {
+      delete element.$skipReferentialConstraintForUp_;
       return true;
+    }
 
-    if (hasBoolAnnotation(parent, '@cds.persistence.skip', true) ||
-     hasBoolAnnotation(parent, '@cds.persistence.exists', true) ||
+    if (hasAnnotationValue(parent, '@cds.persistence.skip', true) ||
+     hasAnnotationValue(parent, '@cds.persistence.exists', true) ||
      parent.query)
       return true;
 
     // '@cds.persistency.assert.integrity: true' supersedes global switch
-    if (!hasBoolAnnotation(element, '@cds.persistency.assert.integrity', true) && options.forHana.skipDbConstraints)
+    if (!hasAnnotationValue(element, '@cds.persistency.assert.integrity', true) && options.forHana.skipDbConstraints)
       return true;
 
     return false;
@@ -352,11 +357,21 @@ function createReferentialConstraints(csn, options) {
    * 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 {any} true if the composition should be treated as an association in regards to foreign key constraints
+   * @returns {boolean} true if the composition should be treated as an association in regards to foreign key constraints
    */
   function treatCompositionLikeAssociation(composition) {
-    const { min, max } = composition.cardinality || {};
-    return (!min && !max || max === 1) && composition.keys;
+    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;
   }
 }