@sap/cds 7.0.2 → 7.1.0

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

@@ -36,6 +36,7 @@ const _inverseTransition = transition => {
         const nested = inverseTransition.mapping.get(ref0) || {}
         if (!nested.transition) nested.transition = { mapping: new Map() }
         let current = nested.transition.mapping
+
         for (let i = 1; i < value.ref.length; i++) {
           const last = i === value.ref.length - 1
           const obj = last ? { ref: [key] } : { transition: { mapping: new Map() } }
@@ -63,16 +64,19 @@ const revertData = (data, transition, service) => {
 
 const _newSubData = (newData, key, transition, el, inverse, service) => {
   const val = newData[key]
+
   if ((!Array.isArray(val) && typeof val === 'object') || (Array.isArray(val) && val.length !== 0)) {
     let mapped = transition.mapping.get(key)
     if (!mapped) {
       mapped = {}
       transition.mapping.set(key, mapped)
     }
+
     if (!mapped.transition) {
       const subTransition = getTransition(el._target, service)
       mapped.transition = inverse ? _inverseTransition(subTransition) : subTransition
     }
+
     if (Array.isArray(val)) {
       newData[key] = val.map(singleVal => _newData(singleVal, mapped.transition, inverse, service))
     } else {
@@ -85,6 +89,7 @@ const _newNestedData = (queryTarget, newData, ref, value) => {
   const parent = queryTarget.query && queryTarget.query._target
   let currentEntity = parent
   let currentData = newData
+
   for (let i = 0; i < ref.length; i++) {
     currentEntity = currentEntity.elements[ref[i]]
     if (currentEntity.isAssociation) {
@@ -101,6 +106,7 @@ const _newNestedData = (queryTarget, newData, ref, value) => {
 // eslint-disable-next-line complexity
 const _newData = (data, transition, inverse, service) => {
   if (data === null) return null
+
   // no transition -> nothing to do
   if (transition.target && transition.target.name === transition.queryTarget.name) return data
 
@@ -109,8 +115,9 @@ const _newData = (data, transition, inverse, service) => {
   const queryTarget = transition.queryTarget
 
   for (const key in newData) {
-    const el = queryTarget && queryTarget.elements && queryTarget.elements[key]
+    const el = queryTarget && queryTarget?.elements[key]
     const isAssoc = el && el.isAssociation
+
     if (isAssoc) {
       if (newData[key] || (newData[key] === null && service.name === 'db')) {
         _newSubData(newData, key, transition, el, inverse, service)
@@ -136,6 +143,7 @@ const _newData = (data, transition, inverse, service) => {
       const value = newData[key]
       delete newData[key]
       const { ref } = mapped
+
       if (ref.length === 1) {
         newData[ref[0]] = value
         if (mapped.alternatives) mapped.alternatives.forEach(({ ref }) => (newData[ref[0]] = value))
@@ -159,6 +167,7 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
       newColumns.push(newColumn)
       return newColumns
     }
+
     const mapped = column.ref && transition.mapping.get(column.ref[0])
 
     if (mapped && mapped.ref) {
@@ -193,24 +202,31 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
       const expandTarget = def._target
       const subtransition = getTransition(expandTarget, service)
       mapped.transition = subtransition
-
       newColumn.expand = _newColumns(column.expand, subtransition, service, withAlias)
     }
+
     newColumns.push(newColumn)
   })
 
   return newColumns
 }
 
+const _resolveColumn = (column, transition) => {
+  const mapped = transition.mapping.get(column)
+  if (mapped && mapped.ref) {
+    return mapped.ref[0]
+  } else if (!mapped) {
+    return column
+  }
+}
+
 const _newInsertColumns = (columns = [], transition) => {
   const newColumns = []
 
   columns.forEach(column => {
-    const mapped = transition.mapping.get(column)
-    if (mapped && mapped.ref) {
-      newColumns.push(mapped.ref[0])
-    } else if (!mapped) {
-      newColumns.push(column)
+    const resolvedColumn = _resolveColumn(column, transition)
+    if (resolvedColumn) {
+      newColumns.push(resolvedColumn)
     }
   })
 
@@ -220,6 +236,7 @@ const _newInsertColumns = (columns = [], transition) => {
 // REVISIT: this hard-coding on ref indexes does not support path expressions
 const _newWhereRef = (newWhereElement, transition, alias, tableName, isSubSelect) => {
   const newRef = Array.isArray(newWhereElement.ref) ? [...newWhereElement.ref] : [newWhereElement.ref]
+
   if (newRef[0] === alias) {
     const mapped = transition.mapping.get(newRef[1])
     if (mapped) newRef[1] = mapped.ref[0]
@@ -236,6 +253,7 @@ const _newWhereRef = (newWhereElement, transition, alias, tableName, isSubSelect
       if (mapped) newRef[0] = mapped.ref[0]
     }
   }
+
   newWhereElement.ref = newRef
 }
 
@@ -250,20 +268,23 @@ const _newWhere = (where = [], transition, tableName, alias, isSubselect = false
 
     const newWhereElement = { ...whereElement }
     if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
+
     if (whereElement.SELECT && whereElement.SELECT.where && !whereElement._doNotResolve) {
       newWhereElement.SELECT.where = _newWhere(whereElement.SELECT.where, transition, tableName, alias, true)
       return newWhereElement
-    } else {
-      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
-      }
     }
+
+    if (newWhereElement.ref) {
+      _newWhereRef(newWhereElement, transition, alias, tableName, isSubselect)
+      return newWhereElement
+    }
+
+    if (newWhereElement.func) {
+      newWhereElement.args = _newWhere(newWhereElement.args, transition, tableName, alias)
+      return newWhereElement
+    }
+
+    return whereElement
   })
 
   return newWhere
@@ -277,6 +298,7 @@ const _initialColumns = transition => {
     if (!transition.queryTarget.elements[transitionEl] || transition.queryTarget.elements[transitionEl].isAssociation) {
       continue
     }
+
     columns.push({ ref: [transitionEl] })
   }
 
@@ -318,9 +340,10 @@ const _rewriteQueryPath = (path, transitions) => {
 }
 
 const _newUpdate = (query, transitions, service) => {
-  const targetTransition = transitions[transitions.length - 1]
+  const targetTransition = transitions.at(-1)
   const targetName = targetTransition.target.name
   const newUpdate = Object.create(query.UPDATE)
+
   newUpdate.entity = newUpdate.entity.ref
     ? {
         ...newUpdate.entity,
@@ -341,16 +364,18 @@ const _newUpdate = (query, transitions, service) => {
     enumerable: false,
     value: transitions
   })
+
   return newUpdate
 }
 
 const _newSelect = (query, transitions, service) => {
-  const targetTransition = transitions[transitions.length - 1]
+  const targetTransition = transitions.at(-1)
   const newSelect = Object.create(query.SELECT)
   newSelect.from = {
     ...newSelect.from,
     ref: _rewriteQueryPath(query.SELECT.from, transitions)
   }
+
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
   if (newSelect.columns) {
     rewriteAsterisks({ SELECT: query.SELECT }, service.model, {
@@ -359,6 +384,7 @@ const _newSelect = (query, transitions, service) => {
     })
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
   }
+
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)
   if (newSelect.groupBy) newSelect.groupBy = _newColumns(newSelect.groupBy, targetTransition)
   if (newSelect.orderBy) newSelect.orderBy = _newColumns(newSelect.orderBy, targetTransition)
@@ -370,17 +396,42 @@ const _newSelect = (query, transitions, service) => {
       query.SELECT.from && query.SELECT.from.as
     )
   }
+
   Object.defineProperty(newSelect, '_transitions', {
     enumerable: false,
     value: transitions
   })
+
   return newSelect
 }
 
+const _newStream = (query, transitions) => {
+  const targetTransition = transitions[transitions.length - 1]
+  const targetName = targetTransition.target.name
+  const newStream = Object.create(query.STREAM)
+  if (newStream.into) {
+    const refObject = newStream.into.ref ? newStream.into : { ref: [query.STREAM.into] }
+    newStream.into = {
+      ...refObject,
+      ref: _rewriteQueryPath(refObject, transitions)
+    }
+    if (!query.STREAM.into.ref) newStream.into = newStream.into.ref[0] // leave as string
+  } else {
+    newStream.into = targetName
+  }
+  if (newStream.column) newStream.column = _resolveColumn([newStream.column], targetTransition)
+  Object.defineProperty(newStream, '_transitions', {
+    enumerable: false,
+    value: transitions
+  })
+  return newStream
+}
+
 const _newInsert = (query, transitions, service) => {
   const targetTransition = transitions[transitions.length - 1]
   const targetName = targetTransition.target.name
   const newInsert = Object.create(query.INSERT)
+
   if (newInsert.into) {
     const refObject = newInsert.into.ref ? newInsert.into : { ref: [query.INSERT.into] }
     newInsert.into = {
@@ -391,12 +442,14 @@ const _newInsert = (query, transitions, service) => {
   } else {
     newInsert.into = targetName
   }
+
   if (newInsert.columns) newInsert.columns = _newInsertColumns(newInsert.columns, targetTransition)
   if (newInsert.entries) newInsert.entries = _newEntries(newInsert.entries, targetTransition, service)
   Object.defineProperty(newInsert, '_transitions', {
     enumerable: false,
     value: transitions
   })
+
   return newInsert
 }
 
@@ -404,6 +457,7 @@ const _newUpsert = (query, transitions, service) => {
   const targetTransition = transitions[transitions.length - 1]
   const targetName = targetTransition.target.name
   const newUpsert = Object.create(query.UPSERT)
+
   newUpsert.into = newUpsert.into.ref
     ? {
         ...newUpsert.into,
@@ -416,6 +470,7 @@ const _newUpsert = (query, transitions, service) => {
     enumerable: false,
     value: transitions
   })
+
   return newUpsert
 }
 
@@ -423,12 +478,14 @@ const _newDelete = (query, transitions) => {
   const targetTransition = transitions[transitions.length - 1]
   const targetName = targetTransition.target.name
   const newDelete = Object.create(query.DELETE)
+
   newDelete.from = newDelete.from.ref
     ? {
         ...newDelete.from,
         ref: _rewriteQueryPath(query.DELETE.from, transitions)
       }
     : targetName
+
   if (newDelete.where) {
     newDelete.where = _newWhere(
       newDelete.where,
@@ -437,10 +494,12 @@ const _newDelete = (query, transitions) => {
       query.DELETE.from.as
     )
   }
+
   Object.defineProperty(newDelete, '_transitions', {
     enumerable: false,
     value: transitions
   })
+
   return newDelete
 }
 
@@ -451,32 +510,41 @@ const _findRenamed = (cqnColumns, column) =>
   cqnColumns.find(
     cqnColumn =>
       cqnColumn.as &&
-      ((column.ref && column.ref[column.ref.length - 1] === cqnColumn.as) ||
+      (column?.ref?.at(-1) === cqnColumn.as ||
         (column.as === cqnColumn.as && Object.prototype.hasOwnProperty.call(cqnColumn, 'val')))
   )
 
 const _queryColumns = (target, columns = [], persistenceTable = false, force = false) => {
   if (!(target && target.query && target.query.SELECT)) return columns
+
   const cqnColumns = target.query.SELECT.columns || []
   const from = target.query.SELECT.from
-  const isTargetAliased = from.as && cqnColumns.some(c => c.ref && c.ref[0] === from.as)
+  const isTargetAliased = from.as && cqnColumns.some(c => c.ref?.[0] === from.as)
+
   if (!columns.length) columns = Object.keys(target.elements).map(e => ({ ref: [e], as: e }))
-  return columns.reduce((res, column) => {
+
+  const queryColumns = columns.reduce((res, column) => {
     const renamed = _findRenamed(cqnColumns, column)
+
     if (renamed) {
       if (renamed.val) return res.concat({ as: renamed.as, val: renamed.val })
+
       // There could be some `where` clause inside `ref` which we don't support yet
       if (!renamed.ref || renamed.ref.some(e => typeof e !== 'string') || renamed.xpr) return res
       if (isTargetAliased) renamed.ref.shift()
+
       // If the entity is annotated with the annotation `@cds.persistence.table`
       // and elements aliases exist, the aliases must be used as column references.
       // The reason is that in this scenario, the cds compiler generate a table
       // instead of a view. If forced, skip this.
       column.ref = !force && persistenceTable ? [renamed.as] : [...renamed.ref]
     }
+
     res.push(column)
     return _appendForeignKeys(res, target, columns, column)
   }, [])
+
+  return queryColumns
 }
 
 const _mappedValue = (col, alias) => {
@@ -498,7 +566,8 @@ const getDBTable = target => {
 }
 
 const _appendForeignKeys = (newColumns, target, columns, { as, ref = [] }) => {
-  const el = target.elements[as] || target.query._target.elements[ref[ref.length - 1]]
+  const el = target.elements[as] || target.query._target.elements[ref.at(-1)]
+
   if (el && el.isAssociation && el.keys) {
     for (const key of el.keys) {
       // .as and .ref has a different meaning here
@@ -506,6 +575,7 @@ const _appendForeignKeys = (newColumns, target, columns, { as, ref = [] }) => {
       const keyName = key.as || key.ref[0]
       const keyAlias = key.ref[0]
       const found = columns.find(col => col.as === `${as}_${keyAlias}`)
+
       if (found) {
         found.ref = [`${ref.join('_')}_${keyName}`]
       } else {
@@ -516,11 +586,13 @@ const _appendForeignKeys = (newColumns, target, columns, { as, ref = [] }) => {
       }
     }
   }
+
   return newColumns
 }
 
 const _checkForForbiddenViews = queryTarget => {
   const select = queryTarget && queryTarget.query && queryTarget.query.SELECT
+
   if (select) {
     if (!select.from || select.from.join || select.from.length > 1) {
       throw getError({
@@ -529,6 +601,7 @@ const _checkForForbiddenViews = queryTarget => {
         target: queryTarget.name
       })
     }
+
     if (select.where) {
       LOG._debug &&
         LOG.debug(`Ignoring where clause during ${_event || 'INSERT|UPDATE|DELETE'} on view "${queryTarget.name}".`)
@@ -543,22 +616,28 @@ const _getTransitionData = (target, columns, service, skipForbiddenViewCheck) =>
   const persistenceTable = _isPersistenceTable(target)
   const isDatabaseService = service.isDatabaseService
   columns = _queryColumns(target, columns, persistenceTable, !isDatabaseService && !targetStartsWithSrvName)
+
   // REVISIT: Change once we expose database service
   if (persistenceTable && isDatabaseService) {
     return { target, transitionColumns: columns }
   }
+
   // stop projection resolving if it starts with the service name prefix
   if (!isDatabaseService && targetStartsWithSrvName) {
     return { target, transitionColumns: columns }
   }
+
   // continue projection resolving if the target is a projection
   if (target.query && target.query._target) {
     const newTarget = target.query._target
+
     if (isDatabaseService || !(service.namespace && newTarget.name.startsWith(`${service.namespace}.`))) {
       return _getTransitionData(newTarget, columns, service, skipForbiddenViewCheck)
     }
+
     return { target: newTarget, transitionColumns: columns }
   }
+
   return { target, transitionColumns: columns }
 }
 
@@ -607,14 +686,14 @@ const _entityTransitionsForTarget = (from, model, service) => {
         // > assoc
         previousEntity = entity
         return getTransition(entity, service)
-      } else {
-        // > struct
-        previousEntity = previousEntity.elements[element]
-        return {
-          target: previousEntity,
-          queryTarget: previousEntity,
-          mapping: new Map()
-        }
+      }
+
+      // > struct
+      previousEntity = previousEntity.elements[element]
+      return {
+        target: previousEntity,
+        queryTarget: previousEntity,
+        mapping: new Map()
       }
     }
   })
@@ -626,7 +705,8 @@ const _newQuery = (query, event, model, service) => {
     INSERT: ['into', _newInsert],
     UPSERT: ['into', _newUpsert],
     UPDATE: ['entity', _newUpdate],
-    DELETE: ['from', _newDelete]
+    DELETE: ['from', _newDelete],
+    STREAM: ['into', _newStream]
   }[event]
   const newQuery = Object.create(query)
   const transitions = _entityTransitionsForTarget(query[event][_prop], model, service)
@@ -647,13 +727,13 @@ const resolveView = (query, model, service) => {
   else if (query.UPSERT) _event = 'UPSERT'
   else if (query.UPDATE) _event = 'UPDATE'
   else if (query.DELETE) _event = 'DELETE'
+  else if (query.STREAM) _event = 'STREAM'
 
   const newQuery = _newQuery(query, _event, model, service)
 
   // restore logger and clear _event
   LOG = _LOG
   _event = undefined
-
   return newQuery
 }
 
@@ -664,10 +744,10 @@ const resolveView = (query, model, service) => {
  * @param {*} req
  */
 const restoreLink = req => {
-  if (req.query.INSERT && req.query.INSERT.entries) {
+  if (req.query.INSERT?.entries) {
     if (Array.isArray(req.query.INSERT.entries)) req.data = req.query.INSERT.entries[0]
     else req.data = req.query.INSERT.entries
-  } else if (req.query.UPDATE && req.query.UPDATE.data) {
+  } else if (req.query.UPDATE?.data) {
     req.data = req.query.UPDATE.data
   }
 }

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

@@ -27,7 +27,28 @@ const _expandColumn = (column, target, _4db) => {
   return column
 }
 
+const _resolveTarget = (ref, target) => {
+  if (ref.length > 1) {
+    if (target.elements[ref[0]]) {
+      // structured
+      return _resolveTarget(ref.slice(1), target.elements[ref[0]])
+    } else {
+      // in case there is an alias, try with the next entry
+      return _resolveTarget(ref.slice(1), target)
+    }
+  } else {
+    return target.elements[ref[0].id || ref[0]]._target
+  }
+}
+
 const rewriteExpandAsterisk = (columns, target) => {
+  // check all nested expands to resolve nested expand asterisks first
+  for (const column of columns) {
+    if (column.expand && column.ref) {
+      rewriteExpandAsterisk(column.expand, _resolveTarget(column.ref, target))
+    }
+  }
+
   const expandAllColIdx = columns.findIndex(col => {
     if (col.ref || !col.expand) return
     return col.expand.includes('*')

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

@@ -20,7 +20,7 @@ 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.
-  if (typeof search2cqn4sql === 'function' && entity.associations?.localized && !aggregated) {
+  if (typeof search2cqn4sql === 'function' && entity?.associations?.localized && !aggregated) {
     const search2cqnOptions = { columns: computeColumnsToBeSearched(query, entity), locale: options.locale }
     return search2cqn4sql(query, entity, search2cqnOptions)
   }

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

@@ -3,10 +3,12 @@ const { generateAliases } = require('../utils/generateAliases')
 const { restoreLink } = require('../../common/utils/resolveView')
 
 const _isLinked = req => {
-  if (req.query.INSERT && req.query.INSERT.entries) {
+  if (req.query.INSERT?.entries) {
     if (Array.isArray(req.query.INSERT.entries)) return req.data === req.query.INSERT.entries[0]
-    else return req.data === req.query.INSERT.entries
-  } else if (req.query.UPDATE && req.query.UPDATE.data) {
+    return req.data === req.query.INSERT.entries
+  }
+
+  if (req.query.UPDATE?.data) {
     return req.data === req.query.UPDATE.data
   }
 }
@@ -36,7 +38,6 @@ function handler(req) {
   if (linked) restoreLink(req)
 
   if (streaming) req.query._streaming = streaming
-
   generateAliases(req.query)
 }
 

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

@@ -45,6 +45,7 @@ const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) =>
     if (!query.SELECT || (query.SELECT && !query.SELECT.columns)) {
       throw getError(500, 'Invalid SELECT statement for streaming')
     }
+
     return executeStreamCQN(model, dbc, query, user, locale, isoTs)
   }
 
@@ -55,20 +56,20 @@ const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) =>
     if (query.SELECT.limit) {
       const countQuery = _createCountQuery(query)
       const countResultPromise = executeSelectCQN(model, dbc, countQuery, user, locale, isoTs)
-      if (query.SELECT.limit.rows && query.SELECT.limit.rows.val === 0) {
+      if (query.SELECT.limit?.rows?.val === 0) {
         // We don't need to perform our result query
         return countResultPromise.then(countResults => _arrayWithCount([], countValue(countResults)))
-      } else {
-        const resultPromise = executeSelectCQN(model, dbc, query, user, locale, isoTs)
-        return Promise.all([countResultPromise, resultPromise]).then(([countResults, result]) =>
-          _arrayWithCount(result, countValue(countResults))
-        )
       }
-    } else {
-      return executeSelectCQN(model, dbc, query, user, locale, isoTs).then(result =>
-        _arrayWithCount(result, result.length)
+
+      const resultPromise = executeSelectCQN(model, dbc, query, user, locale, isoTs)
+      return Promise.all([countResultPromise, resultPromise]).then(([countResults, result]) =>
+        _arrayWithCount(result, countValue(countResults))
       )
     }
+
+    return executeSelectCQN(model, dbc, query, user, locale, isoTs).then(result =>
+      _arrayWithCount(result, result.length)
+    )
   }
 
   return executeSelectCQN(model, dbc, query, user, locale, isoTs)

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

@@ -19,14 +19,13 @@ const _getFilteredCqns = (cqns, model) => {
     const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
     if (!entity) continue
 
-    /*
-     * do not filter if:
-     * - there is a propterty that is not managed or managed but filled by custom handler (i.e., its value doesn't start with $)
-     * - a composition target is updated as well
-     */
+    // do not filter if:
+    // - there is a property that is not managed or managed but filled by custom handler (i.e., its value doesn't start
+    // with $) a composition target is updated as well
     let moreThanManaged = Object.keys(cqn.UPDATE.data).some(
-      k => entity.elements[k]['@cds.on.update'] === undefined || !cqn.UPDATE.data[k].startsWith('$')
+      key => entity.elements[key]['@cds.on.update'] === undefined || !cqn.UPDATE.data[key]?.startsWith('$')
     )
+
     if (moreThanManaged) continue
 
     const comps = Object.values(entity.associations || {}).filter(assoc => assoc.isComposition)
@@ -36,6 +35,7 @@ const _getFilteredCqns = (cqns, model) => {
         break
       }
     }
+
     if (moreThanManaged) continue
 
     // remove current cqn
@@ -50,16 +50,8 @@ const update = executeUpdateCQN => async (model, dbc, req) => {
   const isoTs = normalizeTimestamp(timestamp)
 
   if (model && hasDeepUpdate(model, query)) {
-    // REVISIT: _activeData gets set in case of draftActivate for performance, but this is a layer violation
-    let selectData = req._ && req._.query && req._.query._activeData
-
-    if (selectData) {
-      selectData = [selectData]
-    } else {
-      // REVISIT: avoid additional read
-      selectData = await selectDeepUpdateData(cds.db, model, req)
-    }
-
+    // REVISIT: avoid additional read
+    const selectData = await selectDeepUpdateData(cds.db, model, req)
     let cqns = await getDeepUpdateCQNs(model, req, selectData)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
@@ -70,11 +62,10 @@ const update = executeUpdateCQN => async (model, dbc, req) => {
     cqns = _getFilteredCqns(getFlatArray(cqns), model)
 
     if (cqns.length === 0) return 0
-
     const results = await processCQNs(executeUpdateCQN, cqns, model, dbc, user, locale, isoTs, chunks)
+
     // return number of affected rows of "root cqn", if an update, 1 otherwise (as not update of root but its children)
     if (cqns[0].UPDATE) return results[0]
-
     return 1
   }
 

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

@@ -3,9 +3,11 @@ const _flattenDeep = (arr, res) => {
     res.push(arr)
     return res
   }
+
   for (const a of arr) {
     _flattenDeep(a, res)
   }
+
   return res
 }
 
@@ -20,20 +22,18 @@ async function _processChunk(processFn, model, dbc, cqns, user, locale, ts, inde
   const promisesResults = await Promise.allSettled(promises)
   const firstRejected = promisesResults.find(r => r.status === 'rejected')
   if (firstRejected) throw firstRejected.reason
+
   // put results of queries into correct place of return results
   for (let i = 0; i < promisesResults.length; i++) results[indexes[i]] = promisesResults[i].value
 }
 
+// execute deletes first, but keep results in order of cqns
 async function processCQNs(processFn, cqns, model, dbc, user, locale, ts, chunks) {
-  /*
-   * execute deletes first, but keep results in order of cqns
-   */
-
   const results = new Array(cqns.length)
-
   const deletes = []
   const updatesForDeletes = []
   const others = []
+
   for (let i = 0; i < cqns.length; i++) {
     if (cqns[i].DELETE) deletes.push(i)
     else if (cqns[i].__4delete) updatesForDeletes.push(i)
@@ -43,6 +43,7 @@ async function processCQNs(processFn, cqns, model, dbc, user, locale, ts, chunks
   if (deletes.length > 0) {
     if (chunks) {
       let offset = 0
+
       for (const amount of chunks) {
         const indexes = deletes.slice(offset, offset + amount)
         await _processChunk(processFn, model, dbc, cqns, user, locale, ts, indexes, results)

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

@@ -16,7 +16,7 @@ const _isToConvert = type => type === 'cds.DateTime' || type === 'cds.Timestamp'
 
 const _convertDateTimeEntry = (entry, element, model) => {
   const { name, type, _target } = element
-  if (!(entry[name] === undefined || entry[name] === null)) {
+  if (!(entry[name] == null)) {
     if (_isToConvert(type) && entry[name] !== '$now') {
       entry[name] = _convertDateTimeElement(entry[name], element)
     }