@sap/cds 5.5.3 → 5.6.1

package/libx/_runtime/cds-services/adapter/rest/utils/validation-checks.js

@@ -39,25 +39,18 @@ const validationChecks = (event, data, target) => {
 const _enrichErrorDetails = (isPrimitive, error) => {
   const element = error.target ? ` '${error.target}' ` : ' '
   const typeDetails = isPrimitive ? '.' : ` according to type definition '${error.type}'.`
-  return `Value '${error.value}' of element${element}is invalid${typeDetails}`
+  const value = typeof error.value === 'string' ? `'${error.value}'` : error.value
+  if (element && element.match(/\w/)) return `Value ${value} of element${element}is invalid${typeDetails}`
+  return `Value ${value} is invalid${typeDetails}`
 }
 
 // REVISIT: use i18n
-const _buildErrorMessage = (context, operation, type, typeErrors) => {
-  return `Failed to validate return value ${type ? `of type '${type}' ` : ''}for custom ${operation.kind} '${
-    context.event
+const _getTypeError = (operation, type, errorDetails) => {
+  const typeErrors = errorDetails.map(error => _enrichErrorDetails(cds.builtin.types[type], error))
+  const msg = `Failed to validate return value ${type ? `of type '${type}' ` : ''}for custom ${operation.kind} '${
+    operation.name
   }': ${typeErrors.join(' ')}`
-}
-
-const _getTypeError = (context, operation, type, errorDetails) => {
-  return getError(
-    _buildErrorMessage(
-      context,
-      operation,
-      type,
-      errorDetails.map(error => _enrichErrorDetails(cds.builtin.types[type], error))
-    )
-  )
+  return getError(msg)
 }
 
 const _buildTypeErrorObject = (type, value) => {
@@ -79,14 +72,13 @@ const _checkSingle = (type, check, data) => {
  * Validate the return type values of custom operations (actions and functions) for primitive or complex values as
  * single values or arrays.
  *
- * @param {Context} context
  * @param {Operation} operation
  * @param {object} data
  * @throws Will throw an error with error code 500 if the validation fails. Contains a detailed error message of the
  * type and name of the custom operation, the invalid values, their names and their expected types.
  * @returns {boolean} Returns true if return type validation has passed.
  */
-const validateReturnType = (context, operation, data) => {
+const validateReturnType = (operation, data) => {
   // array of or single return type
   // in case of modeled return type: { type: 'bookModel.Books', _type: csnDefinition }
   // in case of inline return type: { elements: ... } and no explicit name of return type
@@ -114,14 +106,21 @@ const validateReturnType = (context, operation, data) => {
     // Determine entity from bound or unbound action/function
     const returnTypeCsnDefinition = returnType._type || returnType
 
-    checkResult = checkStatic(returnTypeCsnDefinition, data, true)
+    // REVISIT: remove exception with cds^6
+    // mtx returns object instead of string (as in modell) -> skip validation
+    if (returnTypeCsnDefinition.type !== 'cds.String') {
+      checkResult = checkStatic(returnTypeCsnDefinition, data, true)
+    }
   }
 
-  if (checkResult.length !== 0) {
-    throw _getTypeError(context, operation, returnType.type, checkResult)
+  if (checkResult && checkResult.length !== 0) {
+    throw _getTypeError(operation, returnType.type, checkResult)
   }
 
   return true
 }
 
-module.exports = { validationChecks, validateReturnType }
+module.exports = {
+  validationChecks,
+  validateReturnType
+}

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,21 +1,17 @@
 const cds = require('../../../../cds')
 
-const _require = require('../../../utils/require')
-
 const getCredentials = uaa => {
-  uaa = uaa || cds.env.requires.uaa || {}
+  uaa =
+    uaa && uaa.credentials
+      ? uaa
+      : cds.env.requires.uaa && cds.env.requires.uaa.credentials
+      ? cds.env.requires.uaa
+      : cds.env.requires.xsuaa && cds.env.requires.xsuaa.credentials
+      ? cds.env.requires.xsuaa
+      : {}
 
-  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 })
-    }
-  }
+  if (!uaa.credentials)
+    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')
+      }
     }
   }
 }