@sap/cds 5.8.4 → 5.9.0

package/libx/_runtime/common/generic/input.js

@@ -34,9 +34,8 @@ const getSimpleCategory = category => {
 }
 
 const rowKeysGenerator = eventName => {
+  if (eventName === 'UPDATE') return
   return (keyNames, row, template) => {
-    if (eventName === 'UPDATE') return
-
     for (const keyName of keyNames) {
       if (Object.prototype.hasOwnProperty.call(row, keyName)) {
         continue
@@ -59,7 +58,10 @@ const _isDraftCoreComputed = (req, element, event) =>
   element['@Core.Computed'] &&
   !((event === 'CREATE' && element['@cds.on.insert']) || element['@cds.on.update'])
 
-const _getMediaTypeProperty = element => element['@Core.MediaType'] && element['@Core.MediaType']['=']
+const _isStreamingProperty = (elements, row, property) =>
+  Object.values(elements).some(
+    element => element['@Core.MediaType'] && element['@Core.MediaType']['='] === property && row[element.name]
+  )
 
 const _getMediaTypeValue = req =>
   req._.req &&
@@ -101,15 +103,15 @@ const _processCategory = ({ row, key, category, isRoot, event, value, req, eleme
   }
 
   // set media type from content-type header if streaming
-  const mtProperty = _getMediaTypeProperty(element)
+  const isStreaming = _isStreamingProperty(element.parent.elements, row, key)
   const mtValue = _getMediaTypeValue(req)
-  if (category === 'stream' && row[key] && mtProperty && mtValue) row[mtProperty] = mtValue
+  if (category === 'stream' && isStreaming && mtValue) row[key] = mtValue
 }
 
 const processorFn = (errors, req) => {
   const { event } = req
 
-  return ({ row, key, element, plain, isRoot, pathSegments }) => {
+  return ({ row, key, element, plain, isRoot, path }) => {
     const categories = plain.categories
     // ugly pointer passing for sonar
     const value = { mandatory: false, val: row && row[key] }
@@ -123,7 +125,7 @@ const processorFn = (errors, req) => {
     }
 
     // REVISIT: Convert checkInputConstraints to template mechanism
-    checkInputConstraints({ element, value: value.val, errors, pathSegments, event })
+    checkInputConstraints({ element, value: value.val, errors, path, event })
   }
 }
 
@@ -153,11 +155,11 @@ const _pick = element => {
     categories.push('associationEffective')
   }
 
-  if (element.key && !DRAFT_COLUMNS_MAP[element.name] && element.type === 'cds.UUID') {
+  if (element.key && !DRAFT_COLUMNS_MAP[element.name] && element.isUUID) {
     categories.push('uuid')
   }
 
-  if (element['@Core.MediaType']) categories.push('stream')
+  if (element['@Core.IsMediaType']) categories.push('stream')
 
   if (categories.length) return { categories }
 }
@@ -188,38 +190,34 @@ function _handler(req) {
   if (template.elements.size === 0) return
 
   const errors = []
+  const args = {
+    processFn: processorFn(errors, req),
+    template,
+    pathOptions: {
+      rowKeysGenerator: rowKeysGenerator(req.event),
+      includeKeyValues: true,
+      path: []
+    }
+  }
+  if (_isBoundAction(req)) {
+    const pathSegment = _getBoundActionBindingParameter(req)
+    const keys = req._ && req._.params && req._.params[0]
+    if (pathSegment) {
+      args.pathOptions.path.push({ key: pathSegment, url: pathSegment })
+    }
+
+    if (keys && 'IsActiveEntity' in keys) {
+      args.pathOptions.extraKeys = { IsActiveEntity: keys.IsActiveEntity }
+    }
+  }
+
   const data = getDataFromCQN(req.query) // REVISIT: req.data should point into req.query
 
   enrichDataWithKeysFromWhere(data, req, this)
 
   const arrayData = Array.isArray(data) ? data : [data]
   for (const row of arrayData) {
-    let pathSegments
-    let extraKeys
-
-    if (_isBoundAction(req)) {
-      const pathSegment = _getBoundActionBindingParameter(req)
-      const keys = req._ && req._.params && req._.params[0]
-      pathSegments = pathSegment ? [pathSegment] : []
-
-      if (keys && 'IsActiveEntity' in keys) {
-        extraKeys = { IsActiveEntity: keys.IsActiveEntity }
-      }
-    }
-
-    const args = {
-      processFn: processorFn(errors, req),
-      row,
-      template,
-      pathOptions: {
-        extraKeys,
-        rowKeysGenerator: rowKeysGenerator(req.event),
-        segments: pathSegments,
-        includeKeyValues: true
-      }
-    }
-
-    templateProcessor(args)
+    templateProcessor(Object.assign(args, { row }))
   }
 
   setDataFromCQN(req) // REVISIT: req.data should point into req.query
@@ -257,6 +255,7 @@ const _processActionFunctionRow = (row, param, key, errors, event, service) => {
 const _processActionFunction = (row, eventParams, errors, event, service) => {
   for (const key in eventParams) {
     let param = eventParams[key]
+    // .type of action/function behaves different to .type of other csn elements
     const _type = param.type
     if (!_type && param.items) param = param.items
     _processActionFunctionRow(row, param, key, errors, event, service)
@@ -292,6 +291,7 @@ function _actionFunctionHandler(req) {
   // REVISIT: find better solution, maybe compiler?
   // resolve enums like format, range, etc.
   for (const param of Object.values(eventParams)) {
+    // .type of action/function behaves different to .type of other csn elements
     const _type = param.type && this.model && this.model.definitions[param.type]
     if (_type) {
       param.enum = _type.enum

package/libx/_runtime/common/generic/sorting.js

@@ -1,8 +1,7 @@
 const cds = require('../../cds')
 const LOG = cds.log('app')
 const { getAllKeys } = require('../../cds-services/adapter/odata-v4/odata-to-cqn/utils')
-
-const DRAFT_COLUMNS = ['IsActiveEntity', 'HasDraftEntity', 'HasActiveEntity']
+const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 const _getStaticOrders = req => {
   const { target: entity, query } = req
@@ -20,7 +19,7 @@ const _getStaticOrders = req => {
   if (cds.env.features.implicit_sorting !== false && (req.target._isSingleton || query.SELECT.limit)) {
     const keys = getAllKeys(entity, true)
     for (const key of keys) {
-      if (!DRAFT_COLUMNS.includes(key) && !defaultOrders.some(o => o.by['='] === key)) {
+      if (!(key in DRAFT_COLUMNS_MAP) && !defaultOrders.some(o => o.by['='] === key)) {
         ordersFromKeys.push({ by: { '=': key } })
       }
     }

package/libx/_runtime/common/generic/temporal.js

@@ -21,14 +21,14 @@ const _getTimeDelta = (target, queryOption) => {
 
   if (
     _isDate(queryOption) ||
-    Object.values(target.elements).some(el => el['@cds.valid.from'] && el.type === 'cds.Date')
+    Object.values(target.elements).some(el => el['@cds.valid.from'] && el._type === 'cds.Date')
   ) {
     return 1000 * 60 * 60 * 24
   }
 
   if (
     _isTimestamp(queryOption) &&
-    Object.values(target.elements).some(el => el['@cds.valid.from'] && el.type === 'cds.Timestamp')
+    Object.values(target.elements).some(el => el['@cds.valid.from'] && el._type === 'cds.Timestamp')
   ) {
     return 1
   }

package/libx/_runtime/common/i18n/messages.properties

@@ -71,7 +71,7 @@ ENTITY_IS_INSERT_ONLY=Entity "{0}" is insert-only
 ENTITY_IS_READ_ONLY=Entity "{0}" is read-only
 ENTITY_IS_NOT_CRUD=Entity "{0}" is not {1}
 ENTITY_IS_NOT_CRUD_VIA_NAVIGATION=Entity "{0}" is not {1} via association "{2}"
-ENTITY_IS_AUTOEXPOSED=Entity "{0}" is not explicitely exposed as part of the service
+ENTITY_IS_AUTOEXPOSED=Entity "{0}" is not explicitly exposed as part of the service
 EXPAND_IS_RESTRICTED=Navigation property "{0}" is not allowed for expand operation
 EXPAND_COUNT_UNSUPPORTED="$count" is not supported for expand operation
 ORDERBY_LAMBDA_UNSUPPORTED="$orderby" does not support lambda

package/libx/_runtime/common/toggles/handler.js

@@ -0,0 +1,21 @@
+/*
+ * addition for feature toggles
+ */
+module.exports = cds => {
+  if (!cds.requires.toggles) return (req, res, next) => next()
+
+  return (req, res, next) => {
+    // inject features from dwc header
+    const fth = req.headers['dwc-product-configuration']
+    if (fth) {
+      const { features } = JSON.parse(Buffer.from(fth, 'base64').toString('utf-8'))
+      req.features = features
+        .filter(f => f.enabled)
+        .map(f => f.name)
+        .sort((a, b) => a.localeCompare(b))
+      Object.freeze(req.features)
+    }
+
+    next()
+  }
+}

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

@@ -29,7 +29,16 @@ const deepCopyObject = obj => {
   return clone
 }
 
+const deepCopy = data => {
+  if (Array.isArray(data)) {
+    return deepCopyArray(data)
+  }
+
+  return deepCopyObject(data)
+}
+
 module.exports = {
   deepCopyObject,
-  deepCopyArray
+  deepCopyArray,
+  deepCopy
 }

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

@@ -1,9 +1,11 @@
+/* eslint-disable complexity */
+
 const cds = require('../../cds')
 const { SELECT, INSERT, DELETE, UPDATE } = cds.ql
 const Query = require('../../../../lib/ql/Query')
 
 const { resolveView } = require('./resolveView')
-const { ensureNoDraftsSuffix } = require('./draft')
+const { ensureNoDraftsSuffix, getDraftColumnsCQNForDraft } = require('./draft')
 const { flattenStructuredSelect } = require('./structured')
 const search2cqn4sql = require('./search2cqn4sql')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
@@ -14,8 +16,12 @@ const { addToWhere } = require('../../common/utils/cqn')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { addRefToWhereIfNecessary } = require('../../../odata/afterburner')
 const { addAliasToExpression, PARENT_ALIAS, FOREIGN_ALIAS } = require('../../db/utils/generateAliases')
+const { getColumns } = require('../../cds-services/services/utils/columns')
 
-const OPERATIONS = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in']
+const OPERATIONS_MAP = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in'].reduce((acc, cur) => {
+  acc[cur] = 1
+  return acc
+}, {})
 
 const _elementFromRef = (name, entity) => {
   if (!entity) return
@@ -104,7 +110,7 @@ const convertPathExpressionToWhere = (fromClause, model, options) => {
   }
 }
 
-const _convertPathExpressionForInsertOrDelete = (intoClause, model) => {
+const _convertPathExpressionForInsert = (intoClause, model) => {
   // .into is plain string or csn entity
   if (typeof intoClause === 'string' || intoClause.name) {
     return intoClause
@@ -177,10 +183,7 @@ const _getWindColumns = (columns, groupBy, bottomTop) => {
   return [].concat(columns, _getWindowXpr(groupBy, bottomTop))
 }
 
-const _convertCountNavigation = (SELECT, model) => {
-  const entityName = SELECT.from.ref[0].id || SELECT.from.ref[0]
-  const entity = model.definitions[entityName]
-
+const _convertCountNavigation = (SELECT, target) => {
   const newWhere = []
   for (let i = 0; i < SELECT.where.length; i++) {
     const element = SELECT.where[i]
@@ -192,8 +195,8 @@ const _convertCountNavigation = (SELECT, model) => {
 
     const navigations = element.args[0].ref
     const navigationName = navigations[0].id || navigations[0]
-    if (entity.elements[navigationName]) {
-      let currentEntity = entity
+    if (target.elements[navigationName]) {
+      let currentEntity = target
       let topQuery
       let lastQuery
 
@@ -344,7 +347,7 @@ const _getWhereExistsSubSelect = (queryTarget, outerAlias, innerAlias, ref, mode
   }
 
   subSelect.where(queryTarget._relations[navName].join(innerAlias, outerAlias))
-  if (cds.env.effective.odata.structs) {
+  if (cds.env.effective.odata.structs || cds.env.features.ucsn_struct_conversion) {
     flattenStructuredSelect(subSelect, model)
   }
   subSelect.columns([{ val: 1 }])
@@ -459,7 +462,7 @@ const convertWhereExists = (query, model, options, currentTarget) => {
       }
 
       if (element.xpr) {
-        convertWhereExists({ ...query, where: element.xpr }, model, options) // > recursing into nested {xpr}
+        convertWhereExists({ ...query, where: element.xpr }, model, options, currentTarget) // > recursing into nested {xpr}
       } else if (element === 'exists' && where[i + 1].ref) {
         if (query.from) {
           query.from.as = outerAlias
@@ -551,7 +554,7 @@ const _convertOrderByIfSkip = (orderByCQN, index) => {
 
 const _convertWhereIfSkip = (whereCQN, index) => {
   whereCQN.splice(index, 1, '1 = 1')
-  OPERATIONS.includes(whereCQN[index + 1]) ? whereCQN.splice(index + 1, 2) : whereCQN.splice(index - 2, 2)
+  whereCQN[index + 1] in OPERATIONS_MAP ? whereCQN.splice(index + 1, 2) : whereCQN.splice(index - 2, 2)
 }
 
 const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, target, model, alias, processFn) => {
@@ -564,7 +567,7 @@ const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, target, model, alias, proc
 
 const _convertOrderByOrWhereIfSkip = (cqn, target, model) => {
   const alias = cqn.SELECT.from.as
-  if (cqn.SELECT.orderBy && cqn.SELECT.orderBy.length > 1) {
+  if (cqn.SELECT.orderBy && cqn.SELECT.orderBy.length) {
     _convertOrderByOrWhereCQN(cqn.SELECT.orderBy, target, model, alias, _convertOrderByIfSkip)
   }
 
@@ -659,7 +662,11 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
         // Okra always wants to have the key values, remove once we relax this requirement
         if (model.definitions[target] && model.definitions[target].keys) {
           SELECT.columns = Object.keys(model.definitions[target].keys)
-            .filter(k => !model.definitions[target].keys[k].isAssociation)
+            .filter(
+              k =>
+                !model.definitions[target].keys[k].isAssociation &&
+                !columns.find(element => element.ref && element.ref[element.ref.length - 1] === k)
+            )
             .map(k => ({ ref: [k] }))
         } else SELECT.columns = []
       }
@@ -679,6 +686,33 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
   }
 }
 
+const _convertToOneEqNullInFilter = (query, target) => {
+  // we do not handle join or union
+  if (!target) return
+
+  for (let i = 0; i < query.where.length; i++) {
+    const w = query.where[i]
+    const w2 = query.where[i + 2]
+    if (!w2 || !w.ref || w2.val !== null) {
+      continue
+    }
+    const element = target.elements[w.ref[w.ref.length - 1]]
+    if (element && element.is2one && !element.on) {
+      const foreignKeys = Object.values(element.parent.elements).filter(e => e._foreignKey4 === element.name)
+      const replacedKeys = foreignKeys.reduce((arr, e, idx) => {
+        arr.push({ ref: [...w.ref.slice(0, w.ref.length - 1), e.name] }, query.where[i + 1], query.where[i + 2])
+        if (idx < foreignKeys.length - 1) {
+          arr.push('and')
+        }
+        return arr
+      }, [])
+
+      query.where.splice(i, 3, '(', ...replacedKeys, ')')
+      i += replacedKeys.length + 2
+    }
+  }
+}
+
 // eslint-disable-next-line complexity
 const _convertSelect = (query, model, _options) => {
   const options = Object.assign(
@@ -688,6 +722,7 @@ const _convertSelect = (query, model, _options) => {
     },
     _options
   )
+
   // ensure query is ql enabled
   if (!(query instanceof Query)) Object.setPrototypeOf(query, Object.getPrototypeOf(SELECT()))
   if (query.SELECT.from && query.SELECT.from.SELECT) {
@@ -709,8 +744,14 @@ const _convertSelect = (query, model, _options) => {
 
   _convertPathExpression(query.SELECT, model, options)
   rewriteAsterisks(query, model, options)
-  if (query.SELECT.where && _isCountNavigation(query.SELECT.where)) {
-    _convertCountNavigation(query.SELECT, model)
+  if (query.SELECT.where) {
+    const entityName =
+      (query.SELECT.from.ref && (query.SELECT.from.ref[0].id || query.SELECT.from.ref[0])) || query.SELECT.from
+    const target = model.definitions[entityName]
+    if (_isCountNavigation(query.SELECT.where)) {
+      _convertCountNavigation(query.SELECT, target)
+    }
+    _convertToOneEqNullInFilter(query.SELECT, target)
   }
 
   // extract where clause if it is in column expand ref
@@ -727,7 +768,7 @@ const _convertSelect = (query, model, _options) => {
     search2cqn4sql(query, model, { ...query._searchOptions, ...{ entityName, alias } })
   }
 
-  if (query.SELECT.columns && cds.env.effective.odata.structs) {
+  if (query.SELECT.columns && (cds.env.effective.odata.structs || cds.env.features.ucsn_struct_conversion)) {
     flattenStructuredSelect(query, model)
   }
 
@@ -736,30 +777,43 @@ const _convertSelect = (query, model, _options) => {
     _createWindowCQN(query.SELECT, model)
   }
 
+  // best-effort ensure columns
+  if (options._4db && !query.SELECT.columns) {
+    let target = query._target
+    if (target && target._unresolved && typeof target.name === 'string') {
+      target = model.definitions[ensureNoDraftsSuffix(target.name)] || target
+    }
+    if (target && !target._unresolved) {
+      const cols = getColumns(target, { onlyNames: true })
+      query.columns(cols)
+      if (target._isDraftEnabled && query._target._unresolved) {
+        query.SELECT.columns.push(...getDraftColumnsCQNForDraft(target))
+        query.SELECT.columns.push({ ref: ['DraftAdministrativeData_DraftUUID'] })
+      }
+    }
+  }
+
   return query
 }
 
 const _convertInsert = (query, model, options) => {
   // resolve path expression
-  const resolvedIntoClause = _convertPathExpressionForInsertOrDelete(query.INSERT.into, model)
+  const resolvedIntoClause = _convertPathExpressionForInsert(query.INSERT.into, model)
 
   // overwrite only .into, foreign keys are already set
-  const insert = INSERT.into(resolvedIntoClause)
+  // 'a' added as placeholder since its overwritten by Object.assign below
+  const insert = INSERT.into('a')
 
   // REVISIT flatten structured types, currently its done in SQL builder
 
   // We add all previous properties ot the newly created query.
   // Reason is to not lose the query API functionality
-  Object.assign(insert.INSERT, query.INSERT, { into: resolvedIntoClause })
-
-  const targetName = insert.INSERT.into.name || insert.INSERT.into
+  Object.assign(insert.INSERT, query.INSERT, { into: { ref: [resolvedIntoClause], as: query.INSERT.into.as } })
 
-  const target = model.definitions[targetName]
+  const target = model.definitions[resolvedIntoClause]
   if (!target) return insert
 
-  const resolvedView = resolveView(insert, model, cds.db)
-
-  return resolvedView
+  return resolveView(insert, model, cds.db)
 }
 
 function _modifyNavigationInWhere(whereClause, target) {
@@ -783,6 +837,11 @@ function _modifyNavigationInWhere(whereClause, target) {
 const _plainDelete = (cqn, model) => {
   const name = cqn.DELETE.from.name || (cqn.DELETE.from.ref && cqn.DELETE.from.ref[0]) || cqn.DELETE.from
   const target = model.definitions[name]
+
+  if (cqn.DELETE.where) {
+    _convertToOneEqNullInFilter(cqn.DELETE, target)
+  }
+
   if (!target) return cqn
 
   return resolveView(cqn, model, cds.db)
@@ -804,9 +863,13 @@ const _convertDelete = (query, model, options) => {
 
   if (alias) deleet.DELETE.from = { ref: [target], as: alias }
   if (where) deleet.where(where)
-  if (query.DELETE.where) deleet.where(addAliasToExpression(query.DELETE.where, alias))
 
   const targetEntity = model.definitions[target]
+  if (query.DELETE.where) {
+    deleet.where(addAliasToExpression(query.DELETE.where, alias))
+    _convertToOneEqNullInFilter(deleet.DELETE, targetEntity)
+  }
+
   if (!targetEntity) return deleet
 
   return resolveView(deleet, model, cds.db)
@@ -815,6 +878,11 @@ const _convertDelete = (query, model, options) => {
 function _plainUpdate(cqn, model) {
   const name = cqn.UPDATE.entity.name || (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) || cqn.UPDATE.entity
   const target = model.definitions[name]
+
+  if (cqn.UPDATE.where) {
+    _convertToOneEqNullInFilter(cqn.UPDATE, target)
+  }
+
   if (!target) return cqn
 
   return resolveView(cqn, model, cds.db)
@@ -841,9 +909,12 @@ const _convertUpdate = (query, model, options) => {
 
   if (alias) update.UPDATE.entity = { ref: [target], as: alias }
   if (where) update.where(where)
-  if (query.UPDATE.where) update.where(addAliasToExpression(query.UPDATE.where, alias))
-
   const targetEntity = model.definitions[target]
+  if (query.UPDATE.where) {
+    update.where(addAliasToExpression(query.UPDATE.where, alias))
+    _convertToOneEqNullInFilter(update.UPDATE, targetEntity)
+  }
+
   if (!targetEntity) return update
 
   return resolveView(update, model, cds.db)

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

@@ -1,4 +1,5 @@
 const cds = require('../../cds')
+const resolveStructured = require('../../common/utils/resolveStructured')
 
 const { ensureNoDraftsSuffix } = require('./draft')
 
@@ -140,6 +141,7 @@ const findCsnTargetFor = (edmName, model, namespace) => {
     // probably, a combination of '_' and '.', resolving
     const finding = _findRootEntity(model, edmName, namespace)
     target = finding.target
+
     // something left in navigation path => x4 navigation
     // resolving within found entity
     if (target && finding.left > 0) {
@@ -151,10 +153,12 @@ const findCsnTargetFor = (edmName, model, namespace) => {
       }
     }
   }
+
   // remember edm <-> csn
   if (target) {
     mapping[edmName] = target
   }
+
   return mapping[edmName]
 }
 
@@ -191,7 +195,40 @@ const isRootEntity = (definitions, entityName) => {
   return true
 }
 
+function _alias2RefRest(service) {
+  for (const each of Object.values(service.entities)) {
+    each._alias2ref = {}
+    const keys = each.keys
+    for (const key in keys) {
+      if (keys[key].elements) {
+        const structKeys = resolveStructured({ structName: key, structProperties: [] }, keys[key].elements, false, true)
+        for (const structKey of structKeys) {
+          if (each._alias2ref[structKey.key] != null) {
+            // key clash, aliasing not possible
+            each._alias2ref = {}
+            return
+          }
+          each._alias2ref[structKey.key] = structKey.resolved
+        }
+      }
+    }
+  }
+}
+
+const prefixForStruct = element => {
+  const prefixes = []
+  let parent = element.parent
+  while (parent && parent.kind !== 'entity') {
+    prefixes.push(parent.name)
+    parent = parent.parent
+  }
+  return prefixes.length ? prefixes.reverse().join('_') + '_' : ''
+}
+
 function alias2ref(service, edm) {
+  if (!edm) {
+    return _alias2RefRest(service)
+  }
   const defs = edm[service.definition.name]
   for (const each of Object.values(service.entities)) {
     const def = defs[each.name.replace(service.definition.name + '.', '').replace(/\./g, '_')]
@@ -205,6 +242,29 @@ function alias2ref(service, edm) {
   }
 }
 
+function getDraftTreeRoot(entity, model) {
+  if (entity.own('__draftTreeRoot')) return entity.__draftTreeRoot
+
+  let parent
+  let current = entity
+  while (current && !current['@Common.DraftRoot.ActivationAction']) {
+    const parents = []
+    for (const k in model.definitions) {
+      const e = model.definitions[k]
+      if (e.kind !== 'entity' || !e.compositions) continue
+      for (const c in e.compositions) if (e.compositions[c].target === current.name) parents.push(e)
+    }
+    if (parents.length > 1 && parents.some(p => p !== parents[0])) {
+      // > unable to determine single parent
+      parent = undefined
+      break
+    }
+    current = parent = parents[0]
+  }
+
+  return entity.set('__draftTreeRoot', parent)
+}
+
 module.exports = {
   getEtagElement,
   findCsnTargetFor,
@@ -212,5 +272,7 @@ module.exports = {
   isRootEntity,
   getDataSubject,
   alias2ref,
-  getComp2oneParents
+  getComp2oneParents,
+  prefixForStruct,
+  getDraftTreeRoot
 }

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

@@ -11,7 +11,16 @@ module.exports = (entryOrRow, keyOrIndex, user, timestamp) => {
   else if (entryOrRow[keyOrIndex] === '$now') entryOrRow[keyOrIndex] = timestamp
   else if (entryOrRow[keyOrIndex] === '$uuid') entryOrRow[keyOrIndex] = cds.utils.uuid()
   else if (typeof entryOrRow[keyOrIndex] === 'string') {
+    // NOTE: with xsuaa, user attributes are always arrays
     const attr = entryOrRow[keyOrIndex].match(/^\$user\.(.*)/)
-    if (attr && attr.length > 1) entryOrRow[keyOrIndex] = (user.attr && user.attr[attr[1]]) || null
+    if (attr && attr.length > 1) {
+      const val = (user.attr && user.attr[attr[1]]) || null
+      if (Array.isArray(val)) {
+        if (val.length > 1) entryOrRow[keyOrIndex] = JSON.stringify(val)
+        else entryOrRow[keyOrIndex] = val.length > 0 ? val[0] : null
+      } else {
+        entryOrRow[keyOrIndex] = val
+      }
+    }
   }
 }