@sap/cds 5.7.5 → 5.8.0

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

@@ -13,54 +13,10 @@ const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
 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 PARENT_ALIAS = '_parent_'
-const PARENT_ALIAS_REGEX = new RegExp('^' + PARENT_ALIAS + '\\d*$')
-const FOREIGN_ALIAS = '_foreign_'
 const OPERATIONS = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in']
 
-// special case in lambda functions
-const _addParentAlias = (where, alias) => {
-  where.forEach(e => {
-    if (e.ref && e.ref[0].match(PARENT_ALIAS_REGEX)) {
-      e.ref[0] = alias
-    }
-  })
-}
-
-const _addAliasToElement = (e, alias) => {
-  if (e.ref) {
-    return { ref: [alias, ...e.ref] }
-  }
-
-  if (e.list) {
-    return { list: e.list.map(arg => _addAliasToElement(arg, alias)) }
-  }
-
-  if (e.func) {
-    const args = e.args.map(arg => _addAliasToElement(arg, alias))
-    return { ...e, args }
-  }
-
-  if (e.SELECT && e.SELECT.where) {
-    _addParentAlias(e.SELECT.where, alias)
-  }
-
-  if (e.xpr) {
-    return { xpr: e.xpr.map(e1 => _addAliasToElement(e1, alias)) }
-  }
-
-  return e
-}
-
-const _addAliasToExpression = (expression, alias) => {
-  if (!alias) {
-    return expression
-  }
-
-  return expression.map(e => _addAliasToElement(e, alias))
-}
-
 const _elementFromRef = (name, entity) => {
   if (!entity) return
 
@@ -112,7 +68,7 @@ const convertPathExpressionToWhere = (fromClause, model, options) => {
     const currentSelect = SELECT.from(`${currentEntityName} as ${tableAlias}`)
 
     if (fromClause.ref[i].where) {
-      currentSelect.where(_addAliasToExpression(fromClause.ref[i].where, tableAlias))
+      currentSelect.where(addAliasToExpression(fromClause.ref[i].where, tableAlias))
     }
 
     // REVISIT: Only args in last segment are handled, intermediate ones are ignored
@@ -326,35 +282,15 @@ const _createWindowCQN = (SELECT, model) => {
   delete SELECT.groupBy
 }
 
-const _isAny = element => {
-  return Array.isArray(element.ref) && element.ref.slice(-1)[0].id
+const _unshiftRefsWithNavigation = nav => el => {
+  if (el.ref) return { ref: [...nav, ...el.ref] }
+  if (el.xpr) return { xpr: el.xpr.map(_unshiftRefsWithNavigation(nav)) }
+  return el
 }
 
-const _isAll = element => {
-  const last = Array.isArray(element.ref) && element.ref.slice(-1)[0]
-  return last && last.id && last.where && last.where[0] === 'not' && last.where[1].xpr
-}
-
-// eslint-disable-next-line complexity
-const _getWhereExistsSubSelect = (cqn, where, index, model, options) => {
-  const _unshiftRefsWithNavigation = nav => el => {
-    if (el.ref) return { ref: [...nav, ...el.ref] }
-    if (el.xpr) return { xpr: el.xpr.map(_unshiftRefsWithNavigation(nav)) }
-    return el
-  }
-
-  if (!options.lambdaIteration) options.lambdaIteration = 1
-  const outerAlias =
-    (cqn.SELECT.from.ref && cqn.SELECT.from.as) ||
-    (cqn.SELECT.from.args && cqn.SELECT.from.args[0].ref && cqn.SELECT.from.args[0].as) ||
-    PARENT_ALIAS + options.lambdaIteration
-  const innerAlias = FOREIGN_ALIAS + options.lambdaIteration
-  cqn.SELECT.from.as = outerAlias
-  const ref = cqn.SELECT.from.ref || (cqn.SELECT.from.args && cqn.SELECT.from.args[0].ref)
-  const queryTarget = getEntityFromPath(getPathFromRef(ref), model)
-
-  let nav = where[index].ref.map(el => (el.id ? el.id : el))
-  const last = where[index].ref.slice(-1)[0]
+const _getWhereExistsSubSelect = (queryTarget, outerAlias, innerAlias, ref, model, options) => {
+  let nav = ref.map(el => (el.id ? el.id : el))
+  const last = ref.slice(-1)[0]
   const navName = queryTarget.elements[nav[0]] ? nav[0] : nav[nav.length - 1]
   const navElement = queryTarget.elements[navName]
 
@@ -381,17 +317,24 @@ const _getWhereExistsSubSelect = (cqn, where, index, model, options) => {
       : last.where
     : undefined
 
+  if (!innerAlias && !outerAlias) {
+    innerAlias = navElement.target
+    outerAlias = navElement.parent.name
+  }
+
   const subSelect = SELECT.from({ ref: [navElement.target], as: innerAlias })
   if (condition) {
     if (subSelect.SELECT.from.as) {
       for (let i = 0; i < condition.length; i++) {
+        if (!condition[i].ref) continue
         if (
-          condition[i].ref &&
           condition[i].ref.length > 1 &&
           condition[i].ref.every(r => typeof r === 'string') &&
           condition[i].ref[0] === navName
         ) {
           condition[i].ref[0] = subSelect.SELECT.from.as
+        } else if (condition[i].ref.length === 1) {
+          condition[i].ref.unshift(subSelect.SELECT.from.as)
         }
       }
     }
@@ -446,42 +389,9 @@ const _ensureExpandedNestedWhereExists = ({ ref }, aliases) => {
   return { ref: [acc] }
 }
 
-const _convertWhereExists = (where, cqn, model, options) => {
-  for (let i = 0; i < where.length; i++) {
-    const element = where[i]
-
-    // ensure where exists are fully expanded
-    if (
-      (element === 'exists' && where[i + 1].ref && where[i > 1 ? i - 1 : 0] !== 'not') ||
-      (element === 'not' && where[i + 1] === 'exists' && where[i + 2].ref)
-    ) {
-      const offset = element === 'not' ? 2 : 1
-      const aliases = cqn.SELECT.from.as
-        ? [cqn.SELECT.from.as]
-        : cqn.SELECT.from.join
-        ? cqn.SELECT.from.args.map(arg => arg.as)
-        : []
-      where[i + offset] = _ensureExpandedNestedWhereExists(where[i + offset], aliases)
-    }
-
-    if (element.xpr) {
-      _convertWhereExists(element.xpr, cqn, model, options) // > recursing into nested {xpr}
-    } else if (element === 'exists' && _isAny(where[i + 1])) {
-      where[i + 1] = _getWhereExistsSubSelect(cqn, where, i + 1, model, options)
-    } else if (element === 'not' && where[i + 1] === 'exists' && _isAll(where[i + 2])) {
-      where[i + 2] = _getWhereExistsSubSelect(cqn, where, i + 2, model, options)
-    }
-  }
-}
-
-const convertWhereExists = (cqn, model, options) => {
-  if (cqn.SELECT.where) _convertWhereExists(cqn.SELECT.where, cqn, model, options)
-}
-
 const _getRefIndex = (where, index) => {
   if (
     where[index - 1].ref &&
-    // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called there
     where[index - 1].ref[where[index - 1].ref.length - 1] !== 'InProcessByUser' &&
     where[index + 1].val !== undefined &&
     where[index + 1].val !== null &&
@@ -491,7 +401,6 @@ const _getRefIndex = (where, index) => {
   }
   if (
     where[index + 1].ref &&
-    // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called there
     where[index + 1].ref[where[index + 1].ref.length - 1] !== 'InProcessByUser' &&
     where[index - 1].val !== undefined &&
     where[index - 1].val !== null &&
@@ -501,6 +410,77 @@ const _getRefIndex = (where, index) => {
   }
 }
 
+const _convertWhereExistsColumn = (column, model, options, queryTarget) => {
+  const lambdaIteration = options.lambdaIteration
+  if (typeof column === 'object') {
+    if (column.SELECT) {
+      convertWhereExists(column.SELECT, model, options)
+      options.lambdaIteration = lambdaIteration
+    } else if (column.where) {
+      convertWhereExists(column, model, options, queryTarget)
+      options.lambdaIteration = lambdaIteration
+    }
+  }
+}
+
+// eslint-disable-next-line complexity
+const convertWhereExists = (query, model, options, currentTarget) => {
+  const { where, columns, expand } = query
+  let innerAlias, outerAlias, queryTarget
+  const { ref, as } =
+    (query.ref && query) ||
+    (query.from &&
+      ((query.from.ref && query.from) || (query.from.args && query.from.args[0].ref && query.from.args[0]))) ||
+    {}
+  if (!ref) return
+
+  if (!options.lambdaIteration) options.lambdaIteration = 1
+  const lambdaIteration = options.lambdaIteration
+  if (!currentTarget) {
+    queryTarget = getEntityFromPath(getPathFromRef(ref), model)
+    outerAlias = as || PARENT_ALIAS + lambdaIteration
+    innerAlias = FOREIGN_ALIAS + lambdaIteration
+  } else {
+    const element = currentTarget.elements[ref]
+    if (element && element.isAssociation) {
+      queryTarget = element._target
+    }
+  }
+
+  if (where) {
+    for (let i = 0; i < where.length; i++) {
+      const element = where[i]
+
+      // ensure where exists are fully expanded
+      if (element === 'exists' && where[i + 1].ref) {
+        const ref = query.from || query
+        const aliases = ref.as ? [ref.as] : ref.join ? ref.args.map(arg => arg.as) : []
+        where[i + 1] = _ensureExpandedNestedWhereExists(where[i + 1], aliases)
+      }
+
+      if (element.xpr) {
+        convertWhereExists({ ...query, where: element.xpr }, model, options) // > recursing into nested {xpr}
+      } else if (element === 'exists' && where[i + 1].ref) {
+        if (query.from) {
+          query.from.as = outerAlias
+        }
+        where[i + 1] = _getWhereExistsSubSelect(queryTarget, outerAlias, innerAlias, where[i + 1].ref, model, options)
+        i += 1
+      } else if (element.SELECT) {
+        convertWhereExists(element.SELECT, model, options)
+      }
+      options.lambdaIteration = lambdaIteration
+    }
+  }
+
+  if (columns) {
+    columns.forEach(column => _convertWhereExistsColumn(column, model, options, queryTarget))
+  }
+  if (expand && expand !== '*') {
+    expand.forEach(column => _convertWhereExistsColumn(column, model, options, queryTarget))
+  }
+}
+
 const _convertNotEqual = (container, partName = 'where') => {
   const where = container[partName]
 
@@ -668,7 +648,7 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
   if (alias) {
     SELECT.from.as = alias
     if (SELECT.where && alias !== prevAlias) {
-      SELECT.where = _addAliasToExpression(SELECT.where, alias)
+      SELECT.where = addAliasToExpression(SELECT.where, alias)
     }
   }
   if (columns) {
@@ -691,7 +671,7 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
   }
   // TODO: REVISIT: We need to add alias to subselect in .where, .columns, .from, ... etc
   if (where) {
-    if (options.isDraft) {
+    if (options._4fiori) {
       addToWhere({ SELECT }, where)
     } else {
       addToWhere({ SELECT }, removeIsActiveEntityRecursively(where))
@@ -703,8 +683,7 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
 const _convertSelect = (query, model, _options) => {
   const options = Object.assign(
     {
-      isDB: _options.service instanceof cds.DatabaseService,
-      isDraft: _options.draft,
+      _4db: _options.service instanceof cds.DatabaseService,
       isStreaming: query._streaming
     },
     _options
@@ -720,7 +699,7 @@ const _convertSelect = (query, model, _options) => {
   if (cds.env.features.odata_new_parser) _flattenCQN(query)
 
   // lambda functions
-  convertWhereExists(query, model, options)
+  convertWhereExists(query.SELECT, model, options)
 
   // add 'or is null' in case of '!='
   if (query.SELECT._4odata) {
@@ -729,7 +708,7 @@ const _convertSelect = (query, model, _options) => {
   }
 
   _convertPathExpression(query.SELECT, model, options)
-  rewriteAsterisks(query, model, options.isDB, options.isDraft)
+  rewriteAsterisks(query, model, options)
   if (query.SELECT.where && _isCountNavigation(query.SELECT.where)) {
     _convertCountNavigation(query.SELECT, model)
   }
@@ -780,12 +759,6 @@ const _convertInsert = (query, model, options) => {
 
   const resolvedView = resolveView(insert, model, cds.db)
 
-  if (query.INSERT.into.ref && query.INSERT.into.ref.length > 1) {
-    const copyFrom = [...query.INSERT.into.ref]
-    copyFrom.pop()
-    resolvedView._validationQuery = _convertSelect(SELECT.from({ ref: copyFrom }).columns([1]), model, options)
-  }
-
   return resolvedView
 }
 
@@ -831,7 +804,7 @@ 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))
+  if (query.DELETE.where) deleet.where(addAliasToExpression(query.DELETE.where, alias))
 
   const targetEntity = model.definitions[target]
   if (!targetEntity) return deleet
@@ -868,7 +841,7 @@ 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))
+  if (query.UPDATE.where) update.where(addAliasToExpression(query.UPDATE.where, alias))
 
   const targetEntity = model.definitions[target]
   if (!targetEntity) return update

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

@@ -6,17 +6,27 @@ const getEtagElement = entity => {
   return Object.values(entity.elements).find(element => element['@odata.etag'])
 }
 
-const _getUps = (entity, model) => {
+const getComp2oneParents = (entity, model) => {
+  if (!entity) return []
+  if (entity.own('__comp2oneParents')) return entity.__comp2oneParents
+  const invalidationFn = element => !(element.is2one && element._isCompositionEffective)
+  const comp2oneParents = _getUps(entity, model, invalidationFn)
+  return entity.set('__comp2oneParents', comp2oneParents)
+}
+
+const _getUps = (entity, model, invalidationFn) => {
+  if (entity.own('__parents')) return entity.__parents
   const ups = []
   for (const def of Object.values(model.definitions)) {
     if (def.kind !== 'entity' || !def.associations) continue
     for (const element of Object.values(def.associations)) {
       if (element.target !== entity.name || element._isBacklink) continue
       if (element.name === 'SiblingEntity') continue
+      if (invalidationFn && invalidationFn(element)) continue
       ups.push(element)
     }
   }
-  return ups
+  return entity.set('__parents', ups)
 }
 
 const _ifDataSubject = (entity, role) => {
@@ -189,5 +199,6 @@ module.exports = {
   getElementDeep,
   isRootEntity,
   getDataSubject,
-  alias2ref
+  alias2ref,
+  getComp2oneParents
 }

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

@@ -183,7 +183,24 @@ const _resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
 
   for (let i = 0; i < foreignKeys.length; i++) {
     const fk = foreignKeys[i]
-    const tk = targetKeys[i]
+    let tk
+
+    /*
+     * REVISIT: poor man's look-up of target key with fallback to targetKeys[i]
+     * Look at elements, then try to find it in query and resolve recursively until you have the full path.
+     * Once you have the full path, you can find it in the target entity.
+     * NOTE: There can be projections upon projections and renamings in every projection. -> not yet covered!!!
+     */
+    const tkCol =
+      targetKeys[i].parent.query &&
+      targetKeys[i].parent.query.SELECT.columns &&
+      targetKeys[i].parent.query.SELECT.columns.find(
+        c => c.ref && `${fk['@odata.foreignKey4']}_${c.ref.join('_')}` === fk.name
+      )
+    tk = tkCol && targetKeys.find(tk => tk.name === (tkCol.as ? tkCol.as : tkCol.ref.join('_')))
+    // with composition of aspects, the lookup fails -> we need this final fallback
+    if (!tk) tk = targetKeys[i]
+
     if (fk._isStructured) {
       i += _resolve4struct(targetKeys, fk, foreignKeyPropagations, fillChild, false, i)
     } else if (tk._isStructured) {

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

@@ -1,4 +1,5 @@
 const { where2obj } = require('./cqn')
+const { deepCopyArray } = require('./copy')
 
 function _getOnCondElements(onCond, onCondElements = []) {
   const andIndex = onCond.indexOf('and')
@@ -17,7 +18,7 @@ function _getOnCondElements(onCond, onCondElements = []) {
 function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName) {
   if (where) {
     // copy where else query will be modified
-    const whereCopy = JSON.parse(JSON.stringify(where))
+    const whereCopy = deepCopyArray(where)
     if (newWhere.length > 0) newWhere.push('and')
     newWhere.push(...whereCopy)
   }

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

@@ -24,7 +24,7 @@ const getEntityFromPath = (path, model) => {
   while (segments.length) {
     const segment = segments.shift()
     current = current.elements[segment.id || segment]
-    if (current.target) current = model.definitions[current.target]
+    if (current && current.target) current = model.definitions[current.target]
   }
   return current
 }

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

@@ -152,9 +152,15 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
   const newColumns = []
 
   columns.forEach(column => {
+    let newColumn
+    if (column.func) {
+      newColumn = { ...column }
+      newColumn.args = _newColumns(column.args, transition, service, withAlias)
+      newColumns.push(newColumn)
+      return newColumns
+    }
     const mapped = column.ref && transition.mapping.get(column.ref[0])
 
-    let newColumn
     if (mapped && mapped.ref) {
       newColumn = { ...column }
 
@@ -238,7 +244,7 @@ const _newEntries = (entries = [], transition, service) =>
 const _newWhere = (where = [], transition, tableName, alias, isSubselect = false) => {
   const newWhere = where.map(whereElement => {
     const newWhereElement = { ...whereElement }
-    if (!whereElement.ref && !whereElement.SELECT) return whereElement
+    if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
     if (whereElement.SELECT && whereElement.SELECT.where) {
       newWhereElement.SELECT.where = _newWhere(whereElement.SELECT.where, transition, tableName, alias, true)
       return newWhereElement
@@ -246,6 +252,9 @@ const _newWhere = (where = [], transition, tableName, alias, isSubselect = false
       if (newWhereElement.ref) {
         _newWhereRef(newWhereElement, transition, alias, tableName, isSubselect)
         return newWhereElement
+      } else if (newWhereElement.func) {
+        newWhereElement.args = _newWhere(newWhereElement.args, transition, tableName, alias)
+        return newWhereElement
       } else {
         return whereElement
       }
@@ -337,8 +346,7 @@ const _newSelect = (query, transitions, service) => {
   }
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
   if (newSelect.columns) {
-    const isDB = service instanceof cds.DatabaseService
-    rewriteAsterisks({ SELECT: query.SELECT }, service.model, isDB)
+    rewriteAsterisks({ SELECT: query.SELECT }, service.model, { _4db: service instanceof cds.DatabaseService })
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
   }
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)

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

@@ -30,10 +30,11 @@ const _cqlDraftColumns = target => {
   ]
 }
 
-const _expandColumn = (column, target, db) => {
+const _expandColumn = (column, target, _4db) => {
   if (!(column.ref && column.expand)) return
   const nextTarget = getNavigationIfStruct(target, column.ref)
-  if (nextTarget && nextTarget._target && nextTarget._target.elements) _rewriteAsterisks(column, nextTarget._target, db)
+  if (nextTarget && nextTarget._target && nextTarget._target.elements)
+    _rewriteAsterisks(column, nextTarget._target, _4db)
   return column
 }
 
@@ -46,32 +47,33 @@ const rewriteExpandAsterisk = (columns, target) => {
     const { expand } = columns.splice(expandAllColIdx, 1)[0]
     for (const elName in target.elements) {
       if (target.elements[elName]._target && !columns.find(col => col.expand && col.ref && col.ref[0] === elName)) {
+        if (elName === 'SiblingEntity') continue
         columns.push({ ref: [elName], expand: [...expand] })
       }
     }
   }
 }
 
-const _rewriteAsterisk = (columns, target, db, isRoot) => {
+const _rewriteAsterisk = (columns, target, _4db, isRoot) => {
   const asteriskColumnIndex = columns.findIndex(col => isAsteriskColumn(col))
   if (asteriskColumnIndex > -1) {
     columns.splice(
       asteriskColumnIndex,
       1,
-      ...getColumns(target, { db })
+      ...getColumns(target, { _4db })
         .map(c => ({ ref: [c.name] }))
         .filter(c => !columns.find(_isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
     )
   }
 }
 
-const _rewriteAsterisks = (cqn, target, db, isRoot) => {
+const _rewriteAsterisks = (cqn, target, _4db, isRoot) => {
   if (cqn.expand === '*') cqn.expand = ['*']
   const columns = cqn.expand || cqn.columns
-  _rewriteAsterisk(columns, target, db, isRoot)
+  _rewriteAsterisk(columns, target, _4db, isRoot)
   rewriteExpandAsterisk(columns, target)
   for (const column of columns) {
-    _expandColumn(column, target, db)
+    _expandColumn(column, target, _4db)
   }
   return columns
 }
@@ -83,9 +85,17 @@ const _targetOfQueryIfNotDraft = (query, model) => {
   return target
 }
 
-const rewriteAsterisks = (query, model, db = false, isDraft = false, onlyKeys = false) => {
+const rewriteAsterisks = (query, model, options) => {
+  /*
+   * REVISIT:
+   * - _4db: called on db level
+   * - _4fiori: cqn2cqn4sql called in a fiori handler
+   * this is extremely obfuscated!
+   */
+  const { _4db, _4fiori } = options
+
   if (!query.SELECT.columns || !query.SELECT.columns.length) {
-    if (isDraft || db) {
+    if (_4db || _4fiori) {
       if (
         query.SELECT.from.SET &&
         query.SELECT.from.SET.args[0] &&
@@ -101,7 +111,7 @@ const rewriteAsterisks = (query, model, db = false, isDraft = false, onlyKeys =
         for (const arg of query.SELECT.from.args) {
           const _targetName = arg.ref[0].id || arg.ref[0]
           const _target = model.definitions[ensureNoDraftsSuffix(_targetName)]
-          const columns = getColumns(_target, { db, onlyKeys })
+          const columns = getColumns(_target, { _4db })
             .filter(
               c =>
                 !query.SELECT.columns.some(
@@ -116,16 +126,20 @@ const rewriteAsterisks = (query, model, db = false, isDraft = false, onlyKeys =
       } else {
         const target = _targetOfQueryIfNotDraft(query, model)
         if (!target) return
-        query.SELECT.columns = getColumns(target, { db, onlyKeys }).map(col => ({ ref: [col.name] }))
-        if (db && target._isDraftEnabled) query.SELECT.columns.push(..._cqlDraftColumns(target))
+
+        query.SELECT.columns = getColumns(target, { _4db }).map(col => ({ ref: [col.name] }))
+        if (_4db && target._isDraftEnabled) query.SELECT.columns.push(..._cqlDraftColumns(target))
       }
     }
+
     return
   }
+
   const target = _targetOfQueryIfNotDraft(query, model)
   if (!target) return
+
   // REVISIT: Also support JOINs/SETs here
-  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, db, true)
+  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, _4db, true)
 }
 
 module.exports = {

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

@@ -18,8 +18,8 @@ const _search2cqn4sql = (query, model, options = {}) => {
 
   // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
-  // Note: $search query option combined with $filter is not currently optimized
-  if (typeof search2cqn4sql === 'function' && !query.SELECT.where) {
+  // REVISIT: $search query option combined with $count is not currently optimized
+  if (typeof search2cqn4sql === 'function' && !query.SELECT.count) {
     const search2cqnOptions = { columns, locale: options.locale }
     return search2cqn4sql(query, entity, search2cqnOptions)
   }
@@ -30,9 +30,14 @@ const _search2cqn4sql = (query, model, options = {}) => {
   query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
 }
 
-// convert $search system query option to WHERE/HAVING clause using
-// the operator LIKE or CONTAINS
-module.exports = (query, model, options) => {
-  if (query.SELECT.from.SET) return query.SELECT.from.SET.args.forEach(arg => _search2cqn4sql(arg, model, options))
+const search2cqn4sql = (query, model, options) => {
+  if (query.SELECT.from.SET) {
+    return query.SELECT.from.SET.args.forEach(arg => _search2cqn4sql(arg, model, options))
+  }
+
   return _search2cqn4sql(query, model, options)
 }
+
+// convert $search system query option to WHERE/HAVING clause using
+// the operator LIKE or CONTAINS
+module.exports = search2cqn4sql

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

@@ -1,11 +1,28 @@
-const vcapApplication = process.env.VCAP_APPLICATION && JSON.parse(process.env.VCAP_APPLICATION)
-
-module.exports = {
-  appName: vcapApplication && vcapApplication.application_name,
-  appID: vcapApplication && vcapApplication.application_id,
-  appURL:
-    vcapApplication &&
-    vcapApplication.application_uris &&
-    vcapApplication.application_uris[0] &&
-    `https://${vcapApplication.application_uris[0].replace(/^https?:\/\//, '')}`
+const cds = require('../../../../libx/_runtime/cds')
+
+const getAppMetadata = () => {
+  const appMetadata = cds.env.app
+
+  if (appMetadata) {
+    return {
+      appID: appMetadata.id,
+      appName: appMetadata.name,
+      appURL: appMetadata.url
+    }
+  }
+
+  // fallback: if the app metadata is undefined, then extract the metadata from the underlying environment (CF/Kyma/...)
+  const vcapApplication = process.env.VCAP_APPLICATION && JSON.parse(process.env.VCAP_APPLICATION)
+
+  return {
+    appID: vcapApplication && vcapApplication.application_id,
+    appName: vcapApplication && vcapApplication.application_name,
+    appURL:
+      vcapApplication &&
+      vcapApplication.application_uris &&
+      vcapApplication.application_uris[0] &&
+      `https://${vcapApplication.application_uris[0].replace(/^https?:\/\//, '')}`
+  }
 }
+
+module.exports = getAppMetadata()