@sap/cds 5.9.7 → 6.0.2

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

@@ -24,6 +24,7 @@ const _findSubselect = where => {
     if (e.xpr) {
       return _findSubselect(e.xpr)
     }
+
     return e.SELECT && where[i - 1] === 'exists'
   })
 }
@@ -33,29 +34,16 @@ const _findRootSubSelectFor = query => {
     const subSelect = _findSubselect(query.SELECT.where)
     return subSelect ? _findRootSubSelectFor(subSelect) : query
   }
+
   return query
 }
 
 // append where with clauses from @restrict
-const _getWhereWithAppendedDraftRestrictions = (where = [], req, scenarioAlias, model) => {
+const _getWhereWithAppendedDraftRestrictions = (where = [], req) => {
   if (req.query._draftRestrictions) {
     for (const each of req.query._draftRestrictions) {
       const xpr = each._xpr
       if (each.target.name === ensureUnlocalized(req.target.name)) {
-        // > restriction directly on child
-        // REVISIT: remove support for selects in restriction with cds^6
-        // adjust alias of @restrict where "exists (select ...)"
-        if (scenarioAlias && model)
-          xpr
-            .filter(e => e.SELECT && e.SELECT.from && e.SELECT.where)
-            .forEach(e => {
-              const entity = model.definitions[e.SELECT.from.ref[0]]
-              e.SELECT.where = e.SELECT.where.map(w => {
-                if (w.ref && w.ref.length === 1 && !entity.elements[w.ref[0]]) w.ref.unshift(scenarioAlias)
-                return w
-              })
-            })
-
         if (where.length) where.push('and')
         // restriction might contain or clause -> use xpr for grouping
         xpr.includes('or') ? where.push({ xpr }) : where.push(...xpr)
@@ -76,13 +64,12 @@ const _getWhereWithAppendedDraftRestrictions = (where = [], req, scenarioAlias,
       }
     }
   }
+
   return where
 }
 
 const _isTrue = val => val === true || val === 'true'
-
 const _isFalse = val => val === false || val === 'false'
-
 const _inProcessByUserWhere = userId => [{ ref: ['filterAdmin', 'InProcessByUser'] }, '=', { val: userId }]
 
 const _getTableName = (
@@ -162,7 +149,6 @@ const _getDefaultDraftProperties = ({ hasDraft, isActive = true, withDraftUUID =
 // draft values for active entities with calculated hasDraft property
 const _getDraftPropertiesDetermineDraft = (req, where, tableName, calcDraftUUID = false) => {
   const { table } = _getTableName(req, true)
-
   tableName = tableName || table
 
   const hasDraftQuery = SELECT.from(tableName, [{ val: 1 }])
@@ -209,18 +195,18 @@ function _copyCQNPartial(partial) {
     return newPartial
   }
 
-  return partial.ref ? Object.assign({}, partial, { ref: _copyArray(partial.ref) }) : Object.assign({}, partial)
+  if (partial.ref) {
+    return Object.assign({}, partial, { ref: _copyArray(partial.ref) })
+  }
+
+  return Object.assign({}, partial)
 }
 
 function _copyArray(array) {
-  return array.map(entry => {
-    return typeof entry === 'object' && !(entry instanceof String) ? _copyCQNPartial(entry) : entry
-  })
+  return array.map(entry => (typeof entry === 'object' && !(entry instanceof String) ? _copyCQNPartial(entry) : entry))
 }
 
-const _isValidDraftOfWhichIAmOwner = isActiveEntity => {
-  return isActiveEntity.op === '=' && _isFalse(isActiveEntity.value.val)
-}
+const _isValidDraftOfWhichIAmOwner = isActiveEntity => isActiveEntity.op === '=' && _isFalse(isActiveEntity.value.val)
 
 const _isValidActiveWithoutDraft = (isActiveEntity, hasDraftEntity) => {
   return (
@@ -293,7 +279,7 @@ const _getOuterMostColumns = (columnsFromRequest, additionalDraftColumns) => {
 // adds base columns 'InProcessByUser' and 'CreatedByUser' to columns param if needed
 // those are required for calculating 'DraftIsProcessedByMe' and 'DraftIsCreatedByMe'
 const _ensureDraftAdminColumnsForCalculation = columns => {
-  columns.forEach((c, i) => {
+  columns.forEach(c => {
     if (c.ref && c.ref[0] === 'DraftIsCreatedByMe' && !columns.find(e => e.ref && e.ref[0] === 'CreatedByUser')) {
       columns.push({ ref: ['CreatedByUser'] })
     } else if (
@@ -337,13 +323,7 @@ const _allInactive = (req, columns) => {
   // ensure only own drafts are read
   const cqn = SELECT.from(table)
     .join('DRAFT.DraftAdministrativeData', 'filterAdmin')
-    .on([
-      { ref: [table.as, 'DraftAdministrativeData_DraftUUID'] },
-      '=',
-      {
-        ref: ['filterAdmin', 'DraftUUID']
-      }
-    ])
+    .on([{ ref: [table.as, 'DraftAdministrativeData_DraftUUID'] }, '=', { ref: ['filterAdmin', 'DraftUUID'] }])
     .where(_inProcessByUserWhere(req.user.id))
 
   if (isCount) {
@@ -353,7 +333,6 @@ const _allInactive = (req, columns) => {
   }
 
   cqn.where(req.query.SELECT.where)
-
   return { cqn: getEnrichedCQN(cqn, req.query.SELECT, []), scenario: SCENARIO.ALL_INACTIVE }
 }
 
@@ -377,22 +356,7 @@ const _buildWhere = (where, table) => {
   }
 }
 
-const _buildOrderBy = (query, columns, table) => {
-  for (const entry of query.SELECT.orderBy || []) {
-    // detect if calculated value
-    if (entry.ref && columns.some(c => c.as === entry.ref[entry.ref.length - 1])) {
-      // remove table alias if present
-      if (entry.ref[0] === table.as) {
-        entry.ref.splice(0, 1)
-      }
-    } else if (table.as && entry.ref[0] !== table.as) {
-      // if regular column and no alias present, add it
-      entry.ref.unshift(table.as)
-    }
-  }
-}
-
-const _allActive = (req, columns, model) => {
+const _allActive = (req, columns) => {
   const { table } = _getTableName(req)
   if (!table.as) {
     table.as = 'active'
@@ -405,7 +369,6 @@ const _allActive = (req, columns, model) => {
 
   const ids = filterKeys(req.target.keys)
   const isCount = columns.some(element => element.func === 'count')
-
   const xpr = {
     xpr: [
       'case',
@@ -437,15 +400,12 @@ const _allActive = (req, columns, model) => {
   }
 
   const scenarioAlias = 'active'
-
-  req.query.SELECT.where = _getWhereWithAppendedDraftRestrictions(req.query.SELECT.where, req, scenarioAlias, model)
+  req.query.SELECT.where = _getWhereWithAppendedDraftRestrictions(req.query.SELECT.where, req)
 
   if (req.query.SELECT.where) {
     _buildWhere(req.query.SELECT.where, table)
   }
 
-  _buildOrderBy(req.query, cqn.SELECT.columns, table)
-
   return {
     cqn: getEnrichedCQN(cqn, req.query.SELECT, req.query.SELECT.where, scenarioAlias),
     scenario: SCENARIO.ALL_ACTIVE
@@ -472,31 +432,22 @@ const _activeWithoutDraft = (req, draftWhere, columns) => {
   )
 
   const outerMostColumns = _getOuterMostColumns(columns, _getDefaultDraftProperties({ hasDraft: false }))
-
   const cqn = SELECT.from(active.table)
     .columns(...outerMostColumns)
     .where(['not exists', subSelect])
 
   draftWhere = _getWhereWithAppendedDraftRestrictions(draftWhere, req)
-
   return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.ACTIVE_WITHOUT_DRAFT }
 }
 
 const _draftOfWhichIAmOwner = (req, draftWhere, columns) => {
   const { table, name } = _getTableName(req, true)
-
   const outerMostColumns = _getOuterMostColumns(addColumnAlias(columns, name), DRAFT_COLUMNS_CASTED)
 
   const cqn = SELECT.from(table)
     .columns(...outerMostColumns)
     .join('DRAFT.DraftAdministrativeData', 'filterAdmin')
-    .on([
-      { ref: [name, 'DraftAdministrativeData_DraftUUID'] },
-      '=',
-      {
-        ref: ['filterAdmin', 'DraftUUID']
-      }
-    ])
+    .on([{ ref: [name, 'DraftAdministrativeData_DraftUUID'] }, '=', { ref: ['filterAdmin', 'DraftUUID'] }])
     .where(_inProcessByUserWhere(req.user.id))
 
   return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.DRAFT_WHICH_OWNER }
@@ -512,13 +463,7 @@ const _activeWithDraftInProcess = (req, draftWhere, columns, isLocked) => {
   let subSelect = SELECT.from(draftName)
     .columns(...keys)
     .join('DRAFT.DraftAdministrativeData', 'filterAdmin')
-    .on([
-      { ref: [draftName, 'DraftAdministrativeData_DraftUUID'] },
-      '=',
-      {
-        ref: ['filterAdmin', 'DraftUUID']
-      }
-    ])
+    .on([{ ref: [draftName, 'DraftAdministrativeData_DraftUUID'] }, '=', { ref: ['filterAdmin', 'DraftUUID'] }])
 
   const DRAFT_CANCEL_TIMEOUT_IN_SEC = ((cds.env.drafts && cds.env.drafts.cancellationTimeout) || 15) * 60
 
@@ -530,25 +475,20 @@ const _activeWithDraftInProcess = (req, draftWhere, columns, isLocked) => {
     { ref: ['filterAdmin', 'InProcessByUser'] },
     'is not null',
     'and',
-    {
-      func: 'seconds_between',
-      args: [{ ref: ['filterAdmin', 'LastChangeDateTime'] }, 'CURRENT_TIMESTAMP']
-    },
+    { func: 'seconds_between', args: [{ ref: ['filterAdmin', 'LastChangeDateTime'] }, 'CURRENT_TIMESTAMP'] },
     isLocked ? '<' : '>',
     { val: DRAFT_CANCEL_TIMEOUT_IN_SEC }
   ])
 
   subSelect = keys.reduce(
-    (select, key) => subSelect.where([{ ref: [active.name, key] }, '=', { ref: [draftName, key] }]),
+    (_select, key) => subSelect.where([{ ref: [active.name, key] }, '=', { ref: [draftName, key] }]),
     subSelect
   )
 
   const outerMostColumns = _getOuterMostColumns(columns, draftColumns)
-
   const cqn = SELECT.from(active.table).columns(outerMostColumns)
   cqn.where(_getWhereWithAppendedDraftRestrictions([], req))
   cqn.where(['exists', subSelect])
-
   return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.DRAFT_IN_PROCESS }
 }
 
@@ -572,10 +512,12 @@ 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
     }
 
@@ -584,11 +526,13 @@ const _joinFromWhere = (where, parentAlias, 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
   }, [])
 }
@@ -609,6 +553,7 @@ const _functionContainsDraftField = obj =>
   })
 
 const _isLogicalFunction = (where, index) => {
+  // REVISIT
   const borders = ['(', ')', 'and', 'or', undefined]
 
   return borders.includes(where[index - 1]) && borders.includes(where[index + 1])
@@ -621,6 +566,7 @@ const _getWhereForActive = where => {
       activeWhere.push({ xpr: _getWhereForActive(where[i].xpr) })
       continue
     }
+
     if (_isDraftField(where[i])) {
       activeWhere.push({ val: null })
     } else if (_functionContainsDraftField(where[i])) {
@@ -666,9 +612,10 @@ const _siblingEntity = (
   const subScenario = _siblingSubScenario(nav, siblingIndex, siblingQuery, target, params, model, onCond, req)
   const isSiblingDraft = subScenario
     ? subScenario.isSiblingActive || subScenario.scenario === 'ACTIVE' || subScenario.scenario === 'ALL_ACTIVE'
-    : keys.IsActiveEntity && keys.IsActiveEntity !== 'false'
+    : keys.IsActiveEntity && keys.IsActiveEntity !== false
   const { table } = _getTableName({ query, target }, isSiblingDraft)
   const cqn = SELECT.from(table)
+
   if (siblingIndex === 0) {
     const columnCqnPartial = columns.map(col => {
       const colName = col.ref ? col.ref[col.ref.length - 1] : col
@@ -698,14 +645,16 @@ const _siblingEntity = (
   for (const key in keys) {
     if (key !== 'IsActiveEntity') cqn.where([{ ref: [table.as, key] }, '=', { val: keys[key] }])
   }
+
   if (subScenario) {
     cqn.where(['exists', subScenario.cqn])
   }
+
   // in DraftAdminData scenario parent is linked via join
   if (draftAdminAlias) {
     cqn.where([{ ref: [draftAdminAlias, 'DraftUUID'] }, '=', { ref: ['draftAdmin', 'DraftUUID'] }])
   } else if (parentLinks.length) {
-    cqn.where('(', ...parentLinks, ')')
+    cqn.where({ xpr: [...parentLinks] })
   }
 
   return { cqn, scenario: SCENARIO.SIBLING_ENTITY, isSiblingActive: !isSiblingDraft }
@@ -722,6 +671,7 @@ function _siblingSubScenario(nav, siblingIndex, siblingQuery, target, params, mo
     params: [...params].reverse(),
     user: req.user
   }
+
   if (subSiblingIndex > -1) {
     subScenario = _getSiblingScenario(subReq, [{ val: 1 }], model, subSiblingIndex, subNav, params)
     if (subSiblingIndex > 0) {
@@ -732,12 +682,14 @@ function _siblingSubScenario(nav, siblingIndex, siblingQuery, target, params, mo
     }
   } else {
     subReq.query = SELECT.from(siblingQuery.SELECT.from).columns([{ val: 1 }])
+
     const existsIdx = siblingQuery.SELECT.where.indexOf('exists')
     if (existsIdx > -1) subReq.query.where(siblingQuery.SELECT.where.slice(existsIdx, existsIdx + 2))
     const subOrigFrom = { ref: [...subNav].reverse() }
     subScenario = _generateCQN(subOrigFrom, subReq, [{ val: 1 }], model)
     subScenario.cqn.where(onCond)
   }
+
   return subScenario
 }
 
@@ -753,6 +705,7 @@ const _getSiblingScenario = (req, columns, model, siblingIndex, nav) => {
             queryIndex - 1,
             query
           )
+
           if (sibilingQueryFromWhere) return sibilingQueryFromWhere
         }
 
@@ -761,6 +714,7 @@ const _getSiblingScenario = (req, columns, model, siblingIndex, nav) => {
         }
       }
     }
+
     const target = { name: query.SELECT.from.ref[0].id || query.SELECT.from.ref[0], as: query.SELECT.from.as }
     return _siblingEntity(
       { query, target, params, nav },
@@ -772,6 +726,7 @@ const _getSiblingScenario = (req, columns, model, siblingIndex, nav) => {
       req
     )
   }
+
   return _getSiblingQueryFromWhere(req.query, siblingIndex)
 }
 
@@ -807,9 +762,7 @@ const _getDraftDoc = (req, draftName, draftWhere) => {
       .on([
         { ref: [req.query.SELECT.from.as || draftName, 'DraftAdministrativeData_DraftUUID'] },
         '=',
-        {
-          ref: ['filterAdmin', 'DraftUUID']
-        }
+        { ref: ['filterAdmin', 'DraftUUID'] }
       ])
       .where(_inProcessByUserWhere(req.user.id)),
     req.query.SELECT,
@@ -835,6 +788,7 @@ const _getOrderByEnrichedColumns = (orderBy, columns, entity) => {
       }
     }
   }
+
   return enrichedCol
 }
 
@@ -911,28 +865,24 @@ const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere, model, ent
   draftDocs.columns(draftColumns)
 
   const activeName = activeDocs.SELECT.from.as || (activeDocs.SELECT.from.ref && activeDocs.SELECT.from.ref[0])
-
   const hasDraftWhere = []
-  for (const key of _getTargetKeys(req)) {
+  const targetKeys = _getTargetKeys(req)
+  for (const key of targetKeys) {
     // add 'and' token if not the first iteration
     if (hasDraftWhere.length) hasDraftWhere.push('and')
     hasDraftWhere.push({ ref: [activeName, key] }, '=', { ref: [draftName, key] })
   }
 
-  const activeColumns = [
-    ...columns,
-    ...enrichedColumns,
-    ..._filterDraftColumnsBySelected(
-      _getDraftPropertiesDetermineDraft(req, hasDraftWhere, ensureDraftsSuffix(req.target.name), true),
-      req.query.SELECT.columns
-    )
-  ]
+  const draftColumnsBySelected = _filterDraftColumnsBySelected(
+    _getDraftPropertiesDetermineDraft(req, hasDraftWhere, ensureDraftsSuffix(req.target.name), true),
+    req.query.SELECT.columns
+  )
+
+  const activeColumns = [...columns, ...enrichedColumns, ...draftColumnsBySelected]
   activeDocs.columns(activeColumns)
 
-  activeDocs.where([
-    'not exists',
-    _alignAliasForUnion(ensureNoDraftsSuffix(req.target.name), req.query.SELECT.from.as, subSelect)
-  ])
+  const aliasForUnion = _alignAliasForUnion(ensureNoDraftsSuffix(req.target.name), req.query.SELECT.from.as, subSelect)
+  activeDocs.where(['not exists', aliasForUnion])
 
   // groupBy, orderBy and limit do not support partial CQNs
   if (req.query.SELECT.groupBy) {
@@ -958,17 +908,12 @@ const _excludeActiveDraftExists = (req, draftWhere, columns, model) => {
 
   const subSelect = SELECT.from(draftName, [1])
     .join('DRAFT.DraftAdministrativeData', 'filterAdmin')
-    .on([
-      { ref: [draftName, 'DraftAdministrativeData_DraftUUID'] },
-      '=',
-      {
-        ref: ['filterAdmin', 'DraftUUID']
-      }
-    ])
+    .on([{ ref: [draftName, 'DraftAdministrativeData_DraftUUID'] }, '=', { ref: ['filterAdmin', 'DraftUUID'] }])
     .where(_inProcessByUserWhere(req.user.id))
 
   const targetName = ensureNoDraftsSuffix(req.target.name)
-  for (const key of _getTargetKeys(req)) {
+  const targetKeys = _getTargetKeys(req)
+  for (const key of targetKeys) {
     subSelect.where([{ ref: [targetName, key] }, '=', { ref: [draftName, key] }])
   }
 
@@ -1013,17 +958,18 @@ const _validatedWithSiblingInProcess = (req, draftWhere, draftParameters, column
     _isValidExcludeActiveDraftExists(draftParameters.isActiveEntity, draftParameters.siblingIsActive)
   )
     return _excludeActiveDraftExists(req, draftWhere, columns, model)
+
   if (
     draftInProcessByUser &&
     draftInProcessByUser.op === '!=' &&
     _isValidWithDraftLocked(isActiveEntity, siblingIsActive, draftInProcessByUser)
   ) {
     return _activeWithDraftInProcess(req, draftWhere, columns, req.user.id)
-  } else if (draftInProcessByUser && _isValidWithDraftTimeout(isActiveEntity, siblingIsActive, draftInProcessByUser)) {
-    return _activeWithDraftInProcess(req, draftWhere, columns, null)
   }
 
-  //
+  if (draftInProcessByUser && _isValidWithDraftTimeout(isActiveEntity, siblingIsActive, draftInProcessByUser)) {
+    return _activeWithDraftInProcess(req, draftWhere, columns, null)
+  }
 }
 
 const _validatedDraftOfWhichIAmOwner = (req, draftWhere, draftParameters, columns) =>
@@ -1034,6 +980,7 @@ const _draftInSubSelect = (where, req) => {
     if (xpr) {
       return _draftInSubSelect(xpr, req)
     }
+
     if (SELECT && SELECT.where) {
       const isActiveEntity = readAndDeleteKeywords(['IsActiveEntity'], SELECT.where, false)
       if (isActiveEntity) {
@@ -1065,9 +1012,9 @@ const _generateCQN = (originalFrom, req, columns, model) => {
     siblingScenario = _getSiblingScenario(req, columns, model, siblingIndex, nav)
     if (siblingIndex === 0) {
       return siblingScenario
-    } else {
-      _mergeSiblingIntoCQN(req.query, siblingScenario, siblingIndex - 1)
     }
+
+    _mergeSiblingIntoCQN(req.query, siblingScenario, siblingIndex - 1)
   }
 
   if (_isDraftAdminScenario(req)) {
@@ -1075,7 +1022,7 @@ const _generateCQN = (originalFrom, req, columns, model) => {
   }
 
   if (!req.query.SELECT.where) {
-    return _allActive(req, columns, model)
+    return _allActive(req, columns)
   }
 
   // REVISIT this function does not only read, but modifies where!
@@ -1087,7 +1034,7 @@ const _generateCQN = (originalFrom, req, columns, model) => {
     !(draftParameters.siblingIsActive && draftParameters.siblingIsActive.value.val === null) &&
     !draftParameters.hasDraftEntity
   ) {
-    return _allActive(req, columns, model)
+    return _allActive(req, columns)
   }
 
   if (!draftParameters.isActiveEntity) {
@@ -1095,7 +1042,8 @@ const _generateCQN = (originalFrom, req, columns, model) => {
       // this is only the case when navigating into tree
       return _allInactive(req, columns)
     }
-    return _allActive(req, columns, model)
+
+    return _allActive(req, columns)
   }
 
   if (draftParameters.hasDraftEntity) {
@@ -1109,14 +1057,10 @@ const _generateCQN = (originalFrom, req, columns, model) => {
   return _validatedDraftOfWhichIAmOwner(req, req.query.SELECT.where, draftParameters, columns)
 }
 
-const _getColumns = ({ query: { SELECT }, target }, model) => {
-  return SELECT.columns
-    ? SELECT.columns.filter(
-        col =>
-          (col.ref && !(col.ref[col.ref.length - 1] in DRAFT_COLUMNS_MAP)) || (!col.ref && !(col in DRAFT_COLUMNS_MAP))
-      )
-    : getColumns(target, { onlyNames: true, removeIgnore: true })
-}
+const _getColumns = ({ query: { SELECT } }) =>
+  SELECT.columns.filter(
+    col => (col.ref && !(col.ref[col.ref.length - 1] in DRAFT_COLUMNS_MAP)) || (!col.ref && !(col in DRAFT_COLUMNS_MAP))
+  )
 
 const _isIsActiveEntity = element => element.ref && element.ref[element.ref.length - 1] === 'IsActiveEntity'
 
@@ -1170,20 +1114,19 @@ const _adaptDraftColumnsForSiblingEntity = (result, isSiblingActive) => {
 }
 
 const _collectAliases = (from, aliases) => {
-  if (from) {
-    if (from.ref && from.as) {
-      // Actually table names in where annotations should be provided with '.' separator.
-      // Normalization to '_' is done for the exceptional case if '_' is still used (based on db table names).
-      aliases.set(from.ref[0].replace(/\./g, '_'), from.as)
-    } else if (from.args) {
-      from.args.forEach(arg => {
-        _collectAliases(arg, aliases)
-      })
-    } else if (from.SET && from.SET.args) {
-      from.SET.args.forEach(arg => {
-        _collectAliases(arg, aliases)
-      })
-    }
+  if (!from) return
+  if (from.ref && from.as) {
+    // Actually table names in where annotations should be provided with '.' separator.
+    // Normalization to '_' is done for the exceptional case if '_' is still used (based on db table names).
+    aliases.set(from.ref[0].replace(/\./g, '_'), from.as)
+  } else if (from.args) {
+    from.args.forEach(arg => {
+      _collectAliases(arg, aliases)
+    })
+  } else if (from.SET && from.SET.args) {
+    from.SET.args.forEach(arg => {
+      _collectAliases(arg, aliases)
+    })
   }
 }
 
@@ -1217,6 +1160,7 @@ const _getLocalizedEntity = (model, target, user) => {
   if (cds.env.i18n.for_sqlite.includes(user.locale)) {
     localizedEntity = model.definitions[`${prefix}.${user.locale}.${target.name}`]
   }
+
   return localizedEntity || model.definitions[`${prefix}.${target.name}`]
 }
 
@@ -1241,12 +1185,18 @@ const _getOriginalColumns = req => {
   for (const c of req.query.SELECT.columns) {
     originalColumns[c.ref ? c.ref[c.ref.length - 1] : c.as || c] = true
   }
+
   return originalColumns
 }
 
+const _handlerStreaming = (req, query) => {
+  adaptStreamCQN(query)
+  query._streaming = true
+  return cds.tx(req).run(query)
+}
+
 const _postProcess = (result, req, cqnScenario, deleteLastChangeDateTime) => {
   const resultAsArray = Array.isArray(result) ? result : result ? [result] : []
-
   if (!result || !resultAsArray.length) return result
 
   if (cqnScenario.scenario === SCENARIO.SIBLING_ENTITY) {
@@ -1257,11 +1207,11 @@ const _postProcess = (result, req, cqnScenario, deleteLastChangeDateTime) => {
 
   const removeDraftUUIDIfNecessaryFn = removeDraftUUIDIfNecessary(req)
   let notRequestedColumns
-  // REVISIT: remove flag cds.env.features.auto_fetch_expand_keys after two month grace period
-  if (!req.query.SELECT._4odata && !cds.env.features.auto_fetch_expand_keys) {
+  if (!req.query.SELECT._4odata) {
     const originalColumns = _getOriginalColumns(req)
     notRequestedColumns = originalColumns && Object.keys(resultAsArray[0]).filter(key => !originalColumns[key])
   }
+
   if (cqnScenario.scenario === SCENARIO.DRAFT_ADMIN) {
     _calculateDraftAdminColumns(resultAsArray[0], req.user.id, deleteLastChangeDateTime)
     if (notRequestedColumns) {
@@ -1280,31 +1230,58 @@ const _postProcess = (result, req, cqnScenario, deleteLastChangeDateTime) => {
   return result
 }
 
+const _fnCompare = elName => c => (c.as && c.as === elName) || (c.ref && c.ref[c.ref.length - 1] === elName)
+const _adaptColumns4readAfterWrite = (req, cqnScenario, query4sql) => {
+  if (
+    !(req.context.event === 'EDIT' && cqnScenario.scenario === SCENARIO.DRAFT_WHICH_OWNER) &&
+    !(req.context.event === 'draftActivate' && cqnScenario.scenario === SCENARIO.ALL_ACTIVE)
+  )
+    return
+
+  // cleanup columns if not requested with $select or $expand
+  cqnScenario.cqn.SELECT.columns = cqnScenario.cqn.SELECT.columns.reduce((columns, column) => {
+    const elName = column.as || (column.ref && column.ref[column.ref.length - 1])
+    if (query4sql.SELECT.columns.find(_fnCompare(elName)) || elName in req.target.keys) columns.push(column)
+    return columns
+  }, [])
+
+  // add missing keys
+  const isActive = req.context.event === 'draftActivate'
+  // aliasing is fixed by scenarios
+  const alias = isActive ? 'active' : req.target.drafts.name
+  for (const key in req.target.keys) {
+    if (req.target.keys[key].isAssociation) continue
+    if (!cqnScenario.cqn.SELECT.columns.find(_fnCompare(key))) {
+      const column =
+        key === 'IsActiveEntity'
+          ? { val: isActive, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } }
+          : { ref: [alias, key] }
+      cqnScenario.cqn.SELECT.columns.push(column)
+    }
+  }
+}
+
 /**
  * Generic Handler for READ requests in the context of draft.
  *
  * @param req
  */
 const _handler = async function (req) {
+  const query = req.query
+  const originalFrom = _copyCQNPartial(query.SELECT.from)
+
   // handle localized here as it was previously handled for req.target
   req.target = _getLocalizedEntity(this.model, req.target, req.user) || req.target
 
-  const originalFrom = _copyCQNPartial(req.query.SELECT.from)
-
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
   const query4sql = cqn2cqn4sql(req.query, this.model, { _4fiori: true })
 
-  // do not clone with Object.assign as that would skip all non-enumerable properties
-  const reqClone = { __proto__: req, query: _copyCQNPartial(query4sql) }
-
-  // ensure draft restrictions are copied to new query
-  reqClone.query._draftRestrictions = req.query._draftRestrictions
+  // Clone the request. Do not clone with Object.assign as that would skip all non-enumerable properties.
+  const reqClone = { __proto__: req, query: query4sql.clone() }
+  // Clone draft restrictions to the cloned query.
+  reqClone.query._draftRestrictions = query._draftRestrictions
 
-  if (req.query._streaming) {
-    adaptStreamCQN(reqClone.query)
-    reqClone.query._streaming = true
-    return cds.tx(req).run(reqClone.query)
-  }
+  if (query._streaming) return _handlerStreaming(req, reqClone.query)
 
   let cqnScenario
 
@@ -1312,16 +1289,15 @@ const _handler = async function (req) {
   // just to make existing tests working with new parser. not really tested, not needed to be supported
   if (reqClone.query.SELECT.from.SELECT) {
     const subQueryReq = { __proto__: req, query: _copyCQNPartial(_getLastSubQuery(reqClone.query)) }
-    cqnScenario = _generateCQN(originalFrom.SELECT.from, subQueryReq, _getColumns(subQueryReq, this.model), this.model)
+    const columns = _getColumns(subQueryReq)
+    cqnScenario = _generateCQN(originalFrom.SELECT.from, subQueryReq, columns, this.model)
     cqnScenario.cqn = _setLastSubQuery(reqClone.query, cqnScenario.cqn)
   } else {
-    cqnScenario = _generateCQN(originalFrom, reqClone, _getColumns(reqClone, this.model), this.model)
+    const columns = _getColumns(reqClone)
+    cqnScenario = _generateCQN(originalFrom, reqClone, columns, this.model)
   }
 
-  if (!cqnScenario) {
-    req.reject(400)
-    return
-  }
+  if (!cqnScenario) req.reject(400)
 
   // ensure base columns for calculation are selected in draft admin expand
   _adaptDraftAdminExpand(cqnScenario.cqn)
@@ -1341,13 +1317,12 @@ const _handler = async function (req) {
   // unlocalize for db and after handlers as it was before
   req.target = this.model.definitions[ensureUnlocalized(req.target.name)]
 
-  const result = await cds.tx(req).send({ query: cqnScenario.cqn, target: req.target })
+  _adaptColumns4readAfterWrite(req, cqnScenario, query4sql)
 
+  const result = await cds.tx(req).send({ query: cqnScenario.cqn, target: req.target })
   return _postProcess(result, req, cqnScenario, enhancedWithLastChangeDateTime)
 }
 
-module.exports = cds.service.impl(function () {
-  for (const entity of Object.values(this.entities).filter(e => e._isDraftEnabled)) {
-    this.on('READ', entity, _handler)
-  }
+module.exports = cds.service.impl(function (srv, entity) {
+  srv.on('READ', entity, _handler)
 })