@sap/cds 5.9.8 → 6.0.3

package/libx/_runtime/cds-services/adapter/odata-v4/utils/handlerUtils.js

@@ -1,97 +1,117 @@
 const cds = require('../../../../cds')
-const { SELECT } = cds.ql
 const { isCustomOperation } = require('./request')
-const expandToCQN = require('../odata-to-cqn/expandToCQN')
-const QueryOptions = require('../okra/odata-server').QueryOptions
-const { COMPLEX_PROPERTY, PRIMITIVE_PROPERTY } = require('../okra/odata-server').uri.UriResource.ResourceKind
-const { mergeJson } = require('../../../services/utils/compareJson')
-const { getColumns } = require('../../../services/utils/columns')
-
-const _selectForFunction = (selectColumns, result, opReturnType) => {
-  if (!Array.isArray(result)) result = [result]
-
-  const keys = opReturnType.keys
-
-  for (const row of result) {
-    for (const entry in row) {
-      if (keys[entry] || entry.match(/^\*/)) continue
-
-      if (!selectColumns.includes(entry)) {
-        delete row[entry]
-      }
+const {
+  uri: {
+    UriResource: {
+      ResourceKind: { COMPLEX_PROPERTY, PRIMITIVE_PROPERTY }
     }
   }
-}
+} = require('../okra/odata-server')
+const { DRAFT_COLUMNS_MAP } = require('../../../../common/constants/draft')
+const { SELECT } = cds.ql
 
-const { ensureDraftsSuffix, isDraftActivateAction } = require('../../../../fiori/utils/handler')
+const _keysOf = (row, target) => {
+  const keyElements = Object.values(target.keys || {})
+  // > singleton
+  if (!keyElements.length) return
+  const keys = {}
+  for (const key of keyElements) {
+    if (key._isAssociationStrict) continue
+    keys[key.name] = key.elements ? { val: JSON.stringify(row[key.name]) } : row[key.name]
+  }
+  return keys
+}
 
-const _expand = (model, uriInfo, options) => {
-  const expand = uriInfo.getQueryOption(QueryOptions.EXPAND)
+const getSimpleSelectCQN = (target, data, columns) => {
+  const keys = _keysOf(data, target)
+  // don't use `ql.where()` to get `where` in `from` for location header
+  const cqn = keys ? SELECT.one(target, keys) : /* singleton */ SELECT.one(target)
 
-  if (!expand || expand.length === 0) {
-    return []
+  if (columns) {
+    cqn.columns(...columns)
   }
 
-  return expandToCQN(model, expand, uriInfo.getFinalEdmType(), options)
-}
+  if (target.query && target.query.SELECT && target.query.SELECT.orderBy) {
+    cqn.SELECT.orderBy = target.query.SELECT.orderBy
+  }
 
-const _compareKeys = (first, second) => key => {
-  const val1 = first[key]
-  const val2 = second[key]
-  if (Array.isArray(val1) || Buffer.isBuffer(val1)) return val1.every((_, i) => _compareKeys(val1, val2)(i))
-  if (val1 && typeof val1 === 'object') return Object.keys(val1).every(_compareKeys(val1, val2))
-  return val1 === val2
+  return cqn
 }
 
-const _expandForFunction = async (uriInfo, result, req, srv, opReturnType) => {
-  const results = Array.isArray(result) ? result : [result]
-  const isDraft = opReturnType._isDraftEnabled
-  const isDraftActivate = isDraftActivateAction(req)
-
-  // REVISIT: what happens here exactly?
-  const selectQuery = SELECT.from(
-    isDraft && !isDraftActivate ? ensureDraftsSuffix(opReturnType.name) : opReturnType.name
-  )
-  const keys = getColumns(opReturnType, {
-    onlyNames: true,
-    removeIgnore: true,
-    filterDraft: !isDraft || isDraftActivate,
-    filterVirtual: true,
-    keysOnly: true
-  })
-  const expandCqn = _expand(srv.model, uriInfo, { rewriteAsterisks: true })
-  selectQuery.columns(expandCqn)
-  selectQuery.columns(keys)
-  for (const row of results) {
-    const where = ['(']
-    for (const key of keys) {
-      where.push({ ref: [key] }, '=', { val: row[key] }, 'and')
+/*
+ * merge CQNs
+ */
+const _mergeExpandCQNs = cqns => {
+  const cols = cqns[0].SELECT.columns
+  for (const cqn of cqns.slice(1)) {
+    for (const col of cqn.SELECT.columns) {
+      if (!col.expand) continue
+      const idx = cols.findIndex(ele => {
+        if (!col.ref) return
+        if (ele.ref) return ele.ref[0] === col.ref[0]
+        if (ele.as) return ele.as === col.ref[0]
+      })
+      if (idx === -1) {
+        cols.push(col)
+      } else {
+        const colExists = cols[idx]
+        if (colExists.as && colExists.val === null) {
+          cols[idx] = col
+          continue
+        }
+        if (col.as && col.val === null) continue
+        const mergedExpandCQN = _mergeExpandCQNs([
+          { SELECT: { columns: colExists.expand } },
+          { SELECT: { columns: col.expand } }
+        ])
+        colExists.expand = mergedExpandCQN.SELECT.columns
+      }
     }
-    where.pop() // last 'and'
-    where.push(')')
-    if (!selectQuery.SELECT.where) selectQuery.where(where)
-    else selectQuery.or(where)
   }
-  const expandedResults = await cds.tx(req).run(selectQuery)
+  return cqns[0]
+}
 
-  for (let i = 0; i < results.length; i++) {
-    const result = results[i]
-    const res = expandedResults.find(r => keys.every(_compareKeys(result, r)))
-    if (res) results[i] = mergeJson(res, result, opReturnType)
+const _getExpandColumn = (data, element) => {
+  const key = element.name
+  if (!(key in data)) return
+  data = data[key]
+  if ((Array.isArray(data) && data.length === 0) || data == null) {
+    // performance tweak, keep in mind it is only for compositions
+    return { val: null, as: key }
   }
-  return Array.isArray(result) ? results : results[0]
+  const cqn = Array.isArray(data)
+    ? _mergeExpandCQNs(data.map(data => getDeepSelect({ target: element._target, data })))
+    : getDeepSelect({ target: element._target, data })
+  return { ref: [key], expand: cqn.SELECT.columns }
 }
 
-const _cleanupResult = (result, opReturnType) => {
-  if (!Array.isArray(result)) result = [result]
-
-  for (const row of result) {
-    for (const element in opReturnType.elements) {
-      if (opReturnType.elements[element].is2many) {
-        delete row[element]
-      }
+const _getColumns = (target, data, prefix = []) => {
+  const columns = []
+  for (const each in target.elements) {
+    if (each in DRAFT_COLUMNS_MAP) continue
+    const element = target.elements[each]
+    if (element.elements && data[each]) {
+      prefix.push(element.name)
+      columns.push(..._getColumns(element, data[each], prefix))
+      prefix.pop()
+    } else if (element.isComposition && !prefix.length) {
+      const col = _getExpandColumn(data, element, prefix)
+      if (col) columns.push(col)
+    } else if (!element.isAssociation) {
+      columns.push({ ref: [...prefix, each] })
     }
   }
+  return columns
+}
+
+/*
+ * recursively builds a select cqn for deep read after write
+ * (depth determined by req.data)
+ */
+const getDeepSelect = req => {
+  let { target, data } = req
+  const columns = _getColumns(target, data)
+  return getSimpleSelectCQN(target, data, columns)
 }
 
 const getActionOrFunctionReturnType = (pathSegments, definitions) => {
@@ -108,21 +128,6 @@ const getActionOrFunctionReturnType = (pathSegments, definitions) => {
   }
 }
 
-const actionAndFunctionQueries = async (req, odataReq, result, srv, opReturnType) => {
-  _cleanupResult(result, opReturnType)
-
-  // REVISIT consider $expand columns as inline content for $select
-  if (odataReq.getQueryOptions().$select) {
-    _selectForFunction(odataReq.getQueryOptions().$select.split(','), result, opReturnType)
-  }
-
-  // REVISIT: we need to read directly from db for this, which might not be there!
-  if (odataReq.getQueryOptions().$expand && cds.db) {
-    result = await _expandForFunction(odataReq.getUriInfo(), result, req, srv, opReturnType)
-  }
-  return result
-}
-
 const resolveStructuredName = (pathSegments, index, nameArr = []) => {
   if (pathSegments[index].getKind() === COMPLEX_PROPERTY) {
     const prop = pathSegments[index].getProperty()
@@ -147,9 +152,9 @@ const isReturnMinimal = req => {
 }
 
 module.exports = {
-  _expand,
   resolveStructuredName,
-  actionAndFunctionQueries,
   getActionOrFunctionReturnType,
-  isReturnMinimal
+  isReturnMinimal,
+  getDeepSelect,
+  getSimpleSelectCQN
 }

package/libx/_runtime/cds-services/adapter/odata-v4/utils/metaInfo.js

@@ -0,0 +1,382 @@
+const cds = require('../../../../cds')
+const LOG = cds.log('odata')
+const { appURL } = require('../../../../common/utils/vcap')
+const { resolveFromSelect, targetFromPath } = require('../../../../common/utils/cqn')
+const { setEntityContained } = require('../../../../common/utils/csn')
+const { getNavigationIfStruct } = require('../../../../common/utils/structured')
+const getTemplate = require('../../../../common/utils/template')
+const templateProcessor = require('../../../../common/utils/templateProcessor')
+
+const _ignoreColumns = (columns, options) => {
+  if (!(Array.isArray(columns) && columns.some(c => c === '*' || c.as || c.ref))) return true
+  // REVISIT expand=* => list all expanded properties (as by okra's implementation)
+  // OData spec is clarified (https://github.tools.sap/cap/cds/pull/1183#pullrequestreview-1775872)
+  if (options && !options.$select && options.$expand === '*') return true
+}
+
+const _getNestedQueryOptions = (ref, expand, expandString) => {
+  const isNested = expandString.match(new RegExp(`${ref}(?=\\()`))
+  // if no "ref(" i.e. "ref" without open bracket => no nested options => shift and return
+  if (!(isNested && Array.isArray(expand) && expand.length)) return { _expand: expandString.replace(ref, '') }
+  // if "ref(" found, shift to the first position after "("
+  expandString = expandString.slice(isNested.index + ref.length + 1)
+  // i.e. we found 1 open bracket already
+  let openBrackets = 1
+  let head = ''
+  // if expandString is '$top=10;$expand=foo($select=*),bar($select=buz));$select=a,b)',
+  // then outterQueryOptions is '$top=10;$expand=foo,bar;$select=a,b'
+  let outterQueryOptions = ''
+  let nestedExpand = ''
+
+  // parse until the last even closing bracket
+  while (openBrackets) {
+    const bracketFound = expandString.match(/\(|\)/)
+    head = expandString.substring(0, bracketFound.index)
+    expandString = expandString.slice(bracketFound.index + 1)
+    nestedExpand = `${nestedExpand}${head}${bracketFound[0]}`
+    // every time we have only 1 opened bracket and find another one,
+    // everything to the left is related to outter query options
+    if (openBrackets === 1 && bracketFound[0] === '(') {
+      outterQueryOptions = `${outterQueryOptions}${head}`
+    }
+    openBrackets = bracketFound[0] === '(' ? openBrackets + 1 : openBrackets - 1
+  }
+  outterQueryOptions = `${outterQueryOptions}${head}`
+
+  // outterQueryOptions also contain $expand, but without nested options i.e. can safely be split by ";"
+  const $select = outterQueryOptions.split(';').find(s => s.startsWith('$select'))
+
+  const expandIndex = nestedExpand.indexOf('$expand=')
+  // last symbol is a pair to open bracket in "ref(" => slice(..., -1)
+  const $expand = expandIndex === -1 ? '' : nestedExpand.slice(expandIndex + '$expand='.length, -1)
+
+  return {
+    $select: $select && $select.replace('$select=', ''),
+    $expand,
+    _expand: expandString
+  }
+}
+
+const _columnsFromQuery = (columns, target, options) => {
+  // must use query.columns as it includes columns from $apply except of $apply=expand()
+  // must use query options to get nested $selects inside $expand() as they are mixed into query columns
+  // example: GET /Foo?$select=bar&$expand=bar => @odata.context: $metadata#Foo(bar,bar())
+  // REVISIT tbd if having expand column in $select could be integrated into query in grammar.pegjs
+  // REVISIT support $apply=expand()
+  if (_ignoreColumns(columns, options)) return ''
+  const context = []
+  const _select = options.$select ? options.$select.split(',') : []
+  let _expand = options.$expand || ''
+
+  const hasAsterisk = _select.indexOf('*') > -1
+  if (hasAsterisk) context.push('*')
+
+  for (const c of columns) {
+    if (!c) continue
+    const ref = c.ref && c.ref.join('/')
+    if (!hasAsterisk && !c.expand) {
+      if (c.as) context.push(c.as)
+      else if (ref) context.push(ref)
+    } else if (c.expand) {
+      if (!hasAsterisk && _select.indexOf(ref) > -1) context.push(ref)
+
+      const nextTarget = getNavigationIfStruct(target, c.ref)
+      if (nextTarget && nextTarget._target && nextTarget._target.elements) {
+        const nestedOptions = _getNestedQueryOptions(ref, c.expand, _expand)
+        _expand = nestedOptions._expand
+        context.push(`${ref}(${_columnsFromQuery(c.expand, nextTarget._target, nestedOptions)})`)
+      }
+    }
+  }
+  if (context.length) return context.join(',')
+  else if (hasAsterisk) return '*'
+  return ''
+}
+
+const _processFn = columns => {
+  return ({ row, key, element, pathSegments }) => {
+    if (!(key in row) || row[key] === null) return
+    let cur = columns
+    if (element.parent._isStructured) {
+      const prefix = pathSegments.join('/')
+      key = `${prefix}/${key}`
+    } else {
+      for (let p of pathSegments) {
+        if (!cur[p]) cur[p] = {}
+        cur = cur[p]
+      }
+    }
+    if (!cur[key]) cur[key] = {}
+  }
+}
+
+const _columnsFromData = (data, definition, service) => {
+  const columns = {}
+  const template = getTemplate('odata-context', service, definition, { pick: element => element.isAssociation })
+  if (!template || !template.elements.size) return ''
+  const arrayData = Array.isArray(data) ? data : data ? [data] : []
+  for (const row of arrayData) {
+    templateProcessor({ processFn: _processFn(columns), row, template, pathOptions: { pathSegments: [] } })
+  }
+  return _stringifyColumnsFromData(columns)
+}
+
+const _stringifyColumnsFromData = columns =>
+  Object.keys(columns)
+    .map(key => `${key}(${_stringifyColumnsFromData(columns[key])})`)
+    .join(',')
+
+const _listColumns = ({ columns, data, isUpsert, returnType, event, /* express */ _req, service }) => {
+  // query options ($select, $expand, etc) as strings
+  const queryOptions = _req.query
+  let columnsStr
+  if (!isUpsert && event in { CREATE: 1 }) {
+    columnsStr = _columnsFromData(data, returnType, service)
+  } else {
+    columnsStr = _columnsFromQuery(columns, returnType, queryOptions)
+  }
+  return columnsStr && `(${columnsStr})`
+}
+
+const _getContextUrlPrefix = ({ _req, path, target }) => {
+  if (cds.env.odata.contextAbsoluteUrl) {
+    try {
+      if (typeof cds.env.odata.contextAbsoluteUrl === 'string') {
+        const userDefinedURL = new URL(cds.env.odata.contextAbsoluteUrl, cds.env.odata.contextAbsoluteUrl).toString()
+        return (!userDefinedURL.endsWith('/') && `${userDefinedURL}/`) || userDefinedURL
+      }
+    } catch (e) {
+      e.message = `cds.odata.contextAbsoluteUrl could not be parsed as URL: ${cds.env.odata.contextAbsoluteUrl}`
+      LOG._warn && LOG.warn(e)
+    }
+    const reqURL = _req && _req.get && _req.get('host') && `${_req.protocol || 'https'}://${_req.get('host')}`
+    const baseAppURL = appURL || reqURL || ''
+    const serviceUrl = `${(_req && _req.baseUrl) || ''}/`
+    return baseAppURL && new URL(serviceUrl, baseAppURL).toString()
+  }
+  return target && target.params ? '../'.repeat(path.length) : '../'.repeat(path.length - 1)
+}
+
+const _findEdmNameFor = (definition, namespace, fullyQualified = false) => {
+  let name
+  if (!definition) return ''
+  if (definition._isStructured) {
+    const structured = [definition.name]
+    while (definition.parent) {
+      definition = definition.parent
+      structured.unshift(definition.name)
+    }
+    name = structured.join('_')
+  } else {
+    name = definition.name
+  }
+  if (!name.startsWith(`${namespace}.`)) return name
+  return fullyQualified ? name : name.replace(new RegExp(`^${namespace}\\.`), '')
+}
+
+const _opResultName = ({ service, returnType, operation, isServiceEntity }) => {
+  const { namespace } = service
+  if (returnType.name) {
+    const resultName = _findEdmNameFor(returnType, namespace)
+    if (returnType.name.startsWith(`${namespace}.`)) {
+      if (isServiceEntity) return resultName.replace(/\./g, '_')
+      return `${namespace}.${resultName.replace(/\./g, '_')}`
+    }
+    return resultName
+  }
+  // bound action / function returns inline structure
+  if (operation.parent) {
+    const boundEntityName = _findEdmNameFor(operation.parent, namespace, true).replace(/\./g, '_')
+    // REVISIT exactly this return type name is generated in edm by compiler
+    return `${namespace}.return_${boundEntityName}_${_findEdmNameFor(operation, namespace)}`
+  }
+  // unbound action / function returns inline structure
+  // REVISIT exactly this return type name is generated in edm by compiler
+  return `${namespace}.return_${_findEdmNameFor(operation, namespace, true).replace(/\./g, '_')}`
+}
+
+const _isNavToDraftAdmin = path => path.length > 1 && path[path.length - 1] === 'DraftAdministrativeData'
+
+const _getCanonicalUrl = (path, target, model) => {
+  const toManySegment =
+    path.length > 1 && Array.isArray(path[path.length - 1].where) && path[path.length - 1].where.length && path.pop()
+  if (target.params) path.push('Set')
+  const odataUrl = cds.odata.urlify({ SELECT: { from: { ref: path } } }, { model, kind: 'odata' })
+  let contextPath = odataUrl.path && odataUrl.path.match(/^([^?]*)\??/)[1]
+  if (toManySegment) {
+    contextPath += `/${toManySegment.id}`
+    path.push(toManySegment)
+  }
+  return contextPath
+}
+
+const _getReturnTypeUrl = options => {
+  const {
+    service,
+    isCollection,
+    returnType,
+    operation,
+    path,
+    target,
+    propertyName,
+    isServiceEntity,
+    isTargetComposition
+  } = options
+  const { namespace } = service
+  if (operation) {
+    const resultName = _opResultName(options)
+    if (isServiceEntity) return resultName
+    return isCollection ? `Collection(${resultName})` : resultName
+  }
+  if (isTargetComposition || propertyName || target.params || _isNavToDraftAdmin(path)) {
+    return _getCanonicalUrl(path, target, service.model)
+  }
+  if (isServiceEntity) return _findEdmNameFor(returnType, namespace).replace(/\./g, '_')
+  return isCollection ? `Collection(${returnType.name})` : returnType.name
+}
+
+const _isSingleEntity = options => {
+  const { isCollection, propertyName, returnType, isServiceEntity, isTargetComposition } = options
+  if (isCollection || (returnType && returnType._isSingleton) || propertyName) return false
+  return isServiceEntity || isTargetComposition
+}
+
+const _getContextUrl = options => {
+  if (!options.returnType) return ''
+  const contextUrlPrefix = _getContextUrlPrefix(options)
+  const returnTypeUrl = _getReturnTypeUrl(options)
+  const columnsStringified = _listColumns(options)
+  const $entity = _isSingleEntity(options) ? '/$entity' : ''
+  return `${contextUrlPrefix}$metadata#${returnTypeUrl}${columnsStringified}${$entity}`
+}
+
+const _getAdditionalContextUrl = (query, service, data, eventType, _req, isUpsert) => {
+  if (Array.isArray(query)) {
+    const additionalContextUrls = []
+    for (let i = 1; i < query.length; i++) {
+      additionalContextUrls.push(
+        _getContextUrl(
+          Object.assign(_getQueryInfo(query[i], service, data, eventType), { _req, service, data, isUpsert })
+        )
+      )
+    }
+    return additionalContextUrls
+  }
+  return []
+}
+
+const _partialCopyColumn = c => {
+  if (c.expand) {
+    const copy = { expand: Array.isArray(c.expand) ? c.expand.map(_partialCopyColumn) : c.expand }
+    if (c.ref) copy.ref = [...c.ref]
+    return copy
+  }
+  if (c.ref) return { ref: [...c.ref] }
+  if (c.as) return { as: c.as }
+  return c
+}
+
+const _partialCopyColumns = query => {
+  if (query.SELECT) {
+    // stop digging into subSelects as soon as columns found, as deeper columns will be shadowed by these
+    if (!query.SELECT.columns && query.SELECT.from.SELECT) return _partialCopyColumns(query.SELECT.from)
+    if (query.SELECT.columns) return query.SELECT.columns.map(_partialCopyColumn)
+  }
+  return []
+}
+
+const _getPathInfo = (query, model) => {
+  const queryFrom =
+    (query.SELECT && resolveFromSelect(query)) ||
+    (query.INSERT && query.INSERT.into) ||
+    (query.UPDATE && query.UPDATE.entity) ||
+    (query.DELETE && query.DELETE.from)
+  const { last, target, path, isTargetComposition } = targetFromPath(queryFrom, model)
+  const operation = (last.kind === 'action' || last.kind === 'function') && last
+  let returnType, isCollection, propertyName, unbound
+  if (operation) {
+    // last segment is bound action/function => must not be in ref
+    queryFrom && queryFrom.ref && queryFrom.ref.pop()
+    unbound = !operation.parent
+    if (operation.returns) {
+      returnType = setEntityContained(operation.returns.items || operation.returns, model)
+      isCollection = !!operation.returns.items
+    }
+    // no propertyName as operations do not (yet?) support navigation
+  } else {
+    returnType = target
+    isCollection = Array.isArray(query) || (query.SELECT && !query.SELECT.one)
+    propertyName = !isCollection && last.kind !== 'entity' && last.name
+  }
+  const isStream = last['@Core.MediaType']
+  return {
+    path,
+    target,
+    last,
+    operation,
+    returnType,
+    isCollection,
+    propertyName,
+    isStream,
+    unbound,
+    isTargetComposition
+  }
+}
+
+const _getEvent = (eventType, namespace, data, { last, target }) => {
+  if (last && (last.kind === 'action' || last.kind === 'function')) {
+    // BOUND
+    if (last.parent) eventType = last.name
+    // UNBOUND
+    eventType = last.name.replace(`${namespace}.`, '')
+  }
+  // draft
+  if (target && target._isDraftEnabled) {
+    if (eventType === 'CREATE') return 'NEW'
+    else if (eventType === 'draftEdit') return 'EDIT'
+    else if (eventType === 'UPDATE') return 'PATCH'
+    else if (eventType === 'DELETE' && data.IsActiveEntity !== true) return 'CANCEL'
+  }
+  return eventType
+}
+
+const _getQueryInfo = (query, service, data, eventType) => {
+  const { namespace, model } = service
+  const _pathInfo = _getPathInfo(Array.isArray(query) ? query[0] : query, model)
+  const { returnType } = _pathInfo
+
+  // store original columns before they are polluted by drafts, db and so on
+  const columns = _partialCopyColumns(Array.isArray(query) ? query[0] : query)
+  const isServiceEntity =
+    _findEdmNameFor(returnType, namespace) in model.entities(namespace) && !returnType._isContained
+  const event = _getEvent(eventType, namespace, data, _pathInfo)
+  return Object.assign(_pathInfo, {
+    columns,
+    isServiceEntity,
+    event
+  })
+}
+
+module.exports = (query, eventType, service, data, /* express req */ _req, isUpsert) => {
+  const queryInfo = _getQueryInfo(query, service, data, eventType)
+
+  const { isCollection, isStream, propertyName, unbound, event, returnType, isServiceEntity } = queryInfo
+
+  const contextUrl = _getContextUrl(Object.assign(queryInfo, { _req, service, data, isUpsert }))
+
+  const additionalContextUrl = _getAdditionalContextUrl(query, service, data, eventType, _req, isUpsert)
+
+  return {
+    event,
+    unbound,
+    metadata: {
+      isCollection,
+      isStream,
+      propertyName,
+      contextUrl,
+      returnType,
+      isServiceEntity,
+      additionalContextUrl
+    }
+  }
+}

package/libx/_runtime/cds-services/adapter/odata-v4/utils/oDataConfiguration.js

@@ -21,10 +21,7 @@ const _getEntitySets = (edm, namespace) => {
 const _getConcurrent = (namespace, element, csn) => {
   // autoexposed entities now used . in csn and _ in edm
   const e = findCsnTargetFor(element, csn, namespace)
-
-  return Object.values(e.elements).some(val => {
-    return val['@odata.etag']
-  })
+  return !!e._etag
 }
 
 const oDataConfiguration = (edm, csn) => {

package/libx/_runtime/cds-services/adapter/odata-v4/utils/omitValues.js

@@ -40,27 +40,26 @@ const applyOmitValuesPreference = (response, omitValuesPreference) => {
  *
  * **REVISIT**: The handling of delta payloads and instance annotations is not currently
  * implemented, as the runtime does not yet support those features.
- * In the future, you might want to use the `processArgs.pathSegments` argument for the
+ * In the future, you might want to use the `elementInfo.pathSegments` argument for the
  * implementation of delta payloads.
  *
- * @param {import('../../../../types/api').templateProcessorProcessFnArgs} processArgs
+ * @param {import('../../../../types/api').templateElementInfo} elementInfo
  * @param {import('../../../../cds-services/adapter/odata-v4/ODataRequest')} request
  * @param {Map<string, boolean> | null} omitValuesPreference
  * @param {object | undefined} previousRow
  */
-const omitValue = (processArgs, request, omitValuesPreference, previousRow) => {
+const omitValue = (elementInfo, request, omitValuesPreference, previousRow) => {
   const preferHeader = request.headers.prefer
   if (!preferHeader || !omitValuesPreference) return
 
-  const { row, key, element, isRoot } = processArgs
+  const { row, key, element } = elementInfo
   const defaultValue = element.default && element.default.val ? element.default.val : null
   const responseValue = row[key]
   const isDefaultValue = responseValue === defaultValue
 
   if (isDefaultValue) {
     // Don't omit the response value if the request is an update operation and it has changed it
-    // REVISIT: We don't have access to deep previous rows, therefore we always ignore default values in deep operations
-    if (request.event === 'UPDATE' && isRoot) {
+    if (request.event === 'UPDATE') {
       if (previousRow === undefined) return
       if (responseValue !== previousRow[key]) return
     }