@sap/cds 5.5.2 → 5.6.0

package/libx/_runtime/cds-services/services/utils/columns.js

@@ -127,7 +127,12 @@ const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }) =>
     cqn.SELECT.columns.forEach(column => {
       if (column.func) {
         // exclude $count by SELECT of number of Items in a Collection
-        if (cqn.SELECT.columns.length === 1 && column.func === 'count' && column.as === '_counted_') return
+        if (
+          cqn.SELECT.columns.length === 1 &&
+          column.func === 'count' &&
+          (column.as === '_counted_' || column.as === '$count')
+        )
+          return
         toBeSearched.push(column)
         return
       }

package/libx/_runtime/cds-services/services/utils/compareJson.js

@@ -141,15 +141,8 @@ const _addKeysToEntryIfNotExists = (keys, newEntry) => {
   }
 }
 
-const isSelfManaged = element => {
-  if (element.on && element.on.length > 2) {
-    return element.on[0].ref[0] === '$self' || element.on[2].ref[0] === '$self'
-  }
-  return false
-}
-
 const _isUnManaged = element => {
-  return element.on && !isSelfManaged(element)
+  return element.on && !element._isSelfManaged
 }
 
 const _skip = (entity, prop) => entity.elements[prop]._target._hasPersistenceSkip

package/libx/_runtime/cds-services/services/utils/differ.js

@@ -7,8 +7,9 @@ const { selectDeepUpdateData } = require('../../../common/composition')
 const { ensureDraftsSuffix } = require('../../../fiori/utils/handler')
 
 const { DRAFT_COLUMNS } = require('../../../common/constants/draft')
-const cqn2cqn4sql = require('../../../common/utils/cqn2cqn4sql')
+const { cqn2cqn4sql, convertPathExpressionToWhere } = require('../../../common/utils/cqn2cqn4sql')
 const { revertData } = require('../../../common/utils/resolveView')
+const { removeIsActiveEntityRecursively } = require('../../../fiori/utils/where')
 
 module.exports = class {
   constructor(srv) {
@@ -32,31 +33,11 @@ module.exports = class {
     return columns
   }
 
-  _createWhereCondition(entity, data) {
-    return Object.keys(entity.keys).reduce((prev, curr) => {
-      if (!DRAFT_COLUMNS.includes(curr)) {
-        prev[curr] = data[curr]
-      }
-
-      return prev
-    }, {})
-  }
-
   _diffDelete(req) {
     const { DELETE } = (req._ && req._.query) || req.query
     const query = SELECT.from(DELETE.from).columns(this._createSelectColumnsForDelete(req.target))
     if (DELETE.where) query.where(...DELETE.where)
 
-    // REVISIT: should be done in cqn2cqn4sql
-    if (req.target._isDraftEnabled && query.SELECT.from.ref.some(r => r.where)) {
-      query.SELECT.from.ref.forEach((r, i) => {
-        if (!r.where) return
-        const j = r.where.findIndex(w => w.ref && w.ref.some(r => r === 'IsActiveEntity'))
-        if (j === -1) return
-        r.where.splice(Math.max(j - 1, 0), 4)
-      })
-    }
-
     return cds
       .tx(req)
       .run(query)
@@ -92,14 +73,14 @@ module.exports = class {
 
   async _diffPatch(req, providedData) {
     if (cds.db) {
+      const { target, alias, where = [] } = convertPathExpressionToWhere(req.query.UPDATE.entity, this._srv.model, {})
+
+      const draftRef = { ref: [ensureDraftsSuffix(target)], as: alias }
+
       // SELECT because req.query in custom handler does not have access to _drafts
       req._.partialPersistentState = await cds
         .tx(req)
-        .run(
-          SELECT.from(ensureDraftsSuffix(req.target.name))
-            .where(this._createWhereCondition(req.target, req.data))
-            .limit(1)
-        )
+        .run(SELECT.from(draftRef).where(removeIsActiveEntityRecursively(where)).limit(1))
 
       return compareJson(providedData || req.data, req._.partialPersistentState, req.target)
     }

package/libx/_runtime/cds-services/services/utils/handlerUtils.js

@@ -2,7 +2,6 @@ const cds = require('../../../cds')
 
 const { SELECT } = cds.ql
 
-const { foreignKeyPropagations } = require('../../../common/utils/foreignKeyPropagations')
 const { checkReferenceIntegrity } = require('../../util/assert')
 const { processDeep, processDeepAsync } = require('../../util/dataProcessUtils')
 
@@ -74,9 +73,8 @@ const _getSelectCQN = (req, columns) => {
 }
 
 function _fillForeignKeysWithNull(managedAssocToOneElement, row) {
-  const keys = foreignKeyPropagations(managedAssocToOneElement)
-  for (const key of keys) {
-    row[key.parentFieldName] = null
+  for (const key of managedAssocToOneElement._foreignKeys) {
+    if (key.parentElement) row[key.parentElement.name] = null
   }
 }
 

package/libx/_runtime/cds-services/util/assert.js

@@ -1,8 +1,10 @@
+const cds = require('../../cds')
 const { all, resolve } = require('../../common/utils/thenable')
 const { getDependents } = require('../../common/utils/csn')
 
 // REVISIT: replace with cds.Request
 const getEntry = require('../../common/error/entry')
+const crypto = require('crypto')
 
 const ISO_DATE_PART1 =
   '[1-9]\\d{3}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1\\d|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)'
@@ -174,11 +176,12 @@ const checkComplexType = ([key, value], elements, ignoreNonModelledData) => {
   return found || ignoreNonModelledData
 }
 
-const _checkStaticElementByKey = (entity, key, value, result, ignoreNonModelledData) => {
-  const element = entity.elements && entity.elements[key]
+const _checkStaticElementByKey = (definition, key, value, result, ignoreNonModelledData) => {
+  const elementsOrParameters = definition.elements || definition.params
+  const elementOrParameter = elementsOrParameters[key]
 
-  if (!element) {
-    if (!checkComplexType([key, value], entity.elements, ignoreNonModelledData)) {
+  if (!elementOrParameter) {
+    if (!checkComplexType([key, value], elementsOrParameters, ignoreNonModelledData)) {
       result.push(assertError(ASSERT_VALID_ELEMENT, { name: key }))
     }
 
@@ -186,17 +189,17 @@ const _checkStaticElementByKey = (entity, key, value, result, ignoreNonModelledD
   }
 
   let check
-  if (element.type === 'cds.UUID' && entity.name === 'ProvisioningService.tenant') {
+  if (elementOrParameter.type === 'cds.UUID' && definition.name === 'ProvisioningService.tenant') {
     // > old SCP accounts don't have UUID ids
     check = CDS_TYPE_CHECKS['cds.String']
   } else {
-    check = CDS_TYPE_CHECKS[element.type]
+    check = CDS_TYPE_CHECKS[elementOrParameter.type]
   }
 
-  if (check && !check(value, element)) {
+  if (check && !check(value, elementOrParameter)) {
     // code, entity, element, value
-    const args = [typeof value === 'string' ? '"' + value + '"' : value, element.type]
-    result.push(assertError({ code: ASSERT_DATA_TYPE, args }, element, value, key))
+    const args = [typeof value === 'string' ? '"' + value + '"' : value, elementOrParameter.type]
+    result.push(assertError({ code: ASSERT_DATA_TYPE, args }, elementOrParameter, value, key))
   }
 
   return result
@@ -294,14 +297,14 @@ const checkInputConstraints = ({ element, value, errors, key, pathSegments, even
   return errors
 }
 
-const checkStatic = (entity, data, ignoreNonModelledData = false) => {
+const checkStatic = (definition, data, ignoreNonModelledData = false) => {
   if (!Array.isArray(data)) data = [data]
 
   return data.reduce((result, row) => {
     return Object.entries(row)
       .filter(([key, value]) => value !== null && value !== undefined)
       .reduce((result, [key, value]) => {
-        return _checkStaticElementByKey(entity, key, value, result, ignoreNonModelledData)
+        return _checkStaticElementByKey(definition, key, value, result, ignoreNonModelledData)
       }, result)
   }, [])
 }
@@ -320,6 +323,20 @@ const _checkExistsWhere = (entity, whereList, run) => {
       }
     }
 
+    if (cds.context) {
+      const hash = crypto.createHash('sha1').update(JSON.stringify(cqn)).digest('base64') // fastest hash
+      if (!cds.context.__alreadyExecutedIntegrityChecks) cds.context.__alreadyExecutedIntegrityChecks = new Map()
+      if (cds.context.__alreadyExecutedIntegrityChecks.has(hash)) {
+        return cds.context.__alreadyExecutedIntegrityChecks.get(hash)
+      } else {
+        const promise = run(cqn).then(exists => {
+          return exists.length !== 0
+        })
+        // we store the promise object in the map, it won't get executed twice when calling await Promise.all([promise, promise])
+        cds.context.__alreadyExecutedIntegrityChecks.set(hash, promise)
+        return promise
+      }
+    }
     return run(cqn).then(exists => {
       return exists.length !== 0
     })
@@ -553,9 +570,8 @@ const checkKeys = (entity, data) => {
   const entityKeys = Object.keys(entity.keys)
   return data.reduce((result, row) => {
     for (const key of entityKeys) {
-      if (entityKeys.some(key => row[key] === undefined)) {
+      if (row[key] === undefined && entity.elements[key].type !== 'cds.Association')
         result.push(assertError(ASSERT_NOT_NULL, entity.elements[key]))
-      }
     }
     return result
   }, [])

package/libx/_runtime/cds.js

@@ -5,8 +5,9 @@ module.exports = cds
 /*
  * csn aspects
  */
-const { any, entity } = cds.builtin.classes
+const { any, entity, Association } = cds.builtin.classes
 cds.extend(any).with(require('./common/aspects/any'))
+cds.extend(Association).with(require('./common/aspects/Association'))
 cds.extend(entity).with(require('./common/aspects/entity'))
 
 /*

package/libx/_runtime/common/aspects/Association.js

@@ -0,0 +1,72 @@
+// global.cds is used on purpose here!
+const cds = global.cds
+
+const ODATA_CONTAINED = '@odata.contained'
+
+const { isSelfManaged, isBacklink, getAnchor, getBacklink } = require('./utils')
+const { foreignKeyPropagations } = require('../utils/foreignKeyPropagations')
+
+module.exports = class {
+  get _isAssociationStrict() {
+    return (
+      this.own('__isAssociationStrict') ||
+      this.set('__isAssociationStrict', !!(this.isAssociation && !this.isComposition))
+    )
+  }
+
+  get _isAssociationEffective() {
+    return (
+      this.own('__isAssociationEffective') ||
+      this.set(
+        '__isAssociationEffective',
+        this._isAssociationStrict && (!this[ODATA_CONTAINED] || this.name === 'DraftAdministrativeData')
+      )
+    )
+  }
+
+  get _isCompositionEffective() {
+    return (
+      this.own('__isCompositionEffective') ||
+      this.set(
+        '__isCompositionEffective',
+        this.isComposition ||
+          (this._isAssociationStrict && this[ODATA_CONTAINED] && this.name !== 'DraftAdministrativeData')
+      )
+    )
+  }
+
+  get _isContained() {
+    return (
+      this.own('__isContained') ||
+      this.set(
+        '__isContained',
+        this.name !== 'DraftAdministrativeData_DraftUUID' &&
+          ((this.isAssociation && this[ODATA_CONTAINED]) || (this.isComposition && cds.env.effective.odata.containment))
+      )
+    )
+  }
+
+  get _isSelfManaged() {
+    return this.own('__isSelfManaged') || this.set('__isSelfManaged', isSelfManaged(this))
+  }
+
+  get _isBacklink() {
+    return this.own('__isBacklink') || this.set('__isBacklink', isBacklink(this))
+  }
+
+  get _isCompositionBacklink() {
+    return this.own('__isCompositionBacklink') || this.set('__isCompositionBacklink', isBacklink(this, true))
+  }
+
+  get _anchor() {
+    return this.own('__anchor') || this.set('__anchor', getAnchor(this))
+  }
+
+  get _backlink() {
+    return this.own('__backlink') || this.set('__backlink', getBacklink(this))
+  }
+
+  get _foreignKeys() {
+    return this.own('__foreignKeys') || this.set('__foreignKeys', foreignKeyPropagations(this))
+  }
+}

package/libx/_runtime/common/aspects/any.js

@@ -1,54 +1,12 @@
-// global.cds is used on purpose here!
-const cds = global.cds
-
-const ODATA_CONTAINED = '@odata.contained'
-
-const { isMandatory, isReadOnly } = require('./utils')
+const { getRelations, isMandatory, isReadOnly } = require('./utils')
 
+// NOTE: Please only add things which are relevant to _any_ type,
+// use specialized types otherwise (entity, Association, ...).
 module.exports = class {
-  get _isAssociationStrict() {
-    return (
-      this.own('__isAssociationStrict') ||
-      this.set('__isAssociationStrict', !!(this.isAssociation && !this.isComposition))
-    )
-  }
-
-  get _isAssociationEffective() {
-    return (
-      this.own('__isAssociationEffective') ||
-      this.set(
-        '__isAssociationEffective',
-        this._isAssociationStrict && (!this[ODATA_CONTAINED] || this.name === 'DraftAdministrativeData')
-      )
-    )
-  }
-
-  get _isCompositionEffective() {
-    return (
-      this.own('__isCompositionEffective') ||
-      this.set(
-        '__isCompositionEffective',
-        this.isComposition ||
-          (this._isAssociationStrict && this[ODATA_CONTAINED] && this.name !== 'DraftAdministrativeData')
-      )
-    )
-  }
-
   get _isStructured() {
     return this.own('__isStructured') || this.set('__isStructured', !!this.elements && this.kind !== 'entity')
   }
 
-  get _isContained() {
-    return (
-      this.own('__isContained') ||
-      this.set(
-        '__isContained',
-        this.name !== 'DraftAdministrativeData_DraftUUID' &&
-          ((this.isAssociation && this[ODATA_CONTAINED]) || (this.isComposition && cds.env.effective.odata.containment))
-      )
-    )
-  }
-
   get _isMandatory() {
     return this.own('__isMandatory') || this.set('__isMandatory', !this.isAssociation && isMandatory(this))
   }
@@ -56,4 +14,9 @@ module.exports = class {
   get _isReadOnly() {
     return this.own('__isReadOnly') || this.set('__isReadOnly', !this.key && isReadOnly(this))
   }
+
+  // REVISIT: Where to put?
+  get _relations() {
+    return this.own('__relations') || this.set('__relations', getRelations(this))
+  }
 }

package/libx/_runtime/common/aspects/entity.js

@@ -44,7 +44,6 @@ module.exports = class {
     // lazily require on first use
     getSearchableColumns =
       getSearchableColumns || require('../../cds-services/services/utils/columns').getSearchableColumns
-
     return this.own('__searchableColumns') || this.set('__searchableColumns', getSearchableColumns(this))
   }
 

package/libx/_runtime/common/aspects/relation.js

@@ -0,0 +1,40 @@
+const { getOnCond } = require('../utils/generateOnCond')
+
+let initializing = false
+
+module.exports = class Relation {
+  constructor(csn, path = []) {
+    if (!initializing) throw new Error(`Do not new a relation, use 'Relation.to()' instead`)
+    Object.defineProperty(this, 'csn', { get: () => csn })
+    Object.defineProperty(this, 'path', {
+      get: () => path,
+      set: _ => {
+        path = _
+      }
+    })
+    if (csn.target) Object.defineProperty(this, 'target', { get: () => csn.target })
+    initializing = false
+  }
+
+  static to(from, name) {
+    initializing = true
+    if (!name) return new Relation(from)
+    return from._elements[name] && new Relation(from._elements[name], [...from.path, name])
+  }
+
+  _has(prop) {
+    return Reflect.has(this, prop) && !this._elements[prop]
+  }
+
+  get _elements() {
+    if (this.csn.elements) return this.csn.elements
+    if (this.csn._target && this.csn._target.elements) return this.csn._target.elements
+    // if (csn.targetAspect) relation.elements = model.definitions[csn.targetAspect].elements
+    // if (csn.kind = 'type') relation.elements = model.definitions[csn.type].element
+    return {}
+  }
+
+  join(fromAlias = '', toAlias = '') {
+    return getOnCond(this.csn, this.path, { select: fromAlias, join: toAlias })
+  }
+}

package/libx/_runtime/common/aspects/utils.js

@@ -1,3 +1,5 @@
+const Relation = require('./relation')
+
 const CommonFieldControl = e => {
   const cfr = e['@Common.FieldControl']
   return cfr && cfr['#']
@@ -65,10 +67,80 @@ const hasSensitiveData = entity => {
   return val
 }
 
+const _exposeRelation = relation => Object.defineProperty({}, '_', { get: () => relation })
+
+const _relationHandler = relation => ({
+  get: (target, name) => {
+    const path = name.split(',')
+    const prop = path.join('_')
+    if (!target[prop]) {
+      if (path.length === 1) {
+        // REVISIT: property 'join' must not be used in CSN to make this working
+        if (relation._has(prop)) return relation[prop]
+        const newRelation = Relation.to(relation, prop)
+        if (newRelation) {
+          target[prop] = new Proxy(_exposeRelation(newRelation), _relationHandler(newRelation))
+        }
+        return target[prop]
+      }
+      target[prop] = path.reduce((r, p) => r[p] || r.csn._relations[p], relation)
+      target[prop].path = path
+    }
+    return target[prop]
+  }
+})
+
+const getRelations = e => {
+  const newRelation = Relation.to(e)
+  return new Proxy(_exposeRelation(newRelation), _relationHandler(newRelation))
+}
+
+const _hasJoinCondition = e => e.isAssociation && e.on && e.on.length > 2
+
+const _isSelfRef = e => e.ref && e.ref[0] === '$self'
+
+const _getBacklinkName = on => {
+  const i = on.findIndex(_isSelfRef)
+  if (i === -1) return
+  let ref
+  if (on[i + 1] && on[i + 1] === '=') ref = on[i + 2].ref
+  if (on[i - 1] && on[i - 1] === '=') ref = on[i - 2].ref
+  return ref && ref[ref.length - 1]
+}
+
+const isSelfManaged = e => {
+  if (!_hasJoinCondition(e)) return
+  return !!e.on.find(_isSelfRef)
+}
+
+const isBacklink = (e, checkComposition) => getAnchor(e, checkComposition) && true
+
+const _isUnManagedAssociation = (e, checkComposition) =>
+  e.isAssociation && (!checkComposition || e._isCompositionEffective) && _hasJoinCondition(e)
+
+const getAnchor = (e, checkComposition) => {
+  if (!(e._isAssociationStrict && (e.keys || e.on))) return
+  for (const anchor of Object.values(e._target.associations || {})) {
+    if (!_isUnManagedAssociation(anchor, checkComposition)) continue
+    if (_getBacklinkName(anchor.on) === e.name && anchor.target === e.parent.name) return anchor
+  }
+}
+
+const getBacklink = (e, checkComposition) => {
+  if (!_isUnManagedAssociation(e, checkComposition)) return
+  const backlinkName = _getBacklinkName(e.on)
+  if (backlinkName) return e._target && e._target.elements && e._target.elements[backlinkName]
+}
+
 module.exports = {
   isMandatory,
   isReadOnly,
   getETag,
   hasPersonalData,
-  hasSensitiveData
+  hasSensitiveData,
+  getRelations,
+  isSelfManaged,
+  isBacklink,
+  getAnchor,
+  getBacklink
 }

package/libx/_runtime/common/auth/strategies/utils/uaa.js

@@ -1,22 +1,11 @@
 const cds = require('../../../../cds')
 
-const _require = require('../../../utils/require')
-
 const getCredentials = uaa => {
   uaa = uaa || cds.env.requires.uaa || {}
 
   if (!uaa.credentials) {
-    try {
-      const vcap = cds.env.requires.uaa && cds.env.requires.uaa.vcap
-      uaa.credentials = _require('@sap/xsenv').serviceCredentials(vcap || { label: 'xsuaa' })
-    } catch (e) {
-      const msg =
-        'Unable to get xsuaa credentials. Please make sure your app is bound to a single xsuaa service instance or that you provide vcap information in the requires.uaa section.'
-      // REVISIT: switch to verror
-      throw Object.assign(new Error(msg), { original: e })
-    }
+    throw Object.assign(new Error('No or malformed uaa credentials'), { credentials: uaa.credentials })
   }
-
   return uaa.credentials
 }
 

package/libx/_runtime/common/composition/data.js

@@ -4,8 +4,9 @@ const { getEntityNameFromUpdateCQN } = require('../utils/cqn')
 
 const { ensureNoDraftsSuffix } = require('../utils/draft')
 const { getDBTable } = require('../utils/resolveView')
-const cqn2cqn4sql = require('../utils/cqn2cqn4sql')
+const { cqn2cqn4sql } = require('../utils/cqn2cqn4sql')
 const cds = require('../../cds')
+const { SELECT } = cds.ql
 
 /*
  * own utils
@@ -192,7 +193,7 @@ const _select = ({
 }) => {
   const entity = definitions && definitions[entityName]
   const from = ctUtils.addDraftSuffix(draft, entity.name)
-  const selectCQN = { SELECT: { from: { ref: [from] } } }
+  const selectCQN = SELECT.from(from)
   if (alias) selectCQN.SELECT.from.as = alias
   const selectAll = includeAllColumns || (includeAllRootColumns && root)
   selectCQN.SELECT.columns = _columns(entity, data, compositionTree, selectAll)

package/libx/_runtime/common/composition/delete.js

@@ -20,8 +20,10 @@ const _recursivelyAliasRefs = (something, newAlias, oldAlias, subselect = false)
       if (oldAlias && something.ref[0] === oldAlias) something.ref[0] = newAlias
       else if (!subselect) something.ref.unshift(newAlias)
     } else {
-      for (const key in something)
+      for (const key in something) {
+        if (key === 'from') continue // Workaround: Deep delete to be rewritten
         _recursivelyAliasRefs(something[key], newAlias, oldAlias, subselect || key === 'SELECT')
+      }
     }
   }
 }

package/libx/_runtime/common/composition/tree.js

@@ -1,13 +1,9 @@
 const cds = require('../../cds')
 
-const { isSelfManaged, isBacklink } = require('../utils/backlinks')
-
 const { ensureNoDraftsSuffix } = require('../utils/draft')
 const { isRootEntity } = require('../utils/csn')
 const { getTransition, getDBTable } = require('../utils/resolveView')
 
-const { foreignKeyPropagations } = require('../utils/foreignKeyPropagations')
-
 const getError = require('../../common/error')
 
 /*
@@ -15,21 +11,25 @@ const getError = require('../../common/error')
  */
 
 const _foreignKeysToLinks = (element, inverse) =>
-  foreignKeyPropagations(element).map(e => {
+  element._foreignKeys.map(e => {
     e = inverse
       ? {
-          childFieldName: e.parentFieldName,
-          parentFieldName: e.childFieldName,
+          childElement: e.parentElement,
+          parentElement: e.childElement,
           childFieldValue: e.parentFieldValue,
           parentFieldValue: e.childFieldValue,
           prefix: e.prefix
         }
       : e
-    const link = {
-      entityKey:
-        e.prefix && !e.parentFieldName.includes(e.prefix) ? e.prefix + '_' + e.parentFieldName : e.parentFieldName,
-      targetKey: e.prefix && !e.childFieldName.includes(e.prefix) ? e.prefix + '_' + e.childFieldName : e.childFieldName
-    }
+    const link = {}
+    if (e.parentElement)
+      link.entityKey =
+        e.prefix && !e.parentElement.name.includes(e.prefix)
+          ? `${e.prefix}_${e.parentElement.name}`
+          : e.parentElement.name
+    if (e.childElement)
+      link.targetKey =
+        e.prefix && !e.childElement.name.includes(e.prefix) ? `${e.prefix}_${e.childElement.name}` : e.childElement.name
     if (e.parentFieldValue !== undefined) link.entityVal = e.parentFieldValue
     if (e.childFieldValue !== undefined) link.targetVal = e.childFieldValue
     return link
@@ -57,7 +57,7 @@ const _resolvedElement = (element, service) => {
 const _navigationExistsInCompositionMap = (element, compositionMap) =>
   compositionMap.has(element.target) && element._isCompositionEffective
 
-const _isUnManaged = element => element.on && !isSelfManaged(element)
+const _isUnManaged = element => element.on && !element._isSelfManaged
 
 const _isNonRecursiveNavigation = (element, rootEntityName) =>
   rootEntityName !== element.target && element._isCompositionEffective
@@ -106,7 +106,7 @@ const _getCompositionTreeRec = ({
         backLinks: [],
         customBackLinks: []
       })
-      if (!isSelfManaged(element)) {
+      if (!element._isSelfManaged) {
         const backLinks = _foreignKeysToLinks(element, true) || []
         if (element.is2many) {
           compositionElement.customBackLinks.push(...backLinks)
@@ -118,7 +118,11 @@ const _getCompositionTreeRec = ({
         for (const backLinkName in targetEntity.elements) {
           const _backLink = targetEntity.elements[backLinkName]
           if (!_backLink._isAssociationEffective) continue
-          if (isBacklink(_backLink, definitions[compositionElement.target], false, element.name)) {
+          if (
+            _backLink._isCompositionBacklink &&
+            _backLink.target === compositionElement.target &&
+            _backLink._anchor.name === element.name
+          ) {
             const backLinks = _foreignKeysToLinks(_backLink) || []
             if (_isUnManaged(element)) {
               compositionElement.customBackLinks.push(...backLinks)
@@ -131,7 +135,7 @@ const _getCompositionTreeRec = ({
       compositionTree.compositionElements.push(compositionElement)
     } else if (_isNonRecursiveNavigation(element, rootEntityName)) {
       const subObject = _createSubElement(element, definitions)
-      if (!isSelfManaged(element)) {
+      if (!element._isSelfManaged) {
         const backLinks = _foreignKeysToLinks(element, true) || []
         if (element.is2many) {
           subObject.customBackLinks.push(...backLinks)
@@ -151,7 +155,8 @@ const _getCompositionTreeRec = ({
       })
     } else if (
       element._isAssociationEffective &&
-      isBacklink(element, definitions[compositionTree.target], false, compositionTree.name) &&
+      element._isCompositionBacklink &&
+      element.target === compositionTree.target &&
       compositionMap.has(element.target)
     ) {
       const backLinks = _foreignKeysToLinks(element) || []
@@ -218,7 +223,7 @@ const _cacheCompositionParentsOfOne = ({ definitions }) => {
     if (!parent.kind === 'entity' || !parent.elements) continue
     for (const elementName in parent.elements) {
       const element = parent.elements[elementName]
-      if (element._isCompositionEffective && element.is2one && !isSelfManaged(element)) {
+      if (element._isCompositionEffective && element.is2one && !element._isSelfManaged) {
         const targetName = element.target
         const target = definitions[targetName]
         if (!target) continue