@sap/cds 5.5.3 → 5.6.1

package/libx/_runtime/fiori/uiflex/handler/transformREAD.js

@@ -0,0 +1,119 @@
+const { EXT_BACK_PACK, getExtendedFields, hasExtendedEntity, isExtendedEntity, getTargetRead } = require('../utils')
+
+const _addBackPack = (columns, extFields, alias) => {
+  if (!columns) return
+
+  const hasBackPack = columns.some(
+    col => col.ref && col.ref[col.ref.length - 1] === EXT_BACK_PACK && _hasAlias(col.ref, alias)
+  )
+  if (hasBackPack) return // get out early, avoiding overhead of second check
+
+  const hasExtFields = columns.some(
+    col => col.ref && extFields.includes(col.ref[col.ref.length - 1]) && _hasAlias(col.ref, alias)
+  )
+
+  if (hasExtFields) {
+    const col = { ref: [EXT_BACK_PACK] }
+    if (alias) col.ref.unshift(alias)
+    columns.push(col)
+  }
+
+  /*
+    Removing backpack if not needed doesn't work. Probably ref copy problem.
+    if (hasBackPack && !hasExtFields) remove backpack.
+  */
+}
+
+const _hasAlias = (ref, alias) => {
+  return (ref.length === 1 && !alias) || (ref.length > 1 && ref[0] === alias)
+}
+
+const _removeExtendedFields = (columns, extFields, alias) => {
+  if (!columns) return
+
+  let i = columns.length
+  while (i--) {
+    const col = columns[i]
+    if (col.ref && extFields.includes(col.ref[col.ref.length - 1]) && _hasAlias(col.ref, alias)) {
+      columns.splice(i, 1)
+    }
+  }
+}
+
+const _transformUnion = (req, model) => {
+  // second element is active entity
+  const name = req.target.name.SET ? req.target.name.SET.args[1]._target.name : req.target.name
+  const extFields = getExtendedFields(name, model)
+  _addBackPack(req.query.SELECT.columns, extFields)
+  _removeExtendedFields(req.query.SELECT.columns, extFields)
+
+  _addBackPack(
+    req.query.SELECT.from.SET.args[0].SELECT.columns,
+    extFields,
+    req.query.SELECT.from.SET.args[0].SELECT.from.args[0].as
+  )
+  _addBackPack(req.query.SELECT.from.SET.args[1].SELECT.columns, extFields)
+  _removeExtendedFields(
+    req.query.SELECT.from.SET.args[0].SELECT.columns,
+    extFields,
+    req.query.SELECT.from.SET.args[0].SELECT.from.args[0].as
+  )
+  _removeExtendedFields(req.query.SELECT.from.SET.args[1].SELECT.columns, extFields)
+}
+
+const _getAliasedEntitiesForJoin = (args, model) => {
+  const extEntities = []
+
+  args.forEach(arg => {
+    if (arg.ref && arg.ref[0] !== 'DRAFT.DraftAdministativeData' && isExtendedEntity(arg.ref[0], model)) {
+      const extFields = getExtendedFields(arg.ref[0], model)
+      extEntities.push({ name: arg.ref[0], as: arg.as, extFields })
+    }
+
+    if (arg.join) {
+      extEntities.push(..._getAliasedEntitiesForJoin(arg.args, model))
+    }
+  })
+
+  return extEntities
+}
+
+const _transformJoin = (req, model) => {
+  const extEntities = _getAliasedEntitiesForJoin(req.query.SELECT.from.args, model)
+
+  extEntities.forEach(ext => {
+    _addBackPack(req.query.SELECT.columns, ext.extFields, ext.as)
+    _removeExtendedFields(req.query.SELECT.columns, ext.extFields, ext.as)
+  })
+}
+
+const _transformColumns = (columns, targetName, model) => {
+  if (!columns) return
+
+  const extFields = getExtendedFields(targetName, model)
+  if (extFields.length !== 0) {
+    _addBackPack(columns, extFields)
+    _removeExtendedFields(columns, extFields)
+  }
+
+  columns.forEach(col => {
+    if (col.ref && col.expand) {
+      const expTargetName = model.definitions[targetName].elements[col.ref[0]].target
+      _transformColumns(col.expand, expTargetName, model)
+    }
+  })
+}
+
+function transformExtendedFieldsREAD(req) {
+  if (!hasExtendedEntity(req, this.model)) return
+
+  const target = getTargetRead(req)
+  _transformColumns(req.query.SELECT.columns, target.name, this.model)
+
+  if (req.query.SELECT.from.SET) return _transformUnion(req, this.model) // union
+  if (req.query.SELECT.from.join) return _transformJoin(req, this.model) // join
+}
+
+module.exports = {
+  transformExtendedFieldsREAD
+}

package/libx/_runtime/fiori/uiflex/handler/transformRESULT.js

@@ -0,0 +1,43 @@
+const { EXT_BACK_PACK, hasExtendedEntity, getTargetRead } = require('../utils')
+
+const getTemplate = require('../../../common/utils/template')
+const templateProcessor = require('../../../common/utils/templateProcessor')
+
+const _pick = element => {
+  return element['@cds.extension']
+}
+
+const _processorFn = ({ row, key }) => {
+  if (row[EXT_BACK_PACK]) {
+    const extensions = JSON.parse(row[EXT_BACK_PACK])
+    Object.keys(extensions).forEach(field => {
+      row[field] = extensions[field]
+    })
+
+    delete row[EXT_BACK_PACK]
+  }
+
+  if (row[key] === undefined) {
+    row[key] = null
+  }
+}
+
+function transformExtendedFieldsRESULT(result, req) {
+  if (!result || !hasExtendedEntity(req, this.model)) return
+
+  const template = getTemplate('transform-result', this, getTargetRead(req), {
+    pick: _pick
+  })
+
+  if (template.elements.size > 0) {
+    const result_ = Array.isArray(result) ? result : [result]
+    for (const row of result_) {
+      const args = { processFn: _processorFn, row, template }
+      templateProcessor(args)
+    }
+  }
+}
+
+module.exports = {
+  transformExtendedFieldsRESULT
+}

package/libx/_runtime/fiori/uiflex/handler/transformWRITE.js

@@ -0,0 +1,62 @@
+const { EXT_BACK_PACK, getTargetWrite, isExtendedEntity } = require('../utils')
+
+const getTemplate = require('../../../common/utils/template')
+const templateProcessor = require('../../../common/utils/templateProcessor')
+
+const _pick = element => {
+  return element['@cds.extension']
+}
+
+const _processorFn = ({ row, key }) => {
+  if (row[key] === undefined) return
+
+  if (!row[EXT_BACK_PACK]) {
+    row[EXT_BACK_PACK] = '{}'
+  }
+
+  const json = JSON.parse(row[EXT_BACK_PACK])
+  json[key] = row[key]
+  row[EXT_BACK_PACK] = JSON.stringify(json)
+  delete row[key]
+}
+
+function transformExtendedFieldsCREATE(req) {
+  if (!req.target) return
+
+  const target = getTargetWrite(req.target, this.model)
+  const template = getTemplate('transform-write', this, target, { pick: _pick })
+
+  if (template && template.elements.size > 0) {
+    for (const row of req.query.INSERT.entries) {
+      const args = { processFn: _processorFn, row, template }
+      templateProcessor(args)
+    }
+  }
+}
+
+async function transformExtendedFieldsUPDATE(req) {
+  if (!req.target || !req.query.UPDATE.where) return
+
+  const target = getTargetWrite(req.target, this.model)
+  const template = getTemplate('transform-write', Object.assign(req, { model: this.model }), target, { pick: _pick })
+
+  if (template && template.elements.size > 0) {
+    // In patch case we first should obtain backpack from db.
+    // Patch can be only applied to the root.
+    if (isExtendedEntity(target.name, this.model)) {
+      const current = await SELECT.from(req.query.UPDATE.entity).columns([EXT_BACK_PACK]).where(req.query.UPDATE.where)
+
+      if (current[0]) {
+        req.data[EXT_BACK_PACK] = JSON.stringify(current[0])
+      }
+    }
+
+    const args = { processFn: _processorFn, row: req.data, template }
+    templateProcessor(args)
+  }
+}
+
+module.exports = {
+  transformExtendedFieldsCREATE,
+  transformExtendedFieldsUPDATE
+}

package/libx/_runtime/fiori/uiflex/index.js

@@ -0,0 +1,35 @@
+module.exports = async () => {
+  const cds = require('../../cds')
+  if (!cds.requires.db) return
+
+  const db = await cds.connect.to({ ...cds.requires.db, model: null, silent: true })
+  const rs = await db.read('cds_r.Extensions')
+  if (rs.length !== 0) {
+    const extensions = []
+    rs.forEach(row => extensions.push(...JSON.parse(row.csn).extensions))
+    cds.once('loaded', csn => {
+      if (cds.model) return // extend cds.model only
+      const extended = cds.compile({
+        'base.csn': cds.compile.to.json(csn),
+        'ext.csn': cds.compile.to.json({ extensions })
+      })
+      csn.definitions = extended.definitions
+    })
+  }
+  await db.disconnect()
+
+  if (cds.db) return // because of tests
+  cds.once('served', () => {
+    const { transformExtendedFieldsCREATE, transformExtendedFieldsUPDATE } = require('./handler/transformWRITE')
+    const { transformExtendedFieldsREAD } = require('./handler/transformREAD')
+    const { transformExtendedFieldsRESULT } = require('./handler/transformRESULT')
+    cds.db
+      .before('CREATE', transformExtendedFieldsCREATE)
+      .before('UPDATE', transformExtendedFieldsUPDATE)
+      .before('READ', transformExtendedFieldsREAD)
+      .after('READ', transformExtendedFieldsRESULT)
+    if ('cds_r.ExtensibilityService' in cds.services) return
+    const model = require('path').join(__dirname, 'extensibility')
+    return cds.serve(model, { silent: true }).to('odata').in(cds.app)
+  })
+}

package/libx/_runtime/fiori/uiflex/utils.js

@@ -0,0 +1,78 @@
+const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { ensureUnlocalized } = require('../../fiori/utils/handler')
+
+const EXT_BACK_PACK = 'extensions__'
+
+const getTargetRead = req => {
+  let name = ''
+  if (req.query.SELECT.from.join) {
+    // join
+    name = req.query.SELECT.from.args.find(arg => arg.ref && arg.ref[0] !== 'DRAFT.DraftAdministativeData').ref[0]
+  } else if (req.target.name.SET) {
+    // union
+    name = req.target.name.SET.args[0]._target.name
+  } else {
+    // simple select
+    name = req.target.name
+  }
+
+  return { name: ensureUnlocalized(ensureNoDraftsSuffix(name)) }
+}
+
+const getTargetWrite = (target, model) => {
+  return model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(target.name))]
+}
+
+const isExtendedEntity = (entityName, model) => {
+  // REVISIT: Dass alle unsere und auch custom handlers immer die ensureUnlocalized + ensureNoDraftsSuffix schleife drehen müssen, kann nicht sein
+  const entity = model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(entityName))]
+  return entity.elements[EXT_BACK_PACK] || Object.values(entity.elements).some(el => el['@cds.extension'])
+}
+
+const _hasExtendedEntityArgs = (args, model) => {
+  return args.find(arg => {
+    if (arg.ref) {
+      return arg.ref[0] !== 'DRAFT.DraftAdministativeData' && isExtendedEntity(arg.ref[0], model)
+    }
+
+    if (arg.join) {
+      return _hasExtendedEntityArgs(arg.args, model)
+    }
+  })
+}
+
+const hasExtendedEntity = (req, model) => {
+  if (!req.query.SELECT) return false
+
+  if (req.query.SELECT.from.join) {
+    // join
+    return _hasExtendedEntityArgs(req.query.SELECT.from.args, model)
+  } else if (req.target.name.SET) {
+    // union
+    return isExtendedEntity(req.target.name.SET.args[0]._target.name, model)
+  } else {
+    // simple select
+    return isExtendedEntity(req.target.name, model)
+  }
+}
+
+const getExtendedFields = (entityName, model) => {
+  const elements = model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(entityName))].elements
+
+  return Object.values(elements)
+    .filter(element => {
+      return element['@cds.extension']
+    })
+    .map(element => {
+      return element.name
+    })
+}
+
+module.exports = {
+  EXT_BACK_PACK,
+  getTargetRead,
+  getTargetWrite,
+  isExtendedEntity,
+  hasExtendedEntity,
+  getExtendedFields
+}

package/libx/_runtime/fiori/utils/handler.js

@@ -231,11 +231,12 @@ const addColumnAlias = (columns, alias) => {
 const getCompositionTargets = (entity, srv) => {
   if (!entity.own('_deepCompositionTargets')) {
     const _deepCompositionTargets = []
-    getTemplate('delete-drafts', srv, entity, {
+    getTemplate(undefined, srv, entity, {
       pick: element => {
         if (element.isAssociation && !element._isAssociationStrict && srv.model.definitions[element.target].drafts)
           _deepCompositionTargets.push(element.target)
-      }
+      },
+      ignore: element => !element.isAssociation || element._isAssociationStrict
     })
     entity.set('_deepCompositionTargets', new Set(_deepCompositionTargets))
   }
@@ -268,16 +269,6 @@ const getKeyProperty = keys => {
   })
 }
 
-const hasKeyInWhere = (where, target) => {
-  if (!where) {
-    return false
-  }
-
-  const key = getKeyProperty(target.keys)
-
-  return where.some(element => (element.ref ? key === element.ref[element.ref.length - 1] : false))
-}
-
 const filterKeys = keys => {
   return Object.keys(keys).filter(key => {
     return key !== 'IsActiveEntity' && !keys[key]._isAssociationStrict
@@ -301,7 +292,6 @@ module.exports = {
   adaptStreamCQN,
   replaceRefWithDraft,
   getKeyProperty,
-  hasKeyInWhere,
   filterKeys,
   getDeleteDraftAdminCqn,
   getCompositionTargets

package/libx/_runtime/fiori/utils/where.js

@@ -55,6 +55,9 @@ const _removeIsActiveEntityCondition = where => {
       i = i + 4
     } else if (where[i] === 'and' && where[i + 1] === '(' && _isActiveEntity(where[i + 2])) {
       i = i + 6
+    } else if (where[i].xpr) {
+      newWhere.push({ xpr: _removeIsActiveEntityCondition(where[i].xpr) })
+      i++
     } else {
       newWhere.push(where[i])
       i++
@@ -132,7 +135,7 @@ const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
 const removeIsActiveEntityRecursively = where => {
   for (const entry of where) {
     if (entry.SELECT && entry.SELECT.where && entry.SELECT.from.ref && !entry.SELECT.from.ref[0].endsWith('_drafts')) {
-      entry.SELECT.where = _removeIsActiveEntityCondition(entry.SELECT.where)
+      entry.SELECT.where = removeIsActiveEntityRecursively(entry.SELECT.where)
 
       if (entry.SELECT.where.length === 0) {
         delete entry.SELECT.where
@@ -144,6 +147,8 @@ const removeIsActiveEntityRecursively = where => {
 }
 
 const isActiveEntityRequested = where => {
+  if (!where) return true
+
   let i = 0
 
   while (where[i]) {

package/libx/_runtime/hana/Service.js

@@ -130,13 +130,16 @@ class HanaDatabase extends DatabaseService {
   /*
    * connection
    */
+  // eslint-disable-next-line complexity
   async acquire(arg) {
-    const tenant = (typeof arg === 'string' ? arg : arg.user.tenant) || 'anonymous'
+    // REVISIT: remove fallback arg.user.tenant with cds^6
+    const tenant = (typeof arg === 'string' ? arg : arg.tenant || (arg.user && arg.user.tenant)) || 'anonymous'
     const dbc = await pool.acquire(tenant, this.options.credentials)
 
     if (typeof arg !== 'string') {
       _setSessionContext(dbc, 'APPLICATIONUSER', arg.user.id || 'ANONYMOUS')
-      _setSessionContext(dbc, 'LOCALE', arg.user.locale || 'en')
+      // REVISIT: remove fallback arg.user.locale with cds^6
+      _setSessionContext(dbc, 'LOCALE', arg.locale || (arg.user && arg.user.locale) || 'en')
       // REVISIT: stable access
       const validFrom = (arg.context && arg.context._ && arg.context._['VALID-FROM']) || (arg._ && arg._['VALID-FROM'])
       const validto = (arg.context && arg.context._ && arg.context._['VALID-TO']) || (arg._ && arg._['VALID-TO'])

package/libx/_runtime/hana/execute.js

@@ -144,7 +144,7 @@ function _processExpand(model, dbc, cqn, user, locale, txTimestamp) {
     queries.push(_executeSelectSQL(dbc, sql, values, false))
   }
 
-  return rawToExpanded(expandQueries, queries, cqn.SELECT.one, cqn._rootEntity)
+  return rawToExpanded(expandQueries, queries, cqn.SELECT.one, cqn._target)
 }
 
 function executeSelectCQN(model, dbc, query, user, locale, txTimestamp) {

package/libx/_runtime/hana/pool.js

@@ -9,19 +9,20 @@ const _require = require('../common/utils/require')
 let im
 
 function multiTenantInstanceManager(db = cds.env.requires.db) {
-  let creds = db.credentials && (db.credentials.get_managed_instance_url || db.credentials.sm_url) && db.credentials
-  if (!creds) creds = _require('@sap/xsenv').serviceCredentials(db.vcap || { label: 'managed-hana' })
-  if (!creds) creds = _require('@sap/xsenv').serviceCredentials({ label: 'service-manager' })
-
-  if (!creds || typeof creds !== 'object' || !(creds.get_managed_instance_url || creds.sm_url)) {
-    throw Object.assign(new Error('No or malformed Managed HANA credentials'), { credentials: creds })
+  const credentials = db.credentials
+  if (
+    !credentials ||
+    typeof credentials !== 'object' ||
+    !(credentials.get_managed_instance_url || credentials.sm_url)
+  ) {
+    throw Object.assign(new Error('No or malformed db credentials'), { credentials: credentials })
   }
 
   // new instance manager
   return new Promise((resolve, reject) => {
     // REVISIT: better cache settings? current copied from old cds-hana...
     // note: may need to be low for mtx tests -> configurable?
-    const opts = Object.assign(creds, {
+    const opts = Object.assign(credentials, {
       cache_max_items: 1,
       cache_item_expire_seconds: 1
     })
@@ -37,16 +38,16 @@ function multiTenantInstanceManager(db = cds.env.requires.db) {
 }
 
 function singleTenantInstanceManager(db = cds.env.requires.db) {
-  const creds = db.credentials || _require('@sap/xsenv').serviceCredentials(db.vcap || { label: 'hana' })
+  const credentials = db.credentials
 
-  if (!creds || typeof creds !== 'object' || !creds.host) {
-    throw Object.assign(new Error('No or malformed HANA credentials'), { credentials: creds })
+  if (!credentials || typeof credentials !== 'object' || !credentials.host) {
+    throw Object.assign(new Error('No or malformed db credentials'), { credentials: credentials })
   }
 
   // mock instance manager
   return {
     get: (_, cb) => {
-      cb(null, { credentials: creds })
+      cb(null, { credentials: credentials })
     }
   }
 }

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,7 +1,6 @@
 const { computeColumnsToBeSearched } = require('../cds-services/services/utils/columns')
 const searchToLike = require('../common/utils/searchToLike')
 const { isContainsPredicateSupported, searchToContains } = require('./searchToContains')
-const { getOnCond } = require('../common/utils/generateOnCond')
 
 /**
  * Computes a CQN expression for a search query.
@@ -15,30 +14,27 @@ const { getOnCond } = require('../common/utils/generateOnCond')
  * But in contrast to the explicitly written `LIKE ?`, the parameter is already resolved to its concrete value, making
  * it better optimizable by the HANA optimizer.
  *
- * @param {object} cqn The CQN object
+ * @param {object} query The CQN object
  * @param {import('@sap/cds-compiler/lib/api/main').CSN} entity The target entity for the search query
  * @param {import('../types/api').search2cqnOptions} [options]
  * @returns {object} The modified CQN object
  */
-const search2cqn4sql = (cqn, entity, options) => {
-  const cqnSearchPhrase = cqn.SELECT.search
-  if (!cqnSearchPhrase) return cqn
+const search2cqn4sql = (query, entity, options) => {
+  const cqnSearchPhrase = query.SELECT.search
+  if (!cqnSearchPhrase) return query
 
-  let { columns = computeColumnsToBeSearched(cqn, entity), locale } = options
+  let { columns: columnsToBeSearched = computeColumnsToBeSearched(query, entity), locale } = options
   const localizedAssociation = _getLocalizedAssociation(entity)
 
   // If the localized association is defined for the target entity,
   // there should be at least one localized element.
   const resolveLocalizedTextsAtRuntime = !!localizedAssociation
 
-  if (resolveLocalizedTextsAtRuntime) {
-    // suppress the localize handler from modifying the from target
-    // The `_suppressLocalization` property is:
-    // enumerable: false (default), writable: false (default)
-    Object.defineProperty(cqn, '_suppressLocalization', { value: true })
+  // suppress the localize handler from redirecting the query's target to the localized view
+  Object.defineProperty(query, '_suppressLocalization', { value: true })
 
-    const onConditionOptions = _getOnConditionOptions(entity, localizedAssociation)
-    const onCondition = getOnCond(localizedAssociation, onConditionOptions)
+  if (resolveLocalizedTextsAtRuntime) {
+    const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
     // replace $user_locale placeholder with the user locale or the HANA session context
     onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
@@ -46,31 +42,26 @@ const search2cqn4sql = (cqn, entity, options) => {
     // inner join the target table with the _texts table (the _texts table contains
     // the translated texts)
     const localizedEntityName = localizedAssociation.target
-    cqn.join(localizedEntityName).on(onCondition)
-
-    // The inner join modifies the original SELECT ... FROM query and adds ambiguity,
-    // therefore add the table/entity name (as a preceding element) to the columns ref
-    // to prevent a SQL ambiguity error. E.g., SqlError message: column ambiguously
-    // defined.
-    cqn.SELECT.columns = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.columns)
-    columns = _unshiftEntityNameToColumnRef(entity, columns)
-    if (cqn.SELECT.groupBy) cqn.SELECT.groupBy = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.groupBy)
+    query.join(localizedEntityName).on(onCondition)
+
+    // prevent SQL ambiguity error for columns with the same name
+    columnsToBeSearched = _addAliasToColumns(query, entity, columnsToBeSearched)
   } // else --> resolve localized texts via localized view (default)
 
-  const useContains = resolveLocalizedTextsAtRuntime && isContainsPredicateSupported(cqn)
+  const useContains = isContainsPredicateSupported(query)
   let expression
 
   if (useContains) {
-    expression = searchToContains(cqnSearchPhrase, columns)
+    expression = searchToContains(cqnSearchPhrase, columnsToBeSearched)
   } else {
     // No CONTAINS optimization possible. The search implementation for localized
     // texts falls back to the LIKE predicate.
-    expression = searchToLike(cqnSearchPhrase, columns)
+    expression = searchToLike(cqnSearchPhrase, columnsToBeSearched)
   }
 
   // REVISIT: find out here if where or having must be used
-  cqn._aggregated ? cqn.having(expression) : cqn.where(expression)
-  return cqn
+  query._aggregated ? query.having(expression) : query.where(expression)
+  return query
 }
 
 const _getLocalizedAssociation = entity => {
@@ -78,28 +69,28 @@ const _getLocalizedAssociation = entity => {
   return associations && associations.localized
 }
 
-const _getOnConditionOptions = (entity, localizedAssociation) => {
-  return {
-    associationNames: [localizedAssociation.name],
-    aliases: {
-      select: localizedAssociation.target,
-      join: entity.name
-    }
-  }
-}
-
-const _unshiftEntityNameToColumnRef = (entity, columns) => {
+// The inner join modifies the original SELECT ... FROM query and adds ambiguity,
+// therefore add the table/entity name (as a preceding element) to the columns ref
+// to prevent a SQL ambiguity error.
+const _addAliasToColumns = (query, entity, columnsToBeSearched) => {
   const localizedEntityName = _getLocalizedAssociation(entity).target
   const elements = entity.elements
-
-  columns = columns.map(column => {
+  const entityName = entity.name
+  const _addAliasToColumn = (entityName, localizedEntityName, elements) => column => {
     const columnRef = column.ref
     if (!columnRef) return column
     const columnName = columnRef[0]
     const localizedElement = elements[columnName].localized
-    const entityName = localizedElement ? localizedEntityName : entity.name
-    return { ref: [entityName, columnName] }
-  })
+    const targetEntityName = localizedElement ? localizedEntityName : entityName
+    return { ref: [targetEntityName, columnName] }
+  }
+
+  query.SELECT.columns = query.SELECT.columns.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+  const columns = columnsToBeSearched.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+
+  if (query.SELECT.groupBy) {
+    query.SELECT.groupBy = query.SELECT.groupBy.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+  }
 
   return columns
 }

package/libx/_runtime/hana/searchToContains.js

@@ -64,12 +64,12 @@ const searchToContains = (cqnSearchPhrase, columns) => {
   return expression
 }
 
-const isContainsPredicateSupported = cqn => {
-  const cqnSearchPhrase = cqn.SELECT.search
+const isContainsPredicateSupported = query => {
+  const cqnSearchPhrase = query.SELECT.search
 
   // REVISIT: In the future, to further optimize search queries, you might
   // want to remove the following condition(s).
-  if (cqn._aggregated) return false
+  if (query._aggregated) return false
 
   // REVISIT: search terms starting with whitespace after a `NOT` operator does not
   // return the expected result on SAP HANA (BCP 2180256508). In addition, double

package/libx/_runtime/index.js

@@ -5,9 +5,12 @@ module.exports = {
       return this._odatav4 || (this._odatav4 = require('./cds-services/adapter/odata-v4/to'))
     },
 
-    /** @type {import('./cds-services/adapter/rest/to')} */
     get rest() {
-      return this._rest || (this._rest = require('./cds-services/adapter/rest/to'))
+      if (!this._rest) {
+        if (global.cds.env.features.rest_new_adapter) this._rest = require('../rest')
+        else this._rest = require('./cds-services/adapter/rest/to')
+      }
+      return this._rest
     }
   },
 

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -37,7 +37,7 @@ class AMQPWebhookMessaging extends MessagingService {
         // Some messaging systems don't adhere to the standard that the payload has a `data` property.
         // For these cases, we interpret the whole payload as `data`.
         let data, headers
-        if ('data' in _payload) {
+        if (typeof _payload === 'object' && 'data' in _payload) {
           data = _payload.data
           headers = { ..._payload }
           delete headers.data