@sap/cds 6.4.1 → 6.6.0

package/libx/_runtime/common/code-ext/worker.js

@@ -0,0 +1,40 @@
+const cds = require('../../cds')
+const LOG = cds.log()
+const { parentPort, workerData } = require('worker_threads')
+const { WorkerSELECT, WorkerINSERT, WorkerUPSERT, WorkerUPDATE, WorkerDELETE } = require('./workerQuery')
+const WorkerReq = require('./WorkerReq')
+const { timeout } = require('./config')
+
+parentPort.once('message', function onWorkerMessageReceived(message) {
+  const { contextId, workerId, kind, code, reqData } = message
+  if (LOG._debug) LOG.debug(`Post message received on worker thread (worker.js) from main thread`, message)
+  if (kind !== 'start' || workerId !== workerData.id) return
+
+  // eslint-disable-next-line cds/no-missing-dependencies
+  const { VM } = require('vm2')
+  const workerReq = new WorkerReq(contextId, reqData)
+  const vm = new VM({
+    console: 'inherit',
+    timeout, // specifies the number of milliseconds to execute code before terminating execution
+    allowAsync: true,
+
+    // the sandbox represents the global object inside the vm instance
+    sandbox: {
+      req: workerReq,
+      SELECT: WorkerSELECT._api(),
+      INSERT: WorkerINSERT._api(),
+      UPSERT: WorkerUPSERT._api(),
+      UPDATE: WorkerUPDATE._api(),
+      DELETE: WorkerDELETE._api()
+    }
+  })
+
+  try {
+    ;(async function () {
+      const result = await vm.run(code)
+      parentPort.postMessage({ contextId, kind: 'success', req: reqData, postMessages: workerReq.postMessages, result })
+    })()
+  } catch (error) {
+    parentPort.postMessage({ contextId, kind: 'error', error })
+  }
+})

package/libx/_runtime/common/code-ext/workerQuery.js

@@ -0,0 +1,45 @@
+const SELECT = require('../../../../lib/ql/SELECT')
+const INSERT = require('../../../../lib/ql/INSERT')
+const UPSERT = require('../../../../lib/ql/UPSERT')
+const UPDATE = require('../../../../lib/ql/UPDATE')
+const DELETE = require('../../../../lib/ql/DELETE')
+const queryExecutor = require('./workerQueryExecutor')
+
+class WorkerSELECT extends SELECT {
+  // intercept await SELECT.from(...) calls
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerINSERT extends INSERT {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerUPSERT extends UPSERT {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerUPDATE extends UPDATE {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerDELETE extends DELETE {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+Object.defineProperty(WorkerSELECT.prototype, 'cmd', { value: 'SELECT' })
+Object.defineProperty(WorkerINSERT.prototype, 'cmd', { value: 'INSERT' })
+Object.defineProperty(WorkerUPSERT.prototype, 'cmd', { value: 'UPSERT' })
+Object.defineProperty(WorkerUPDATE.prototype, 'cmd', { value: 'UPDATE' })
+Object.defineProperty(WorkerDELETE.prototype, 'cmd', { value: 'DELETE' })
+
+module.exports = { WorkerSELECT, WorkerINSERT, WorkerUPSERT, WorkerUPDATE, WorkerDELETE }

package/libx/_runtime/common/code-ext/workerQueryExecutor.js

@@ -0,0 +1,36 @@
+const cds = require('../../cds')
+const LOG = cds.log()
+const { parentPort } = require('worker_threads')
+const executorCallbackMap = new Map()
+
+parentPort.on('message', function onWorkerMessageReceived(message) {
+  const { id, kind, result } = message
+  if (LOG._debug) LOG.debug(`Post message received on worker thread (workerQueryExecutor.js) from main thread`, message)
+  if (!executorCallbackMap.has(id)) return
+
+  switch (kind) {
+    case 'responseData':
+      executorCallbackMap.get(id)(result)
+      executorCallbackMap.delete(id)
+      return
+
+    case 'cleanup':
+      executorCallbackMap.delete(id)
+      return
+  }
+})
+
+function queryExecutor(resolve) {
+  const id = cds.utils.uuid()
+  executorCallbackMap.set(id, result => resolve(result))
+  parentPort.postMessage({
+    id,
+    kind: 'run',
+    target: 'srv',
+    prop: 'run',
+    responseData: true,
+    args: [this]
+  })
+}
+
+module.exports = queryExecutor

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

@@ -78,7 +78,9 @@ const _whereKeys = keySet => {
 }
 
 const _parentKey = (element, key) => {
-  return [...element.customBackLinks, ...element.backLinks].reduce((parentKey, customBackLink) => {
+  let links = [...element.customBackLinks, ...element.backLinks]
+  if (element.is2one && links.some(l => l.for2one)) links = links.filter(l => l.for2one)
+  return links.reduce((parentKey, customBackLink) => {
     // TODO: why Object.prototype.hasOwnProperty?
     parentKey[customBackLink.entityKey] = Object.prototype.hasOwnProperty.call(key, customBackLink.targetKey)
       ? key[customBackLink.targetKey]
@@ -139,7 +141,8 @@ const _getWhereObj = (row, links) => {
 
 const _subWhere = (result, element) => {
   let where
-  const links = [...element.backLinks, ...element.customBackLinks]
+  let links = [...element.backLinks, ...element.customBackLinks]
+  if (element.is2one && links.some(l => l.for2one)) links = links.filter(l => l.for2one)
   if (result.length && links && links.length > 0) {
     where = {}
     const keys0 = Object.keys(_getWhereObj(result[0], links))

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

@@ -132,6 +132,8 @@ const _getCompositionTreeRec = ({
         if (element.is2many) {
           subObject.customBackLinks.push(...backLinks)
         } else {
+          subObject.is2one = true
+          backLinks.forEach(b => (b.for2one = true))
           subObject.backLinks.push(...backLinks)
         }
       }

package/libx/_runtime/common/generic/auth/restrict.js

@@ -142,7 +142,7 @@ const _getRestrictionForTarget = (resolvedApplicables, target) => {
 }
 
 const _addRestrictionsToRead = async (req, model, resolvedApplicables) => {
-  if (req.target._isDraftEnabled) {
+  if (!cds.env.features.lean_draft && req.target._isDraftEnabled) {
     req.query._draftRestrictions = resolvedApplicables
     return
   }

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

@@ -61,6 +61,10 @@ exports.impl = cds.service.impl(function () {
       req.query.where(singleton)
     }
 
+    if (req.event === 'READ' && req.query?.SELECT) {
+      req.query.SELECT.localized = true
+    }
+
     if (!result) {
       result = await cds.tx(req).run(req.query, req.data)
     }

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

@@ -81,7 +81,9 @@ const commonGenericEtag = async function (req) {
 
     // validate
     if (req.isConditional && !req.query.INSERT) {
-      const result = await cds.tx(req).run(getSelectCQN(req.query, req.target, this.model))
+      let cqn = getSelectCQN(req.query, req.target, this.model)
+      if (req.query.UPDATE || req.query.DELETE) cqn = cqn.forUpdate()
+      const result = await cds.tx(req).run(cqn)
 
       if (result.length === 1) {
         const etag = Object.values(result[0])[0]

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

@@ -36,10 +36,10 @@ const _getSimpleCategory = category => {
 }
 
 const _isDraftCoreComputed = (req, element, event) =>
+  element['@Core.Computed'] &&
   cds.env.features.preserve_computed !== false &&
   req._ &&
   req._.event === 'draftActivate' &&
-  element['@Core.Computed'] &&
   !((event === 'CREATE' && element['@cds.on.insert']) || element['@cds.on.update'])
 
 const _isStreamingProperty = (elements, row, property) =>
@@ -217,16 +217,8 @@ const _callError = (req, errors) => {
   for (const error of errors) req.error(error)
 }
 
-const _isBoundAction = req => !!(req.getUriInfo && req.getUriInfo().getLastSegment().getKind() === 'BOUND.ACTION')
-
-const _getBoundActionBindingParameter = req => {
-  // REVISIT: req._ gets set in onDraftActivate to original req
-  const action = (req._ && req._.event) || req.event
-  const actions = req.target.actions
-
-  // 'in' is the default binding parameter name for bound actions/functions
-  return (actions && actions[action] && actions[action]['@cds.odata.bindingparameter.name']) || 'in'
-}
+const _getBoundAction = req => req.target.actions?.[req.context?.event]
+const _getBoundActionBindingParameter = action => action['@cds.odata.bindingparameter.name'] || 'in'
 
 async function commonGenericInput(req) {
   if (!req.query) return // FIXME: the code below expects req.query to be defined
@@ -250,8 +242,10 @@ async function commonGenericInput(req) {
     pathSegments: []
   }
 
-  if (_isBoundAction(req)) {
-    const pathSegment = _getBoundActionBindingParameter(req)
+  const boundAction = _getBoundAction(req)
+
+  if (boundAction) {
+    const pathSegment = _getBoundActionBindingParameter(boundAction)
     const keys = req._ && req._.params && req._.params[0]
     if (pathSegment) pathOptions.pathSegments.push(pathSegment)
 
@@ -370,7 +364,11 @@ commonGenericInput._initial = true
 _actionFunctionHandler._initial = true
 
 module.exports = cds.service.impl(function () {
-  this.before(['CREATE', 'UPDATE', 'NEW', 'PATCH'], '*', commonGenericInput)
+  if (cds.env.features.lean_draft) {
+    this.before(['CREATE', 'UPDATE'], '*', commonGenericInput)
+  } else {
+    this.before(['CREATE', 'UPDATE', 'NEW', 'PATCH'], '*', commonGenericInput)
+  }
   const operationNames = []
 
   for (const operation of this.operations) {

package/libx/_runtime/common/i18n/index.js

@@ -8,7 +8,7 @@ const dirs = (cds.env.i18n && cds.env.i18n.folders) || []
 const i18ns = {}
 
 function exists(args, locale) {
-  const file = path.join(process.cwd(), ...args, locale ? `messages_${locale}.properties` : 'messages.properties')
+  const file = path.join(cds.root, ...args, locale ? `messages_${locale}.properties` : 'messages.properties')
   return fs.existsSync(file) ? file : undefined
 }
 

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

@@ -11,7 +11,7 @@ const search2cqn4sql = require('./search2cqn4sql')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 const getError = require('../../common/error')
 const { rewriteAsterisks } = require('./rewriteAsterisks')
-const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
+const { getEntityFromPath } = require('../../common/utils/path')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { addRefToWhereIfNecessary } = require('../../../odata/afterburner')
 const { addAliasToExpression, PARENT_ALIAS, FOREIGN_ALIAS } = require('../../db/utils/generateAliases')
@@ -142,14 +142,16 @@ const _getWindowWhere = (where, bottomTop) => {
 
 const _getOrderByForWindowFn = bottomTop => {
   const orderBy = _getBottomTopRefOrVal(bottomTop[0], 'ref')[0]
-  orderBy.sort = bottomTop[0].func === 'topcount' ? 'desc' : 'asc'
-  return orderBy
+  const sort = bottomTop[0].func === 'topcount' ? 'desc' : 'asc'
+  return [orderBy, sort]
 }
 
 const _getWindowXpr = (groupBy, bottomTop) => {
-  const xpr = [{ func: 'ROW_NUMBER', args: [] }, 'OVER', '(']
+  const overXpr = { xpr: [] }
+  const xpr = [{ func: 'ROW_NUMBER', args: [] }, 'OVER', overXpr]
+
   if (groupBy)
-    xpr.push(
+    overXpr.xpr.push(
       'PARTITION BY',
       ...groupBy.reduce((acc, el, i) => {
         if (i < groupBy.length - 1) {
@@ -163,9 +165,8 @@ const _getWindowXpr = (groupBy, bottomTop) => {
       }, [])
     )
 
-  xpr.push('ORDER BY', _getOrderByForWindowFn(bottomTop))
-  xpr.push(')')
-  return { xpr: xpr, as: 'rowNumber' }
+  overXpr.xpr.push('ORDER BY', ..._getOrderByForWindowFn(bottomTop))
+  return { xpr, as: 'rowNumber' }
 }
 
 const _isNavCountFunc = el => el.func && el.func === 'count' && el.args[0] !== '*'
@@ -445,7 +446,7 @@ const convertWhereExists = (query, model, options, currentTarget) => {
   if (currentTarget) {
     queryTarget = getEntityFromPath({ ref }, currentTarget)
   } else {
-    queryTarget = getEntityFromPath(getPathFromRef(ref), model)
+    queryTarget = getEntityFromPath({ ref }, model)
     outerAlias = as || PARENT_ALIAS + lambdaIteration
     innerAlias = FOREIGN_ALIAS + lambdaIteration
   }
@@ -586,6 +587,7 @@ const _convertOrderByOrWhereIfSkip = (cqn, target, model) => {
   }
 }
 
+/* REVISIT: Unused
 const _convertExpand = expand => {
   expand.forEach(expandElement => {
     if (expandElement.ref && expandElement.ref[0]) {
@@ -603,15 +605,21 @@ const _convertExpand = expand => {
     }
   })
 }
+*/
 
-const _convertRefWhereInExpand = columns => {
-  if (!columns) return
+const _simplifyWhere = col => {
+  if (col.ref?.[0].where) {
+    col.where = col.ref[0].where
+    col.ref[0] = col.ref[0].id
+  }
+}
 
-  columns.forEach(col => {
-    if (col.expand && typeof col.expand !== 'string') {
-      _convertExpand(col.expand)
-    }
-  })
+const _simplifyWhereInColumns = columns => {
+  if (!columns) return
+  for (const col of columns) {
+    _simplifyWhere(col)
+    if (col.expand) _simplifyWhereInColumns(col.expand)
+  }
 }
 
 const _convertPathExpression = (query, model, options = {}) => {
@@ -742,8 +750,8 @@ const _convertSelect = (query, model, _options) => {
     _convertToOneEqNullInFilter(query.SELECT, target)
   }
 
-  // extract where clause if it is in column expand ref
-  _convertRefWhereInExpand(query.SELECT.columns)
+  // extract where clause if it is in an expand column
+  _simplifyWhereInColumns(query.SELECT.columns)
 
   // REVISIT: The following operations only work for _one_ entity.
   // We must also enable them for joins etc.
@@ -822,7 +830,11 @@ const _convertUpsert = (query, model) => {
 
   // We add all previous properties ot the newly created query.
   // Reason is to not lose the query API functionality
-  Object.assign(upsert.UPSERT, query.UPSERT, { into: { ref: [resolvedIntoClause], as: query.UPSERT.into.as } })
+
+  for (const key in query.UPSERT) {
+    upsert.UPSERT[key] = query.UPSERT[key]
+  }
+  Object.assign(upsert.UPSERT, { into: { ref: [resolvedIntoClause], as: query.UPSERT.into.as } })
 
   const resolved = resolveView(upsert, model, cds.db)
   // required for deplyoing of extensions, not used anywhere else except UpsertBuilder
@@ -843,7 +855,11 @@ const _convertInsert = (query, model) => {
 
   // We add all previous properties ot the newly created query.
   // Reason is to not lose the query API functionality
-  Object.assign(insert.INSERT, query.INSERT, { into: { ref: [resolvedIntoClause], as: query.INSERT.into.as } })
+  insert.INSERT = {}
+  for (const prop in query.INSERT) {
+    insert.INSERT[prop] = query.INSERT[prop]
+  }
+  Object.assign(insert.INSERT, { into: { ref: [resolvedIntoClause], as: query.INSERT.into.as } })
 
   const target = model.definitions[resolvedIntoClause]
   if (!target) return insert
@@ -895,7 +911,12 @@ const _convertDelete = (query, model, options) => {
 
   const { target, alias, where } = convertPathExpressionToWhere(query.DELETE.from, model, options)
   const deleet = DELETE('x')
-  Object.assign(deleet.DELETE, query.DELETE, { from: target, where: undefined })
+
+  for (const key in query.DELETE) {
+    deleet.DELETE[key] = query.DELETE[key]
+  }
+
+  Object.assign(deleet.DELETE, { from: target, where: undefined })
 
   if (alias) deleet.DELETE.from = { ref: [target], as: alias }
   if (where) deleet.where(where)
@@ -940,7 +961,11 @@ const _convertUpdate = (query, model, options) => {
   // link .with and .data and set query target and remove current where clause
   // REVISIT: update statement does not accept cqn partial as input
   const update = UPDATE('x')
-  Object.assign(update.UPDATE, query.UPDATE, { entity: target, where: undefined })
+  // Object.assign(update.UPDATE, query.UPDATE, { entity: target, where: undefined })
+  for (const key in query.UPDATE) {
+    update.UPDATE[key] = query.UPDATE[key]
+  }
+  Object.assign(update.UPDATE, { entity: target, where: undefined })
 
   if (alias) update.UPDATE.entity = { ref: [target], as: alias }
   if (where) update.where(where)

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

@@ -1,41 +1,20 @@
-const cds = require('../../cds')
 const { ensureNoDraftsSuffix } = require('./draft')
 
-/*
- * returns path like <service>.<entity>:<prop1>.<prop2> for ref = [{ id: '<service>.<entity>' }, '<prop1>', '<prop2>']
- */
-const getPathFromRef = ref => {
-  const x = ref.reduce((acc, cur) => {
-    acc += (acc ? ':' : '') + (cur.id ? cur.id : cur)
-    return acc
-  }, '')
-  const y = x.split(':')
-  let z = y.shift()
-  if (y.length) z += ':' + y.join('.')
-  return z
-}
-
 /*
  * returns the target entity for the given path
  */
 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) {
-    let segment = segments.shift()
-    if (segment.id && typeof segment.id === 'string') {
-      segment.id = ensureNoDraftsSuffix(segment.id)
-    } else if (typeof segment === 'string') {
-      segment = ensureNoDraftsSuffix(segment)
-    }
-    current = current.elements[segment.id || segment]
+
+  let id
+  for (const segment of path.ref) {
+    id = ensureNoDraftsSuffix(segment.id || segment)
+    current = current.elements[id]
     if (current && current.target) current = current._target
   }
   return current
 }
 
 module.exports = {
-  getPathFromRef,
   getEntityFromPath
 }

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

@@ -15,20 +15,27 @@ const search2cqn4sql = (query, model, options = {}) => {
   const { search2cqn4sql } = options
   const { entityName, alias } = _targetFrom(query.SELECT.from, options)
   const entity = model.definitions[entityName]
-  const columns = computeColumnsToBeSearched(query, entity, alias)
-
+  const localizedAssociation = entity.associations?.localized
   // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
   // REVISIT: $search query option combined with $count is not currently optimized
-  if (typeof search2cqn4sql === 'function' && !query.SELECT.count) {
-    const search2cqnOptions = { columns, locale: options.locale }
+  if (
+    typeof search2cqn4sql === 'function' &&
+    !query.SELECT.count &&
+    localizedAssociation &&
+    !(query._aggregated || /* new parser */ query.SELECT.groupBy)
+  ) {
+    const search2cqnOptions = { columns: computeColumnsToBeSearched(query, entity), locale: options.locale }
     return search2cqn4sql(query, entity, search2cqnOptions)
-  }
+  } else {
+    const columnsToBeSearched = computeColumnsToBeSearched(query, entity, alias)
+    const expression = columnsToBeSearched?.length
+      ? searchToLike(cqnSearchPhrase, columnsToBeSearched)
+      : [{ val: 0 }, '=', { val: 1 }]
 
-  const expression = searchToLike(cqnSearchPhrase, columns)
-
-  // REVISIT: find out here if where or having must be used
-  query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
+    // REVISIT: find out here if where or having must be used
+    query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
+  }
 }
 
 module.exports = search2cqn4sql

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

@@ -1,20 +1,26 @@
+const cds = require('../../cds')
 const templatePathSerializer = (tKey, keyNames, row, elements, draftKeys) => {
-  const keyValuePairs = keyNames.map(key => {
-    let quote
+  const keyValuePairs = keyNames
+    .filter(key => {
+      if (cds.env.features.lean_draft && key === 'IsActiveEntity') return false
+      return true
+    })
+    .map(key => {
+      let quote
 
-    switch (elements[key].type) {
-      case 'cds.String':
-        quote = "'"
-        break
+      switch (elements[key].type) {
+        case 'cds.String':
+          quote = "'"
+          break
 
-      default:
-        quote = ''
-        break
-    }
+        default:
+          quote = ''
+          break
+      }
 
-    const keyValue = row[key] ?? draftKeys?.[key]
-    return `${key}=${quote}${keyValue}${quote}`
-  })
+      const keyValue = row[key] ?? draftKeys?.[key]
+      return `${key}=${quote}${keyValue}${quote}`
+    })
 
   const keyValuePairsSerialized = keyValuePairs.join(',')
   return `${tKey}(${keyValuePairsSerialized})`

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

@@ -91,7 +91,7 @@ const _getMapperForListedElements = (conversionMap, csn, cqn) => {
     if (col.cast) {
       const name = col.as ? col.as : col.ref[col.ref.length - 1]
       _addConverter(mapper, name, (val, key, row, unaliasedKey) => {
-        row[unaliasedKey || key] = _getCastFunction(col.cast)(val)
+        row[unaliasedKey || key] = val === null ? null : _getCastFunction(col.cast)(val)
       })
       continue
     }

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

@@ -40,7 +40,8 @@ function getCqnCopy(readToOneCQN) {
 
 class JoinCQNFromExpanded {
   constructor(cqn, csn, locale) {
-    this._SELECT = Object.assign({}, cqn.SELECT)
+    this._SELECT = {}
+    for (const prop in cqn.SELECT) this._SELECT[prop] = cqn.SELECT[prop]
     this._csn = csn
     // REVISIT: locale is only passed in case of sqlite -> bad coding
     if (cds.env.i18n.for_sqlite.includes(locale)) {
@@ -866,7 +867,7 @@ class JoinCQNFromExpanded {
         const subWhere = []
 
         for (const key in entity.keys) {
-          if (key === 'IsActiveEntity') continue
+          if (key === 'IsActiveEntity' || entity.keys[key]._isAssociationStrict) continue
           if (subWhere.length) {
             subWhere.push('and')
           }
@@ -981,7 +982,7 @@ class JoinCQNFromExpanded {
           ...column,
           xpr: column.xpr.map(x => {
             if (x.ref) {
-              const res = this._buildNewAliasColumn(x, entity, tableAlias, mappings)
+              const res = this._buildNewAliasColumn(x, entity, tableAlias, mappings, true)
               delete res.as
               return res
             } else return x
@@ -1012,7 +1013,7 @@ class JoinCQNFromExpanded {
     return column.ref && typeof column.ref[column.ref.length - 1] !== 'string'
   }
 
-  _buildNewAliasColumn(column, entity, tableAlias, mappings) {
+  _buildNewAliasColumn(column, entity, tableAlias, mappings, skipMapping = false) {
     // Casted name, vs column name
     const identifier = this._getIdentifier(column, tableAlias)
     const as = column[SKIP_MAPPING] ? column.as : `${tableAlias}_${identifier}`
@@ -1026,6 +1027,8 @@ class JoinCQNFromExpanded {
       aliasedElement.ref = alias ? [alias, column.ref[0]] : [column.ref[0]]
     }
 
+    if (skipMapping) return aliasedElement
+
     if (!column[SKIP_MAPPING]) {
       mappings[column[IDENTIFIER] || identifier] = as
       if (column[CLEANUP_KEYS]) {

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

@@ -1,5 +1,6 @@
 const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 const DRAFT_COLUMNS_ARRAY = Object.keys(DRAFT_COLUMNS_MAP)
+const cds = require('../../cds')
 
 const EXPAND = Symbol.for('sap.cds.expand')
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
@@ -110,9 +111,9 @@ class RawToExpanded {
         let expandedItems = this._getResultCache(toManyTree.concat(key))[mapping[GET_KEY_VALUE](false, entry)] || []
 
         // the expanded items may include the actives of the deleted drafts -> filter out
-        if (rootIsActiveEntity !== null) {
+        if (!cds.env.features.lean_draft && rootIsActiveEntity !== null) {
           if (mapping[TO_ACTIVE]) expandedItems = expandedItems.filter(ele => ele.IsActiveEntity !== false)
-          else expandedItems = expandedItems.filter(ele => ele.IsActiveEntity === rootIsActiveEntity)
+          else expandedItems = expandedItems.filter(ele => !!ele.IsActiveEntity === rootIsActiveEntity)
         }
 
         row[key] = !mapping[CLEANUP_KEYS]

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

@@ -197,11 +197,11 @@ function dbGenericInput(req) {
   // call with this for this.model
   normalizeTimeData.call(this, req)
 
-  const draft = req.target.name && req.target.name.match(/_drafts$/)
+  const draft = req.target.name && (req.target.name.match(/_drafts$/) || req.target.name.match(/\.drafts$/))
 
   const target =
     req.target._unresolved && req.target.name
-      ? this.model.definitions[req.target.name.replace(/_drafts$/, '')]
+      ? this.model.definitions[req.target.name] || this.model.definitions[req.target.name.replace(/_drafts$/, '')]
       : req.target
   if (!target || target._unresolved) return
 

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

@@ -333,6 +333,7 @@ const _checkReferenceIntegrity = (entity, data, req, csn, run) => {
 }
 
 const _checkIntegrityWrapper = (req, csn, run) => async (data, entity) => {
+  if (cds.env.features.lean_draft && entity.name?.endsWith('.drafts')) return
   const errors = await _checkReferenceIntegrity(entity, data, req, csn, run)
   if (errors && errors.length !== 0) for (const err of errors) req.error(err)
 }

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

@@ -18,6 +18,7 @@ const _convert = (columns, target, model, alias) => {
     if (element) {
       if (element.virtual) {
         col.as = col.as || col.ref[col.ref.length - 1]
+        col.cast = { type: element._type }
         delete col.ref
         col.val = (element.default && element.default.val) || null
       }

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

@@ -1,5 +1,6 @@
 const { timestampToISO } = require('../data-conversion/timestamp')
 const { deepCopyObject } = require('../../common/utils/copy')
+const getError = require('../../common/error')
 
 function _arrayWithCount(a, count) {
   const _map = a.map
@@ -41,8 +42,8 @@ const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) =>
   const isoTs = timestampToISO(timestamp)
 
   if (query._streaming) {
-    if (!query.SELECT || (query.SELECT && (!query.SELECT.columns || query.SELECT.columns.length !== 1))) {
-      req.reject(400)
+    if (!query.SELECT || (query.SELECT && !query.SELECT.columns)) {
+      throw getError(500, 'Invalid SELECT statement for streaming')
     }
     return executeStreamCQN(model, dbc, query, user, locale, isoTs)
   }