@sap/cds 5.9.2 → 5.9.3

package/CHANGELOG.md

@@ -4,6 +4,17 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 5.9.3 - 2022-04-25
+
+### Fixed
+
+- Since 5.8.2 `req.target` for requests like `srv.put('/MyService.entity')` is defined, but `req.query` undefined (before `req.target` was also undefined). This was leading to accessing undefined, which has been fixed. 
+- Custom actions with names conflicting with methods from service base classes, e.g. `run()`, could lead to hard-to-detect errors. This is now detected and avoided with a warning. 
+- Typed methods for custom actions were erroneously applied to `cds.db` service, which led to server crashes, e.g. when the action was named `deploy()`. 
+- Invalid batch requests were further processed after error response was already sent to client, leading to an InternalServerError
+- Full support of `SELECT` queries with operator expressions (`xpr`)
+
+
 ## Version 5.9.2 - 2022-04-07
 
 ### Fixed

package/lib/compile/for/drafts.js

@@ -4,6 +4,6 @@ module.exports = function cds_compile_for_drafts (csn,o) {
   const unfold = cds_compile_for_drafts.unfold || (
     cds_compile_for_drafts.unfold = require ('@sap/cds-compiler/lib/transform/draft/odata')
   )
-  // csn = JSON.parse (JSON.stringify (csn)) // REVISIT: workaround for bad test setup
+  csn = JSON.parse (JSON.stringify (csn)) // REVISIT: workaround for bad test setup
   return unfold (csn,o||{})
 }

package/lib/index.js

@@ -81,7 +81,7 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
     ApplicationService: lazy => require('../libx/_runtime/cds-services/services/Service.js'),
     MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
     DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
-    RemoteService: lazy => require('../libx/_runtime/rest/service.js'),
+    RemoteService: lazy => require('../libx/_runtime/remote/Service.js'),
     AuditLogService: lazy => require('../libx/_runtime/audit/Service.js'),
     odata: require('../libx/odata'),
 

package/lib/serve/Service-methods.js

@@ -1,5 +1,12 @@
+const cds = require('..')
+const LOG = cds.log('cds-app-service-methods')
+
 
 module.exports = (srv) => {
+  if (!( //> we only support that for app services
+    srv instanceof cds.ApplicationService ||
+    srv instanceof cds.RemoteService
+  )) return
   for (const each of srv.operations) {
     add_handler_for (srv, each)
   }
@@ -16,7 +23,23 @@ const add_handler_for = (srv, def) => {
   // Use existing methods as handler implementations
   const method = srv[event]
   if (method) {
-    if (method._is_stub || method.name in srv.__proto__.__proto__) return
+    if (method._is_stub) return
+    const baseclass = (
+      srv.__proto__ === cds.ApplicationService.prototype ? srv.__proto__ :
+      srv.__proto__ === cds.RemoteService.prototype ? srv.__proto__ :
+      srv.__proto__.__proto__ // in case of class-based impls
+    )
+    if (method.name in baseclass) return LOG.warn(`WARNING: custom ${def.kind} '${event}()' conflicts with method in base class.
+
+      Cannot add typed method for custom ${def.kind} '${event}' to service impl of '${srv.name}',
+      as this would shadow equally named method in service base class '${baseclass.constructor.name}'.
+      Consider choosing a different name for your custom ${def.kind}.
+      Learn more at https://cap.cloud.sap/docs/guides/providing-services#actions-and-functions.
+    `)
+    LOG.debug (`
+      Using method ${event} from service class '${baseclass.constructor.name}'
+      as handler for ${def.kind} '${event}' in service '${srv.name}'
+    `)
     srv.on (event, function ({params,data}) {
       const args = []; if (def.parent) args.push (def.parent)
       for (let p in params) args.push(params[p])
@@ -26,6 +49,10 @@ const add_handler_for = (srv, def) => {
   }
 
   // Add stub methods to send request via typed API
+  LOG.debug (`
+    Adding typed method stub for calling custom ${def.kind} '${event}'
+    to service impl '${srv.name}'
+  `)
   const stub = srv[event] = function (...args) {
     const req = { event, data:{} }, $ = args[0]
     const target = this.entities [ $ && $.name ? $.name.match(/\w*$/)[0] : $ ]

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/deserializer/BatchRequestListBuilder.js

@@ -89,7 +89,9 @@ class BatchRequestListBuilder {
     source
       .pipe(reader)
       .on('finish', () => {
-        callback(null, this._requestInBatchList)
+        //Revisit: if statement needed in node v12 and v14, not in v16.
+        //Without it, finish callback reached in 12/14 after error handler was thrown
+        if (!source.res || !source.res.headersSent) callback(null, this._requestInBatchList)
       })
       .on('error', callback)
   }

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

@@ -30,9 +30,7 @@ const _adaptSubSelectsDraft = select => {
       if (element.SELECT) {
         _adaptSubSelectsDraft(element)
       } else if (element.xpr) {
-        for (const ele of element.xpr.filter(e => e.SELECT)) {
-          _adaptSubSelectsDraft(ele)
-        }
+        _adaptSubSelectsDraft({ SELECT: { from: {}, where: element.xpr } })
       }
     }
   }

package/libx/_runtime/common/composition/data.js

@@ -12,20 +12,13 @@ const { SELECT } = cds.ql
  * own utils
  */
 
-const _isSameEntity = (cqn, req) => {
-  const where = cqn.UPDATE.where || []
-  const persistentObj = Array.isArray(req._.partialPersistentState)
-    ? req._.partialPersistentState[0]
-    : req._.partialPersistentState
-  if (!persistentObj) {
-    // If no data was found we don't know if it is the same entity
-    return false
-  }
-  const target = getDBTable(req.target)
-  if (target.name !== (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) && target.name !== cqn.UPDATE.entity) {
-    return false
-  }
+const _isSameEntityInWhere = (where, target, persistentObj) => {
   for (let i = 0; i < where.length; i++) {
+    if (where[i].xpr) {
+      const res = _isSameEntityInWhere(where[i].xpr, target, persistentObj)
+      if (!res) return res
+      continue
+    }
     if (!where[i] || !where[i].ref || !target.elements[where[i].ref]) {
       continue
     }
@@ -40,6 +33,22 @@ const _isSameEntity = (cqn, req) => {
   return true
 }
 
+const _isSameEntity = (cqn, req) => {
+  const where = cqn.UPDATE.where || []
+  const persistentObj = Array.isArray(req._.partialPersistentState)
+    ? req._.partialPersistentState[0]
+    : req._.partialPersistentState
+  if (!persistentObj) {
+    // If no data was found we don't know if it is the same entity
+    return false
+  }
+  const target = getDBTable(req.target)
+  if (target.name !== (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) && target.name !== cqn.UPDATE.entity) {
+    return false
+  }
+  return _isSameEntityInWhere(where, target, persistentObj)
+}
+
 const _getLinksOfCompTree = compositionTree => {
   const links = []
   for (const link of [...compositionTree.backLinks, ...compositionTree.customBackLinks]) {

package/libx/_runtime/common/composition/delete.js

@@ -216,6 +216,18 @@ const resolveNavigationTarget = (cqn, ref, model) => {
   return { target, elementName }
 }
 
+const _getDataFromOncond = (onCond, parent) => {
+  return onCond.reduce((res, e) => {
+    if (e.xpr) {
+      return Object.assign(res, _getDataFromOncond(e.xpr, parent))
+    }
+    if (!e.ref || e.ref[0] !== '$$parent') return res
+    const fk = e.ref.slice(1).join('_')
+    if (!parent.keys[fk]) res[fk] = null
+    return res
+  }, {})
+}
+
 // eslint-disable-next-line complexity
 const getSetNullParentForeignKeyCQNs = async (model, req, dbQuery) => {
   const cqns = []
@@ -229,12 +241,7 @@ const getSetNullParentForeignKeyCQNs = async (model, req, dbQuery) => {
     const element = parent.elements[elementName]
     if (element && element._isCompositionEffective && element.is2one) {
       const onCond = element && parent._relations[element.name].join('$$whatever', '$$parent')
-      const data = onCond.reduce((res, e) => {
-        if (!e.ref || e.ref[0] !== '$$parent') return res
-        const fk = e.ref.slice(1).join('_')
-        if (!parent.keys[fk]) res[fk] = null
-        return res
-      }, {})
+      const data = _getDataFromOncond(onCond, parent)
       cqn.data(data)
       cqn.__4delete = true
       if (Object.keys(data).length) cqns.push(cqn)
@@ -247,12 +254,7 @@ const getSetNullParentForeignKeyCQNs = async (model, req, dbQuery) => {
     for (const element of comp2oneParents) {
       const parent = element.parent
       const onCond = parent._relations[element.name].join('$$child', '$$parent')
-      const data = onCond.reduce((res, e) => {
-        if (!e.ref || e.ref[0] !== '$$parent') return res
-        const fk = e.ref.slice(1).join('_')
-        if (!parent.keys[fk]) res[fk] = null
-        return res
-      }, {})
+      const data = _getDataFromOncond(onCond, parent)
       const columns = getColumns(parent, { _4db: true, onlyKeys: true }).map(c => ({ ref: ['$$parent', c.name] }))
       const as = query.DELETE.from.as || (query.DELETE.from.ref && query.DELETE.from.ref[0]) || query.DELETE.from
       const selectCQN = SELECT.from(`${parent.name} as $$parent`)

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

@@ -184,6 +184,7 @@ const _getBoundActionBindingParameter = req => {
 }
 
 function _handler(req) {
+  if (!req.query) return // FIXME: the code below expects req.query to be defined
   if (!req.target) return
 
   const template = getTemplate('app-input', this, req.target, { pick: _pick })

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

@@ -57,6 +57,7 @@ const _pick = element => {
 
 function _handler(req) {
   if (req.method !== 'PUT') return
+  if (!req.query) return // FIXME: the code below expects req.query to be defined
   if (!req.target) return
 
   // not for payloads with stream properties

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

@@ -16,20 +16,16 @@ const getEntityNameFromUpdateCQN = cqn => {
   return (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) || cqn.UPDATE.entity.name || cqn.UPDATE.entity
 }
 
-const addToWhere = (cqn, where) => {
-  const partial = cqn.SELECT || cqn.UPDATE || cqn.DELETE
-  if (!partial.where) partial.where = where
-  else {
-    partial.where.unshift('(')
-    partial.where.push(')', 'and', '(', ...where, ')')
-  }
-}
-
 // scope: simple wheres à la "[{ ref: ['foo'] }, '=', { val: 'bar' }, 'and', ... ]"
 function where2obj(where, target = null) {
   const data = {}
   for (let i = 0; i < where.length; i++) {
     const whereEl = where[i]
+
+    if (whereEl.xpr) {
+      where2obj(whereEl.xpr, target, data)
+    }
+
     const colName = whereEl.ref && whereEl.ref[whereEl.ref.length - 1]
     // optional validation if target is passed
     if (target) {
@@ -85,7 +81,6 @@ function isPathToDraft(path, model) {
 }
 
 module.exports = {
-  addToWhere,
   getEntityNameFromDeleteCQN,
   getEntityNameFromUpdateCQN,
   where2obj,

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

@@ -12,7 +12,6 @@ const { getEntityNameFromCQN } = require('./entityFromCqn')
 const getError = require('../../common/error')
 const { rewriteAsterisks } = require('./rewriteAsterisks')
 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')
@@ -240,11 +239,14 @@ const _convertCountNavigation = (SELECT, target) => {
 }
 
 const _addTableName = (where, tableName) => {
-  return where.map(ref => {
-    if (ref.ref) {
-      ref.ref.unshift(tableName)
+  return where.map(whereEl => {
+    if (whereEl.xpr) {
+      return { xpr: _addTableName(whereEl.xpr, tableName) }
     }
-    return ref
+    if (whereEl.ref) {
+      whereEl.ref.unshift(tableName)
+    }
+    return whereEl
   })
 }
 
@@ -444,10 +446,7 @@ const convertWhereExists = (query, model, options, currentTarget) => {
     outerAlias = as || PARENT_ALIAS + lambdaIteration
     innerAlias = FOREIGN_ALIAS + lambdaIteration
   } else {
-    const element = currentTarget.elements[ref]
-    if (element && element.isAssociation) {
-      queryTarget = element._target
-    }
+    queryTarget = getEntityFromPath({ ref }, currentTarget)
   }
 
   if (where) {
@@ -562,6 +561,10 @@ const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, target, model, alias, proc
   const queryTarget = model.definitions[ensureNoDraftsSuffix(target)]
 
   orderByOrWhereCQN.forEach((el, index) => {
+    if (el.xpr) {
+      _convertOrderByOrWhereCQN(el.xpr, target, model, alias, processFn)
+      return
+    }
     if (el.ref && _skip(queryTarget, el.ref, alias, model)) processFn(orderByOrWhereCQN, index)
   })
 }
@@ -603,86 +606,56 @@ const _convertRefWhereInExpand = columns => {
   }
 }
 
-const _flattenCQN = cqn => {
-  if (Array.isArray(cqn)) cqn.forEach(_flattenCQN)
-  else if (cqn) {
-    if (cqn.SELECT) _flattenCQN(cqn.SELECT)
-    if (cqn.from) _flattenCQN(cqn.from)
-    if (cqn.ref) _flattenCQN(cqn.ref)
-    if (cqn.SET) _flattenCQN(cqn.SET)
-    if (cqn.args) _flattenCQN(cqn.args)
-    if (cqn.columns) _flattenCQN(cqn.columns)
-    if (cqn.expand) _flattenCQN(cqn.expand)
-    if (cqn.where) _flattenXpr(cqn.where)
-    if (cqn.having) _flattenXpr(cqn.having)
-  }
-}
-
-const _flattenXpr = cqn => {
-  if (!Array.isArray(cqn)) {
-    if (cqn.xpr) cqn = cqn.xpr
-    return
-  }
-
-  let idx = cqn.findIndex(el => el.xpr)
-  while (idx > -1) {
-    cqn.splice(idx, 1, '(', ...cqn[idx].xpr, ')')
-    idx = cqn.findIndex(el => el.xpr)
+const _convertPathExpression = (query, model, options = {}) => {
+  const prevAlias = query.SELECT.from.as
+  for (const whereEl of query.SELECT.where || []) {
+    if (typeof whereEl === 'object' && whereEl.SELECT) _convertPathExpression(whereEl, model)
   }
-
-  cqn.forEach(_flattenCQN)
-}
-
-const _convertPathExpression = (SELECT, model, options = {}) => {
-  const prevAlias = SELECT.from.as
-  for (const whereEl of SELECT.where || []) {
-    if (typeof whereEl === 'object' && whereEl.SELECT) _convertPathExpression(whereEl.SELECT, model)
-  }
-  const conversion = convertPathExpressionToWhere(SELECT.from, model, options)
+  const conversion = convertPathExpressionToWhere(query.SELECT.from, model, options)
   if (!conversion) return
   const { target, alias, where, cardinality, columns, args } = conversion
 
   // REVISIT: It's not possible to just change the reference (i.e. SELECT.from.ref = [target])
   // as many parts of our code base still refer to SELECT.from (e.g. authorization)
   if (args) {
-    SELECT.from = { ref: [{ id: target, args }] }
+    query.SELECT.from = { ref: [{ id: target, args }] }
   } else {
-    SELECT.from = { ref: [target] }
+    query.SELECT.from = { ref: [target] }
   }
   if (alias) {
-    SELECT.from.as = alias
-    if (SELECT.where && alias !== prevAlias) {
-      SELECT.where = addAliasToExpression(SELECT.where, alias)
+    query.SELECT.from.as = alias
+    if (query.SELECT.where && alias !== prevAlias) {
+      query.SELECT.where = addAliasToExpression(query.SELECT.where, alias)
     }
   }
   if (columns) {
     // TODO: use streaming as outer property
-    if (options.isStreaming) SELECT.columns = columns
+    if (options.isStreaming) query.SELECT.columns = columns
     else {
-      if (!SELECT.columns) {
+      if (!query.SELECT.columns) {
         // 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)
+          query.SELECT.columns = Object.keys(model.definitions[target].keys)
             .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 = []
+        } else query.SELECT.columns = []
       }
-      SELECT.columns.push(...columns)
+      query.SELECT.columns.push(...columns)
     }
   }
   if (cardinality && cardinality.max === 1) {
-    SELECT.one = true
+    query.SELECT.one = true
   }
   // TODO: REVISIT: We need to add alias to subselect in .where, .columns, .from, ... etc
   if (where) {
     if (options._4fiori) {
-      addToWhere({ SELECT }, where)
+      query.where(where)
     } else {
-      addToWhere({ SELECT }, removeIsActiveEntityRecursively(where))
+      query.where(removeIsActiveEntityRecursively(where))
     }
   }
 }
@@ -693,6 +666,9 @@ const _convertToOneEqNullInFilter = (query, target) => {
 
   for (let i = 0; i < query.where.length; i++) {
     const w = query.where[i]
+    if (w.xpr) {
+      _convertToOneEqNullInFilter({ where: w.xpr }, target)
+    }
     const w2 = query.where[i + 2]
     if (!w2 || !w.ref || w2.val !== null) {
       continue
@@ -716,10 +692,6 @@ const _convertToOneEqNullInFilter = (query, target) => {
 
 // eslint-disable-next-line complexity
 const _convertSelect = (query, model, _options) => {
-  const { _initial } = _options
-  if (_initial) {
-    delete _options._initial
-  }
   const options = Object.assign(
     {
       _4db: _options.service instanceof cds.DatabaseService,
@@ -744,7 +716,7 @@ const _convertSelect = (query, model, _options) => {
     _convertNotEqual(query.SELECT, 'having')
   }
 
-  _convertPathExpression(query.SELECT, model, options)
+  _convertPathExpression(query, model, options)
   rewriteAsterisks(query, model, options)
   if (query.SELECT.where) {
     const entityName =
@@ -795,9 +767,6 @@ const _convertSelect = (query, model, _options) => {
     }
   }
 
-  // temporary workaround for xpr - cds v5.9.2 only
-  if (_initial) _flattenCQN(query)
-
   return query
 }
 
@@ -937,7 +906,7 @@ const _convertUpdate = (query, model, options) => {
  */
 const cqn2cqn4sql = (query, model, options = { suppressSearch: false }) => {
   if (query.SELECT) {
-    return _convertSelect(query, model, Object.assign(options, { _initial: true }))
+    return _convertSelect(query, model, options)
   }
 
   if (query.UPDATE) {

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

@@ -1,24 +1,44 @@
-const _getSubOns = element => {
-  // this only works for on conds with `and`, once we support `or` this needs to be adjusted
-  const newOn = element.on ? element.on.filter(e => e !== '(' && e !== ')') : []
-  const subOns = []
+const _normalizedRef = o => (o && o.ref && o.ref.length > 1 && o.ref[0] === '$self' ? { ref: o.ref.slice(1) } : o)
+
+const _sub = (newOn, subOns = []) => {
   let currArr = []
 
-  for (const onEl of newOn) {
-    if (currArr.length === 0) subOns.push(currArr)
+  for (let i = 0; i < newOn.length; i++) {
+    const onEl = newOn[i]
+
+    if (onEl === 'or') {
+      // abort condition for or
+      subOns.push([])
+      return subOns
+    }
+    if (onEl.xpr) {
+      _sub(onEl.xpr, subOns)
+      // after xpr there usually should be and/or
+      i++
+      continue
+    }
+    if (currArr.length === 0) {
+      subOns.push(currArr)
+    }
     if (onEl !== 'and') currArr.push(onEl)
     else {
       currArr = []
     }
   }
 
+  return subOns
+}
+
+const _getSubOns = element => {
+  const newOn = element.on || []
+  const subOns = _sub(newOn)
+
   for (const subOn of subOns) {
     // We don't support anything else than
     // A = B AND C = D AND ...
     if (subOn.length !== 3) return []
   }
-
-  return subOns
+  return subOns.map(subOn => subOn.map(ref => _normalizedRef(ref)))
 }
 
 const _parentFieldsFromSimpleOnCond = (element, subOn) => {

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

@@ -17,14 +17,14 @@ const getPathFromRef = ref => {
 /*
  * returns the target entity for the given path
  */
-const getEntityFromPath = (path, model) => {
-  let current = { elements: model.definitions }
+const getEntityFromPath = (path, def) => {
+  let current = def.definitions ? { elements: def.definitions } : def
   path = typeof path === 'string' ? cds.parse.path(path) : path
   const segments = [...path.ref]
   while (segments.length) {
     const segment = segments.shift()
     current = current.elements[segment.id || segment]
-    if (current && current.target) current = model.definitions[current.target]
+    if (current && current.target) current = current._target
   }
   return current
 }

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

@@ -243,6 +243,9 @@ const _newEntries = (entries = [], transition, service) =>
 
 const _newWhere = (where = [], transition, tableName, alias, isSubselect = false) => {
   const newWhere = where.map(whereElement => {
+    if (whereElement.xpr) {
+      return { xpr: _newWhere(whereElement.xpr, transition, tableName, alias, isSubselect) }
+    }
     const newWhereElement = { ...whereElement }
     if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
     if (whereElement.SELECT && whereElement.SELECT.where) {

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

@@ -47,7 +47,8 @@ const _flattenStructuredInExpand = (column, { _target: expandedEntity }) => {
   if (orderBy) {
     column.orderBy = orderBy
   }
-  column.where = flattenStructuredWhereHaving(column.where, expandedEntity)
+  const columnWhere = flattenStructuredWhereHaving(column.where, expandedEntity)
+  if (columnWhere) column.where = columnWhere
   column.expand = column.expand.filter(e => !e.ref || !toBeDeleted.includes(e.ref[e.ref.length - 1]))
   column.expand.push(...flattenedElements)
 }
@@ -205,6 +206,10 @@ const flattenStructuredWhereHaving = (filterArray, csnEntity, model) => {
 
   const newFilterArray = []
   for (let i = 0; i < filterArray.length; i++) {
+    if (filterArray[i].xpr) {
+      newFilterArray.push({ xpr: flattenStructuredWhereHaving(filterArray[i].xpr, csnEntity, model) })
+      continue
+    }
     if (filterArray[i + 1] in OPERATIONS_MAP) {
       const refElement = filterArray[i].ref ? filterArray[i] : filterArray[i + 2]
 

package/libx/_runtime/db/Service.js

@@ -38,6 +38,16 @@ class DatabaseService extends cds.Service {
     // REVISIT: how to generic handler registration?
   }
 
+  /** Database services don't support custom-defined operations */
+  operations() {
+    return []
+  }
+
+  /** Database services don't support custom-defined events */
+  events() {
+    return []
+  }
+
   /*
    * tx
    */

package/libx/_runtime/db/expand/expand-v2.js

@@ -79,16 +79,24 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth, o
   return previousResult
 }
 
+const _fkForOnCOnd = (onCond, requiredFks) => {
+  for (const ele of onCond) {
+    if (ele.xpr) {
+      _fkForOnCOnd(ele.xpr, requiredFks)
+    }
+
+    if (ele.ref && ele.ref[0] === 'parent') {
+      requiredFks.add(ele.ref.slice(1).join('_'))
+    }
+  }
+}
+
 const _foreignKeysOfTopLevelNavs = (entity, options) => {
   const requiredFks = new Set()
   for (const nav in entity._associations) {
     if (options.onlyCompositions && entity._associations[nav]._isAssociationEffective) continue
     const onCond = entity._relations[nav].join('child', 'parent')
-    for (const ele of onCond) {
-      if (ele.ref && ele.ref[0] === 'parent') {
-        requiredFks.add(ele.ref.slice(1).join('_'))
-      }
-    }
+    _fkForOnCOnd(onCond, requiredFks)
   }
   return [...requiredFks]
 }

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -395,6 +395,9 @@ class JoinCQNFromExpanded {
    */
   _adaptWhereSELECT(aliasedTable, where, tableAlias) {
     return where.map(element => {
+      if (element.xpr) {
+        return { xpr: this._adaptWhereSELECT(aliasedTable, element.xpr, tableAlias) }
+      }
       return this._elementAliasNeedsReplacement(element, aliasedTable)
         ? Object.assign({}, element, { ref: [tableAlias, element.ref[1]] })
         : element
@@ -870,13 +873,21 @@ class JoinCQNFromExpanded {
     const aliases = this._getAliases(subSelectColumns)
     const on = entity._relations[tableAlias === columns[0] ? columns.slice(1) : columns].join(tableAlias, parentAlias)
 
+    this._adjustAliases(on, aliases)
+
+    return on
+  }
+
+  _adjustAliases(on, aliases) {
     for (const element of on) {
+      if (element.xpr) {
+        this._adjustAliases(element.xpr, aliases)
+        continue
+      }
       if (element.ref && aliases[element.ref[0]] && aliases[element.ref[0]][element.ref[1]]) {
         element.ref[1] = aliases[element.ref[0]][element.ref[1]]
       }
     }
-
-    return on
   }
 
   _addJoinKeyColumnsToUnion(args, on, parentAlias) {
@@ -899,23 +910,27 @@ class JoinCQNFromExpanded {
   }
 
   _addColumns(columns, on, parentAlias, withAlias = false) {
-    const keyColumns = on
-      .filter(entry => {
-        return (
-          entry.ref &&
-          entry.ref[0] === parentAlias &&
-          !columns.some(column => column.ref && column.ref[column.ref.length - 1] === entry.ref[1])
+    for (const entry of on) {
+      if (entry.xpr) {
+        this._addColumns(columns, entry.xpr, parentAlias, withAlias)
+        continue
+      }
+      if (
+        entry.ref &&
+        entry.ref[0] === parentAlias &&
+        !columns.some(column => column.ref && column.ref[column.ref.length - 1] === entry.ref[1])
+      ) {
+        columns.push(
+          withAlias
+            ? { ref: [parentAlias, entry.ref[1]], as: `${parentAlias}_${entry.ref[1]}` }
+            : { ref: [entry.ref[1]] }
         )
-      })
-      .map(entry =>
-        withAlias ? { ref: [parentAlias, entry.ref[1]], as: `${parentAlias}_${entry.ref[1]}` } : { ref: [entry.ref[1]] }
-      )
-    if (keyColumns.length === 0) return
-    columns.push(...keyColumns)
+      }
+    }
   }
 
   /**
-   * Add an unique alias to each column, to avoid ambiguity.
+   * Add a unique alias to each column, to avoid ambiguity.
    * Add this information to the post process config.
    *
    * @param {object} column
@@ -1318,6 +1333,26 @@ class JoinCQNFromExpanded {
     return newObj
   }
 
+  _getFilterColumns(readToOneCQN, on, parentAlias) {
+    const columns = []
+    const outerColumns = []
+
+    for (const entry of on) {
+      if (entry.xpr) {
+        const { columns: cols, outerColumns: outerCols } = this._getFilterColumns(readToOneCQN, entry.xpr, parentAlias)
+        columns.push(...cols)
+        outerColumns.push(...outerCols)
+        continue
+      }
+      if (typeof entry === 'object' && entry.ref && entry.ref[0] === 'filterExpand') {
+        columns.push(this._getColumnObjectForFilterExpand(readToOneCQN, parentAlias, entry.ref[1]))
+        outerColumns.push({ ref: [entry.ref[1]] })
+      }
+    }
+
+    return { columns, outerColumns }
+  }
+
   /**
    * Reduce column list to column(s) needed to merge the result into one.
    *
@@ -1329,22 +1364,13 @@ class JoinCQNFromExpanded {
    * @private
    */
   _getFilterExpandCQN(readToOneCQN, on, parentAlias, keyObject) {
-    const columns = []
-
-    const outerColumns = []
-
-    for (const entry of on) {
-      if (typeof entry === 'object' && entry.ref && entry.ref[0] === 'filterExpand') {
-        columns.push(this._getColumnObjectForFilterExpand(readToOneCQN, parentAlias, entry.ref[1]))
-        outerColumns.push({ ref: [entry.ref[1]] })
-      }
-    }
-
     const keys = Object.keys(keyObject).filter(
       key =>
         key !== 'IsActiveEntity' && !keyObject[key].is2one && !keyObject[key].is2many && !keyObject[key]._isStructured
     )
 
+    const { columns, outerColumns } = this._getFilterColumns(readToOneCQN, on, parentAlias)
+
     for (const key of keys) {
       if (!columns.map(entry => entry.as).includes(key)) {
         columns.push(this._getColumnObjectForFilterExpand(readToOneCQN, parentAlias, key))
@@ -1455,6 +1481,10 @@ class JoinCQNFromExpanded {
     this._addColumNames(entity, parentAlias, columnNames)
 
     for (const entry of on) {
+      if (entry.xpr) {
+        columns.push(...this._getJoinColumnsFromOnAddToMapping(mapping, parentAlias, entry.xpr, entity))
+        continue
+      }
       if (typeof entry === 'object' && entry.ref && entry.ref[0] !== 'filterExpand') {
         const as = entry.ref.join('_')
         columns.push({

package/libx/_runtime/db/utils/generateAliases.js

@@ -20,6 +20,11 @@ const _redirectXpr = (xpr, aliasMap) => {
       return
     }
 
+    if (element.xpr) {
+      _redirectXpr(element.xpr, aliasMap)
+      return
+    }
+
     if (element.func) {
       _redirectXpr(element.args, aliasMap)
       return
@@ -98,6 +103,10 @@ const generateAliases = query => {
 
 const _addParentAlias = (where, alias) => {
   where.forEach(e => {
+    if (e.xpr) {
+      _addParentAlias(e.xpr, alias)
+      return
+    }
     if (e.ref && e.ref[0].match(PARENT_ALIAS_REGEX)) {
       e.ref[0] = alias
     }

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

@@ -21,6 +21,7 @@ const _processorFn = ({ row, key }) => {
 }
 
 function transformExtendedFieldsCREATE(req) {
+  if (!req.query) return // FIXME: the code below expects req.query to be defined
   if (!req.target) return
   if (!req.query.INSERT.entries) return // REVISIT: breaks at cds.deploy -> should anyways not kick in during cds.deploy
 

package/libx/_runtime/fiori/generic/read.js

@@ -19,9 +19,18 @@ const { deleteCondition, readAndDeleteKeywords, removeIsActiveEntityRecursively
 const { getColumns } = require('../../cds-services/services/utils/columns')
 const { adaptStreamCQN } = require('../../cds-services/adapter/odata-v4/utils/stream')
 
+const _findSubselect = where => {
+  return where.find((e, i) => {
+    if (e.xpr) {
+      return _findSubselect(e.xpr)
+    }
+    return e.SELECT && where[i - 1] === 'exists'
+  })
+}
+
 const _findRootSubSelectFor = query => {
   if (query.SELECT.where) {
-    const subSelect = query.SELECT.where.find((e, i) => e.SELECT && query.SELECT.where[i - 1] === 'exists')
+    const subSelect = _findSubselect(query.SELECT.where)
     return subSelect ? _findRootSubSelectFor(subSelect) : query
   }
   return query
@@ -422,8 +431,8 @@ const _allActive = (req, columns, model) => {
     cqn.leftJoin(ensureDraftsSuffix(table.ref[0]) + ' as drafts').on(`${table.as}.${ids[0]} = drafts.${ids[0]}`)
 
     for (let i = 1; i < ids.length; i++) {
-      // REVISIT: this is extremely expensive as it repeatedly invokes the compiler's cds.parse.expr -> better extend plain CQN yourself here
-      cqn.and(`${table.as}.${ids[i]} = drafts.${ids[i]}`)
+      // this 'and' belongs to the join condition and is not a where and
+      cqn.and({ ref: [table.as, ids[i]] }, '=', { ref: ['drafts', ids[i]] })
     }
   }
 
@@ -557,27 +566,38 @@ const _alignAliasForUnion = (table, as, select) => {
   return select
 }
 
-const _findJoinInQuery = (query, parentAlias) => {
-  const targetAlias = query.SELECT.from.as
-  const isTargetRef = el => targetAlias && el.ref && el.ref.length > 1 && el.ref[0] === targetAlias
-  if (query.SELECT && query.SELECT.where)
-    return query.SELECT.where.reduce((links, el, idx, where) => {
-      if (el.ref && el.ref[0] === parentAlias && el.ref[el.ref.length - 1] !== 'IsActiveEntity') {
-        if (where[idx - 1] && where[idx - 1] === '=' && isTargetRef(where[idx - 2])) {
-          if (links.length) links.push('and')
-          links.push(el, '=', where[idx - 2])
-        }
-        if (where[idx + 1] && where[idx + 1] === '=' && isTargetRef(where[idx + 2])) {
-          if (links.length) links.push('and')
-          links.push(el, '=', where[idx + 2])
-        }
+const isTargetRef = (el, targetAlias) => targetAlias && el.ref && el.ref.length > 1 && el.ref[0] === targetAlias
+
+const _joinFromWhere = (where, parentAlias, targetAlias) => {
+  return where.reduce((links, el, idx, where) => {
+    if (el.xpr) {
+      const result = _joinFromWhere(el.xpr, parentAlias, targetAlias)
+      if (result.length) {
+        if (links.length) links.push('and')
+        links.push(...result)
       }
       return links
-    }, [])
-  return []
+    }
+
+    if (el.ref && el.ref[0] === parentAlias && el.ref[el.ref.length - 1] !== 'IsActiveEntity') {
+      if (where[idx - 1] && where[idx - 1] === '=' && isTargetRef(where[idx - 2], targetAlias)) {
+        if (links.length) links.push('and')
+        links.push(el, '=', where[idx - 2])
+      }
+      if (where[idx + 1] && where[idx + 1] === '=' && isTargetRef(where[idx + 2], targetAlias)) {
+        if (links.length) links.push('and')
+        links.push(el, '=', where[idx + 2])
+      }
+    }
+    return links
+  }, [])
 }
 
-const _isFiltered = where => where.some(element => !(element in ['(', ')']))
+const _findJoinInQuery = (query, parentAlias) => {
+  const targetAlias = query.SELECT.from.as
+  if (query.SELECT && query.SELECT.where) return _joinFromWhere(query.SELECT.where, parentAlias, targetAlias)
+  return []
+}
 
 const _isDraftField = element => element.ref && element.ref.length > 1 && element.ref[0] === 'DraftAdministrativeData'
 
@@ -597,6 +617,10 @@ const _isLogicalFunction = (where, index) => {
 const _getWhereForActive = where => {
   const activeWhere = []
   for (let i = 0; i < where.length; i++) {
+    if (where[i].xpr) {
+      activeWhere.push({ xpr: _getWhereForActive(where[i].xpr) })
+      continue
+    }
     if (_isDraftField(where[i])) {
       activeWhere.push({ val: null })
     } else if (_functionContainsDraftField(where[i])) {
@@ -721,10 +745,20 @@ const _getSiblingScenario = (req, columns, model, siblingIndex, nav) => {
   const draftAdminAlias = _isDraftAdminScenario(req) && req.query.SELECT.from.as
   const params = [...req.params].reverse()
   const _getSiblingQueryFromWhere = (query, queryIndex, parentQuery) => {
-    if (query.SELECT && query.SELECT.where) {
-      const indexExists = query.SELECT.where.indexOf('exists')
-      if (indexExists > -1 && queryIndex > 0) {
-        return _getSiblingQueryFromWhere(query.SELECT.where[indexExists + 1], queryIndex - 1, query)
+    if (query.SELECT && query.SELECT.where && queryIndex > 0) {
+      for (let i = 0; i < query.SELECT.where.length; i++) {
+        if (query.SELECT.where[i].xpr && queryIndex > 0) {
+          const sibilingQueryFromWhere = _getSiblingQueryFromWhere(
+            { SELECT: { where: query.SELECT.where[i].xpr } },
+            queryIndex - 1,
+            query
+          )
+          if (sibilingQueryFromWhere) return sibilingQueryFromWhere
+        }
+
+        if (query.SELECT.where[i] === 'exists' && queryIndex > 0) {
+          return _getSiblingQueryFromWhere(query.SELECT.where[i + 1], queryIndex - 1, query)
+        }
       }
     }
     const target = { name: query.SELECT.from.ref[0].id || query.SELECT.from.ref[0], as: query.SELECT.from.as }
@@ -741,9 +775,16 @@ const _getSiblingScenario = (req, columns, model, siblingIndex, nav) => {
   return _getSiblingQueryFromWhere(req.query, siblingIndex)
 }
 
-const _mergeSiblingIntoCQN = (cqn, { cqn: siblingCQN }, siblingIndex) => {
-  const _replaceWhereExists = (query, _siblingIndex) => {
-    if (query.SELECT && query.SELECT.where) {
+const _replaceWhereExists = (query, _siblingIndex, siblingCQN) => {
+  if (query.SELECT && query.SELECT.where) {
+    for (let i = 0; i < query.SELECT.where.length; i++) {
+      const whereElement = query.SELECT.where[i]
+      if (whereElement.xpr) {
+        const res = _replaceWhereExists({ SELECT: { where: whereElement.xpr } }, _siblingIndex, siblingCQN)
+        if (res) return res
+        continue
+      }
+
       const indexExists = query.SELECT.where.indexOf('exists')
       if (indexExists > -1) {
         if (_siblingIndex > 0) return _replaceWhereExists(query.SELECT.where[indexExists + 1], _siblingIndex - 1)
@@ -751,7 +792,10 @@ const _mergeSiblingIntoCQN = (cqn, { cqn: siblingCQN }, siblingIndex) => {
       }
     }
   }
-  return _replaceWhereExists(cqn, siblingIndex)
+}
+
+const _mergeSiblingIntoCQN = (cqn, { cqn: siblingCQN }, siblingIndex) => {
+  return _replaceWhereExists(cqn, siblingIndex, siblingCQN)
 }
 
 const _getDraftDoc = (req, draftName, draftWhere) => {
@@ -796,6 +840,11 @@ const _getOrderByEnrichedColumns = (orderBy, columns, entity) => {
 
 const _replaceDraftAlias = where => {
   where.forEach(element => {
+    if (element.xpr) {
+      _replaceDraftAlias(element.xpr)
+      return
+    }
+
     if (_isDraftField(element)) {
       element.ref[0] = 'filterAdmin'
     }
@@ -981,7 +1030,10 @@ const _validatedDraftOfWhichIAmOwner = (req, draftWhere, draftParameters, column
   _isValidDraftOfWhichIAmOwner(draftParameters.isActiveEntity) && _draftOfWhichIAmOwner(req, draftWhere, columns)
 
 const _draftInSubSelect = (where, req) => {
-  return where.some(({ SELECT }) => {
+  return where.some(({ SELECT, xpr }) => {
+    if (xpr) {
+      return _draftInSubSelect(xpr, req)
+    }
     if (SELECT && SELECT.where) {
       const isActiveEntity = readAndDeleteKeywords(['IsActiveEntity'], SELECT.where, false)
       if (isActiveEntity) {
@@ -1022,7 +1074,7 @@ const _generateCQN = (originalFrom, req, columns, model) => {
     return _draftAdminTable(req)
   }
 
-  if (!req.query.SELECT.where || !_isFiltered(req.query.SELECT.where)) {
+  if (!req.query.SELECT.where) {
     return _allActive(req, columns, model)
   }
 
@@ -1032,7 +1084,7 @@ const _generateCQN = (originalFrom, req, columns, model) => {
   if (
     draftParameters.isActiveEntity &&
     _isTrue(draftParameters.isActiveEntity.value.val) &&
-    !draftParameters.siblingIsActive &&
+    !(draftParameters.siblingIsActive && draftParameters.siblingIsActive.value.val === null) &&
     !draftParameters.hasDraftEntity
   ) {
     return _allActive(req, columns, model)

package/libx/_runtime/fiori/generic/readOverDraft.js

@@ -5,18 +5,14 @@ const { readAndDeleteKeywords } = require('../utils/where')
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 const { isActiveEntityRequested } = require('../../../_runtime/fiori/utils/where')
 
-const _modifyCQN = (cqnDraft, where, context) => {
-  const whereDraft = [...where]
-  const result = readAndDeleteKeywords(['IsActiveEntity'], whereDraft)
-  cqnDraft.where(whereDraft)
+const _modifyWhere = (where, context) => {
+  for (let i = 0; i < where.length; i++) {
+    const element = where[i]
 
-  if (result && result.value.val === false) {
-    const fromRef = cqnDraft.SELECT.from.ref
-    cqnDraft.SELECT.from.ref[fromRef.length - 1] = ensureDraftsSuffix(fromRef[fromRef.length - 1])
-  }
-
-  for (let i = 0; i < cqnDraft.SELECT.where.length; i++) {
-    const element = cqnDraft.SELECT.where[i]
+    if (element.xpr) {
+      _modifyWhere(element.xpr, context)
+      continue
+    }
 
     if (element.SELECT) {
       const subCqnDraft = SELECT.from(
@@ -27,12 +23,25 @@ const _modifyCQN = (cqnDraft, where, context) => {
         [1]
       )
 
-      cqnDraft.SELECT.where[i] = subCqnDraft
+      where[i] = subCqnDraft
       _modifyCQN(subCqnDraft, element.SELECT.where, context)
     }
   }
 }
 
+const _modifyCQN = (cqnDraft, where, context) => {
+  const whereDraft = [...where]
+  const result = readAndDeleteKeywords(['IsActiveEntity'], whereDraft)
+  cqnDraft.where(whereDraft)
+
+  if (result && result.value.val === false) {
+    const fromRef = cqnDraft.SELECT.from.ref
+    cqnDraft.SELECT.from.ref[fromRef.length - 1] = ensureDraftsSuffix(fromRef[fromRef.length - 1])
+  }
+
+  _modifyWhere(cqnDraft.SELECT.where, context)
+}
+
 const _hasNavToNonDraftEnclosedAssoc = (pathSegments, definitions, excludeAssoc) => {
   if (pathSegments.length < 2) return false
   const entity = definitions[pathSegments[0]]
@@ -112,7 +121,7 @@ const _readOverDraftHandler = async function (req, next) {
 
   const hasDraftEntity = hasDraft(definitions, sqlQuery)
 
-  if (hasDraftEntity && sqlQuery.SELECT.where && sqlQuery.SELECT.where.length > 0) {
+  if (hasDraftEntity && sqlQuery.SELECT.where && sqlQuery.SELECT.where.length) {
     let cqnDraft = SELECT.from({
       ref: [...sqlQuery.SELECT.from.ref],
       as: sqlQuery.SELECT.from.as

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

@@ -93,6 +93,9 @@ const getUpdateDraftAdminCQN = ({ user }, draftUUID) => {
 const _addAlias = (where, tableName) => {
   // copy where
   return where.map(element => {
+    if (element.xpr) {
+      return { xpr: _addAlias(element.xpr, tableName) }
+    }
     if (element.ref && element.ref.length === 1) {
       // and copy ref
       return { ref: [tableName, element.ref[0]] }

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

@@ -57,7 +57,9 @@ const _removeIsActiveEntityCondition = where => {
     } 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) })
+      if (where[i].xpr.length) {
+        newWhere.push({ xpr: _removeIsActiveEntityCondition(where[i].xpr) })
+      }
       i++
     } else {
       newWhere.push(where[i])
@@ -65,7 +67,7 @@ const _removeIsActiveEntityCondition = where => {
     }
   }
 
-  if (newWhere[0] === 'and') {
+  if (newWhere[0] === 'and' || newWhere[0] === 'or') {
     newWhere.splice(0, 1)
   } else if (newWhere[0] === '(' && newWhere[1] === 'and') {
     newWhere.splice(0, 2)
@@ -90,32 +92,35 @@ const deleteCondition = (index, whereCondition, isXpr = false) => {
 }
 
 const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
-  let index = whereCondition.findIndex(({ xpr }) => xpr)
-  if (index !== -1) {
-    const result = readAndDeleteKeywords(keywords, whereCondition[index].xpr, toDelete)
-    if (result) {
-      if (whereCondition[index].xpr.length === 0) {
-        deleteCondition(index, whereCondition, true)
+  let index = -1
+  for (let i = 0; i < whereCondition.length; i++) {
+    const entry = whereCondition[i]
+    if (entry.xpr) {
+      const result = readAndDeleteKeywords(keywords, entry.xpr, toDelete)
+      if (result) {
+        if (entry.xpr.length === 0) {
+          deleteCondition(i, whereCondition, true)
+        }
+        return result
+      }
+    } else if (entry.ref) {
+      const refLastIndex = entry.ref.length - 1
+
+      if (keywords.length === 1) {
+        if (entry.ref[refLastIndex] === keywords[0]) {
+          index = i
+          break
+        }
       }
-      return result
-    }
-  }
-
-  index = whereCondition.findIndex(({ ref }) => {
-    if (!ref) {
-      return false
-    }
-
-    const refLastIndex = ref.length - 1
-
-    if (keywords.length === 1) {
-      return ref[refLastIndex] === keywords[0]
-    }
 
-    if (keywords.length === 2 && ref.length >= 2) {
-      return ref[refLastIndex - 1] === keywords[0] && ref[refLastIndex] === keywords[1]
+      if (keywords.length === 2 && entry.ref.length >= 2) {
+        if (entry.ref[refLastIndex - 1] === keywords[0] && entry.ref[refLastIndex] === keywords[1]) {
+          index = i
+          break
+        }
+      }
     }
-  })
+  }
 
   if (index === -1) {
     return
@@ -135,6 +140,10 @@ const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
 
 const removeIsActiveEntityRecursively = where => {
   for (const entry of where) {
+    if (entry.xpr) {
+      entry.xpr = removeIsActiveEntityRecursively(entry.xpr)
+      continue
+    }
     if (entry.SELECT && entry.SELECT.where && entry.SELECT.from.ref && !entry.SELECT.from.ref[0].endsWith('_drafts')) {
       entry.SELECT.where = removeIsActiveEntityRecursively(entry.SELECT.where)
 
@@ -153,6 +162,10 @@ const isActiveEntityRequested = where => {
   let i = 0
 
   while (where[i]) {
+    if (where[i].xpr) {
+      const isRequested = isActiveEntityRequested(where.xpr)
+      if (isRequested) return true
+    }
     if (
       where[i].ref &&
       where[i].ref[where[i].ref.length - 1] === 'IsActiveEntity' &&

package/libx/_runtime/hana/search2cqn4sql.js

@@ -37,8 +37,11 @@ const search2cqn4sql = (query, entity, options) => {
   if (resolveLocalizedDataAtRuntime) {
     const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
+    // REVISIT this is dirty but works for now
     // replace $user_locale placeholder with the user locale or the HANA session context
-    onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
+    if (onCondition[0].xpr) {
+      onCondition[0].xpr[onCondition[0].xpr.length - 1] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
+    } else onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
 
     // inner join the target table with the _texts table (the _texts table contains
     // the translated texts)

package/libx/_runtime/sqlite/convertAssocToOneManaged.js

@@ -17,29 +17,36 @@ const _getConvertibleEntries = req => {
   return [...orders, ...groups, ...filters, ...havings]
 }
 
-// REVISIT once sql can handle structured keys properly, this handler should not be required anymore
-const _handler = function (req) {
-  // do simple checks upfront and exit early
-  if (!req.query || typeof req.query === 'string') return
-  if (!req.query.SELECT.orderBy && !req.query.SELECT.groupBy && !req.query.SELECT.where && !req.query.SELECT.having) {
-    return
-  }
-
-  if (!req.target || !req.target.elements) return
+const _convert = (refEntries, req) => {
+  for (const refEntry of refEntries) {
+    if (refEntry.xpr) {
+      _convert(refEntry.xpr, req)
+      continue
+    }
 
-  for (const refEntry of _getConvertibleEntries(req)) {
     if (!refEntry.ref || refEntry.ref.length < 2) {
       // only check refs in format {ref: ['assoc', 'id']}
       continue
     }
-
     const element = req.target.elements[refEntry.ref[0]]
     if (!element || !element.is2one) return
-
     _convertRefForAssocToOneManaged(element, refEntry)
   }
 }
 
+// REVISIT once sql can handle structured keys properly, this handler should not be required anymore
+const _handler = function (req) {
+  // do simple checks upfront and exit early
+  if (!(req.query && req.query.SELECT) || typeof req.query === 'string') return
+  if (!req.query.SELECT.orderBy && !req.query.SELECT.groupBy && !req.query.SELECT.where && !req.query.SELECT.having) {
+    return
+  }
+
+  if (!req.target || !req.target.elements) return
+
+  _convert(_getConvertibleEntries(req), req)
+}
+
 _handler._initial = true
 
 module.exports = _handler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "5.9.2",
+  "version": "5.9.3",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [