@sap/cds 5.7.5 → 5.8.2

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/structured.js

@@ -99,6 +99,7 @@ const _getVal = (data, name) => {
 
 const _filterForStructProperty = (structElement, structData, op, prefix = '', nav = []) => {
   const filterArray = []
+  const andOr = op === '!=' ? 'or' : 'and'
 
   for (const elementName in structElement.elements) {
     const element = structElement.elements[elementName]
@@ -123,8 +124,8 @@ const _filterForStructProperty = (structElement, structData, op, prefix = '', na
           for (const key in assoc._target.keys) {
             if (element.name === `${assocName}_${key}`) {
               const ref = [`${prefix}_${assocName}_${key}`]
-              const val = _getVal(structData[assocName], key)
-              filterArray.push({ ref }, op, { val }, 'and')
+              const val = _getVal(structData && structData[assocName], key)
+              filterArray.push({ ref }, op, { val }, andOr)
             }
           }
         }
@@ -134,7 +135,7 @@ const _filterForStructProperty = (structElement, structData, op, prefix = '', na
         { ref: [...nav, `${prefix}_${element.name}`] },
         op,
         { val: _getVal(structData, element.name) },
-        'and'
+        andOr
       )
     }
   }
@@ -182,7 +183,12 @@ const _transformStructToFlatWhereHaving = ([first, op, second], resArray, struct
   } else {
     // transform complex structured to multiple single structured
     const { nestedElement, prefix } = _nestedStructElement(structProperties, structElement)
-    resArray.push(..._filterForStructProperty(nestedElement, structData, op, prefix, nav))
+    const filterForStructProperty = _filterForStructProperty(nestedElement, structData, op, prefix, nav)
+    if (filterForStructProperty.length) {
+      filterForStructProperty.pop() // last and/or
+      if (op === '!=') resArray.push('(', ...filterForStructProperty, ')')
+      else resArray.push(...filterForStructProperty)
+    }
   }
 
   if (resArray[resArray.length - 1] === 'and') {

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()

package/libx/_runtime/db/data-conversion/post-processing.js

@@ -90,7 +90,8 @@ const _extractRefs = (from, as) => {
   return [ref]
 }
 
-const _addMapperFunction = (elements, toService, key, type, from, includeAlias) => {
+// REVISIT: check why we need includeAlias for some draft cases (check AFC tests)
+const _addMapperFunction = (elements, toService, key, type, alias, includeAlias) => {
   if (!toService.has(type)) {
     return
   }
@@ -99,9 +100,8 @@ const _addMapperFunction = (elements, toService, key, type, from, includeAlias)
 
   // ambiguous cases will lead to SQL syntax errors anyway, so no need for a check
   elements.set(key, convertFunction)
-
-  if (includeAlias) {
-    elements.set(`${from.as}_${key}`, convertFunction)
+  if (includeAlias && alias) {
+    elements.set(`${alias}_${key}`, convertFunction)
   }
 }
 
@@ -109,13 +109,13 @@ const _filterUnique = (value, index, arr) => {
   return arr.indexOf(value) === index
 }
 
-const _addMapperFunction4struct = (elements, toService, parent, struct, from, includeAlias) => {
+const _addMapperFunction4struct = (elements, toService, parent, struct, alias, includeAlias) => {
   for (const k in struct.elements) {
     const current = struct.elements[k]
     if (current._isStructured) {
-      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, from, includeAlias)
+      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, alias, includeAlias)
     } else {
-      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, from, includeAlias)
+      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, alias, includeAlias)
     }
   }
 }
@@ -126,7 +126,6 @@ const _addMapperFunction4struct = (elements, toService, parent, struct, from, in
  * @param {Map} toService - Mapping instructions for data conversions based on CDS data types
  * @param {object} csn - Reflected CSN
  * @param {object} cqn - CQN that is used to query the DB.
- * @param {boolean} [includeAlias] - Include mapping for aliases. Defaults to false.
  * @returns {Map<any, any>}
  * @private
  */
@@ -142,13 +141,16 @@ const _getElementCombinations = (toService, csn, cqn, includeAlias = false) => {
     }
 
     const entity = csn.definitions[ensureUnlocalized(entityName)]
-
     for (const key in entity.elements) {
       const element = entity.elements[key]
       if (element._isStructured) {
-        _addMapperFunction4struct(elements, toService, key, element, from, includeAlias)
+        _addMapperFunction4struct(elements, toService, key, element, from.as, includeAlias)
       } else {
-        _addMapperFunction(elements, toService, key, element.type, from, includeAlias)
+        if ('SET' in cqn.SELECT.from) {
+          _addMapperFunction(elements, toService, key, element.type, cqn.SELECT.from.as, includeAlias)
+        } else {
+          _addMapperFunction(elements, toService, key, element.type, from.as, includeAlias)
+        }
       }
     }
   }
@@ -182,15 +184,17 @@ const _getMapperForListedElements = (toService, csn, cqn) => {
 
   for (const element of cqn.SELECT.columns) {
     if (element.ref) {
-      const identifier = element.ref[element.ref.length - 1]
+      const identifier = element.ref.length === 1 ? element.ref[0] : undefined
       const name = element.as ? element.as : identifier
 
       if (element.cast) {
         mapper.set(name, _getCastFunction(element.cast))
       } else if (elements.has(name)) {
         mapper.set(name, elements.get(name))
-      } else if (elements.has(identifier) && !cqn.SELECT.from.args) {
+      } else if (elements.has(identifier)) {
         mapper.set(name, elements.get(identifier))
+      } else if (elements.has(element.ref.join('_'))) {
+        mapper.set(name || element.ref[element.ref.length - 1], elements.get(element.ref.join('_')))
       }
     } else if (element.as && element.cast) {
       mapper.set(element.as, _getCastFunction(element.cast))
@@ -514,6 +518,9 @@ const getPropertyMapper = (csn, cqn) => {
   return new Map()
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   getPropertyMapper,
   getPostProcessMapper,

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

@@ -11,9 +11,10 @@ const _removeParentKeysFromRow = (row, prefix, keys) => {
   }
 }
 
-const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) => {
+const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth, options) => {
   for (const nav in entity._associations) {
     const navigation = entity._associations[nav]
+    if (options.onlyCompositions && navigation._isAssociationEffective) continue
 
     // do not expand backlinks
     if (navigation._isBacklink) continue
@@ -26,7 +27,9 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
       .on(entity._relations[navigation.name].join(childAlias, parentAlias))
 
     // set alias for expanded columns already
-    const childColumns = getColumns(navigation._target).map(c => ({ ref: [childAlias, c.name] }))
+    const childColumns = getColumns(navigation._target, { _4db: true, onlyKeys: options.onlyKeys }).map(c => ({
+      ref: [childAlias, c.name]
+    }))
     const parentKeys = Object.keys(entity.keys).filter(k => !entity.keys[k].isAssociation)
     // mark parent key with prefix in alias
     const parentKeysWithAlias = parentKeys.map(pk => ({ ref: [parentAlias, pk], as: `$$pk_${pk}` }))
@@ -69,16 +72,17 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
 
     // expand next level if needed
     if (depth - 1 !== 0 && result.length && navigation._target._associations) {
-      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1)
+      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1, options)
     }
   }
 
   return previousResult
 }
 
-const _foreignKeysOfTopLevelNavs = entity => {
+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') {
@@ -89,6 +93,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
   return [...requiredFks]
 }
 
+const _addForeignKeys = (columns, entity, options) => {
+  const fks = _foreignKeysOfTopLevelNavs(entity, options)
+  fks.forEach(fk => {
+    if (!columns.some(c => c.ref[0] === fk)) {
+      columns.push({ ref: [fk] })
+    }
+  })
+}
+
 /**
  * 1. Creates flattened SQL statements for each expand layer
  * 2. Mixes in foreign keys if needed
@@ -98,18 +111,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
  * @returns object
  */
 const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSelectCQN) => {
+  const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
+  const options = Object.assign({ onlyKeys: false, onlyCompositions: false }, expandColumn._options)
   // remove expand columns from query without modifying
   const topLevelSelect = query.clone().columns(query.SELECT.columns.filter(c => !c.expand))
 
   const entity = model.definitions[topLevelSelect.SELECT.from.ref[0]]
 
   // ensure foreign keys are selected if needed
-  const fks = _foreignKeysOfTopLevelNavs(entity)
-  fks.forEach(fk => {
-    if (!topLevelSelect.SELECT.columns.some(c => c.ref[0] === fk)) {
-      topLevelSelect.SELECT.columns.push({ ref: [fk] })
-    }
-  })
+  _addForeignKeys(topLevelSelect.SELECT.columns, entity, options)
 
   const result = await executeSelectCQN(model, dbc, topLevelSelect, user, locale, txTimestamp)
 
@@ -119,9 +129,8 @@ const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSel
 
   // _associations contains compositions and associations
   if (entity._associations) {
-    const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
     const depth = expandColumn.expand === '**' ? -1 : Number(expandColumn.expand.replace('*', ''))
-    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth)
+    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth, options)
   }
 
   return result

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

@@ -2,10 +2,15 @@ const cds = require('../../cds')
 
 const { getAllKeys } = require('../../cds-services/adapter/odata-v4/odata-to-cqn/utils')
 
+const { deepCopyObject } = require('../../common/utils/copy')
 const { getNavigationIfStruct } = require('../../common/utils/structured')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
-const { filterKeys } = require('../../fiori/utils/handler')
 const { isAsteriskColumn } = require('../../common/utils/rewriteAsterisks')
+const { getCQNUnionFrom } = require('../../common/utils/union')
+
+const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+
+const { filterKeys } = require('../../fiori/utils/handler')
 
 // Symbols are used to add extra information in response structure
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
@@ -16,12 +21,9 @@ const IDENTIFIER = Symbol.for('sap.cds.identifier')
 const IS_ACTIVE = Symbol.for('sap.cds.isActive')
 const IS_UNION_DRAFT = Symbol.for('sap.cds.isUnionDraft')
 
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
-
-const { getCQNUnionFrom } = require('../../common/utils/union')
-
 function getCqnCopy(readToOneCQN) {
-  const readToOneCQNCopy = JSON.parse(JSON.stringify(readToOneCQN))
+  // REVISIT: Use query.clone() instead
+  const readToOneCQNCopy = deepCopyObject(readToOneCQN)
   if (readToOneCQN[GET_KEY_VALUE] !== undefined) readToOneCQNCopy[GET_KEY_VALUE] = readToOneCQN[GET_KEY_VALUE]
   if (readToOneCQN[TO_MANY] !== undefined) readToOneCQNCopy[TO_MANY] = readToOneCQN[TO_MANY]
   if (readToOneCQN[TO_ACTIVE] !== undefined) readToOneCQNCopy[TO_ACTIVE] = readToOneCQN[TO_ACTIVE]
@@ -518,6 +520,17 @@ class JoinCQNFromExpanded {
 
         // REVISIT required for other cqn properties as well?
         this.adjustOrderBy(readToOneCQN.orderBy, mappings, column, tableAlias)
+
+        // In case active parent entity has orderBy with draft specific columns we need to add them to parent CQN
+        if (
+          readToOneCQN[IS_ACTIVE] &&
+          readToOneCQN.orderBy &&
+          column.as &&
+          (column.as === 'IsActiveEntity' || column.as === 'HasActiveEntity' || column.as === 'HasDraftEntity')
+        ) {
+          readToOneCQNCopy.orderBy = readToOneCQN.orderBy
+          this._addColumnsInCaseOrderByHasDraft(readToOneCQNCopy, readToOneCQN.columns[readToOneCQN.columns.length - 1])
+        }
       }
     }
 
@@ -549,6 +562,14 @@ class JoinCQNFromExpanded {
     }
   }
 
+  _addColumnsInCaseOrderByHasDraft(readToOneCQNCopy, column) {
+    readToOneCQNCopy.orderBy.forEach(order => {
+      if (order.as === column.as) {
+        readToOneCQNCopy.columns.push(column)
+      }
+    })
+  }
+
   /**
    * Follow the tree to get to the relevant config object.
    *
@@ -1130,28 +1151,37 @@ class JoinCQNFromExpanded {
           }
         }
       }
-      const ks = Object.keys(expandedEntity.keys).filter(
-        c => !expandedEntity.keys[c].isAssociation && !DRAFT_COLUMNS.includes(c)
-      )
-      const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
-      const unionFrom = getCQNUnionFrom(cols, ref.replace(/_drafts$/, ''), ref, ks, user)
-      for (const each of cqn.columns) {
-        if (!each.as) continue
-        // replace val with ref
-        if (each.as === 'IsActiveEntity' || each.as === 'HasActiveEntity') {
-          delete each.val
-          each.ref = [tableAlias, each.as]
-          each.as = tableAlias + '_' + each.as
-        }
-        // ensure the cast
-        if (each.as.match(/IsActiveEntity$/) || each.as.match(/HasActiveEntity$/) || each.as.match(/HasDraftEntity$/)) {
-          each.cast = { type: 'cds.Boolean' }
+
+      if (!cqn[IS_ACTIVE]) {
+        const ks = Object.keys(expandedEntity.keys).filter(
+          c => !expandedEntity.keys[c].isAssociation && !DRAFT_COLUMNS.includes(c)
+        )
+        const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
+        const unionFrom = getCQNUnionFrom(cols, ref.replace(/_drafts$/, ''), ref, ks, user)
+        for (const each of cqn.columns) {
+          if (!each.as) continue
+          // replace val with ref
+          if (each.as === 'IsActiveEntity' || each.as === 'HasActiveEntity') {
+            delete each.val
+            each.ref = [tableAlias, each.as]
+            each.as = tableAlias + '_' + each.as
+          }
+          // ensure the cast
+          if (
+            each.as.match(/IsActiveEntity$/) ||
+            each.as.match(/HasActiveEntity$/) ||
+            each.as.match(/HasDraftEntity$/)
+          ) {
+            each.cast = { type: 'cds.Boolean' }
+          }
         }
+        const cs = cqn.columns
+          .filter(c => !c.expand && c.ref && c.ref[0] === tableAlias)
+          .map(c => ({ ref: [c.ref[1]] }))
+        const unionArgs = cqn.from.args
+        unionArgs[0].SELECT = { columns: cs, from: unionFrom, distinct: true }
+        delete unionArgs[0].ref
       }
-      const cs = cqn.columns.filter(c => !c.expand && c.ref && c.ref[0] === tableAlias).map(c => ({ ref: [c.ref[1]] }))
-      const unionArgs = cqn.from.args
-      unionArgs[0].SELECT = { columns: cs, from: unionFrom, distinct: true }
-      delete unionArgs[0].ref
     }
 
     return cqn
@@ -1324,6 +1354,17 @@ class JoinCQNFromExpanded {
       }
     }
 
+    if (readToOneCQN[IS_ACTIVE] && readToOneCQN.columns.length > 0) {
+      readToOneCQN.columns.forEach(column => {
+        if (
+          column.as === `${parentAlias}_IsActiveEntity` ||
+          column.as === `${parentAlias}_HasActiveEntity` ||
+          column.as === `${parentAlias}_HasDraftEntity`
+        )
+          columns.push(column)
+      })
+    }
+
     const subSelect = Object.assign({}, readToOneCQN, { columns })
 
     const SELECT = { from: { SELECT: subSelect }, columns: outerColumns, distinct: true }

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

@@ -2,6 +2,9 @@ const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
 const rawToExpanded = require('./rawToExpanded')
 const expandV2 = require('./expand-v2')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   hasExpand,
   createJoinCQNFromExpanded,

package/libx/_runtime/db/generic/create.js

@@ -15,16 +15,6 @@ module.exports = async function (req) {
   }
 
   try {
-    // REVISIT: should be handled in protocol adapter
-    // execute validation query first to fail early
-    if (req.query._validationQuery) {
-      const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-      if (validationResult.length === 0) {
-        // > validation target (e.g., root of navigation) doesn't exist
-        req.reject(404)
-      }
-    }
     const results = await this._insert(this.model, this.dbc, req.query, req)
     return new InsertResult(req, results)
   } catch (err) {

package/libx/_runtime/db/generic/index.js

@@ -12,6 +12,9 @@ const DELETE = require('./delete')
 const structured = require('./structured')
 const arrayed = require('./arrayed')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   rewrite,
   virtual,

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

@@ -7,32 +7,10 @@
  *
  * @param req - cds.Request
  */
-module.exports = async function (req) {
+module.exports = function (req) {
   if (typeof req.query === 'string') {
     return this._execute.sql(this.dbc, req.query, req.data)
   }
 
-  // REVISIT: should be handled in protocol adapter
-  // execute validation query first to fail early
-  if (req.query._validationQuery) {
-    const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-    if (validationResult.length === 0) {
-      // > validation target (e.g., root of navigation) doesn't exist
-      req.reject(404)
-    }
-  }
-
-  const result = await this._read(this.model, this.dbc, req.query, req)
-
-  if (
-    req.query._validationQuery &&
-    req.query._validationQuery.__navToManyWithKeys &&
-    (!result || result.length === 0)
-  ) {
-    // > navigation to collection with key specified without result -> 404
-    req.reject(404)
-  }
-
-  return result
+  return this._read(this.model, this.dbc, req.query, req)
 }