@sap/cds 9.7.0 → 9.8.0

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

@@ -11,19 +11,19 @@ module.exports = cds.service.impl(function () {
   this.on(['CREATE', 'READ', 'UPDATE', 'UPSERT', 'DELETE'], '*', async function handle_crud_requests(req) {
 
     if (!cds.db)
-      return req.reject ('NO_DATABASE_CONNECTION') // REVISIT: error message
+      return req.reject('NO_DATABASE_CONNECTION') // REVISIT: error message
 
     if (!req.query)
-      return req.reject (501, 'The request has no query and cannot be served generically.')
+      return req.reject(501, 'The request has no query and cannot be served generically.')
 
     if (typeof req.query !== 'string' && req.target?._hasPersistenceSkip)
-      return req.reject (501, `Entity "${req.target.name}" is annotated with "@cds.persistence.skip" and cannot be served generically.`)
+      return req.reject(501, `Entity "${req.target.name}" is annotated with "@cds.persistence.skip" and cannot be served generically.`)
 
     // validate that all elements in path exist on db, if necessary
     // - INSERT has no where clause to do this in one roundtrip
     // - SELECT returns [] -> really empty collection or invalid path?
     const subject = req.query.INSERT?.into || req.query.SELECT?.from
-    const pathExistsQuery = subject?.ref?.length > 1 && SELECT(1).from({ ref: subject.ref.slice(0,-1) })
+    const pathExistsQuery = subject?.ref?.length > 1 && SELECT(1).from({ ref: subject.ref.slice(0, -1) })
 
     if (req.event === 'CREATE' && pathExistsQuery) {
       // REVISIT: Why dont't we just run the insert and check affected rows?
@@ -33,10 +33,10 @@ module.exports = cds.service.impl(function () {
 
     if (req.event in { DELETE: 1, UPDATE: 1 } && req.target?._isSingleton) {
       if (req.event === 'DELETE' && !req.target['@odata.singleton.nullable'])
-        return req.reject (400, 'SINGLETON_NOT_NULLABLE')
+        return req.reject(400, 'SINGLETON_NOT_NULLABLE')
 
       const selectSingleton = SELECT.one(req.target)
-      const keyColumns = [...(req.target.keys||[])].filter(e => !e.isAssociation).map(e => e.name)
+      const keyColumns = [...(req.target.keys || [])].filter(e => !e.isAssociation).map(e => e.name)
 
       // if no keys available, select all columns so we can delete the singleton with same content
       if (keyColumns.length) selectSingleton.columns(keyColumns)
@@ -54,7 +54,8 @@ module.exports = cds.service.impl(function () {
 
     if (req.event === 'READ' && req.query?.SELECT && req.locale) req.query.SELECT.localized ??= true
 
-    const result = await cds.run (req.query, req.data)
+    // REVISIT for cds^10: can we always use cds.db.dispatch(req)?
+    const result = req.iterator && !req.objectMode ? await cds.db.dispatch(req) : await cds.run(req.query, req.data)
 
     if (req.event === 'READ') {
       // do not execute additional select to distinguish between 412 and 404

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

@@ -50,6 +50,12 @@ const _addDefaultSortOrder = (req, select) => {
   )
 }
 
+const containsAggregation = column => {
+  if (column.func) return true
+  if (column.xpr) return column.xpr.some(xpr => containsAggregation(xpr))
+  return false
+}
+
 /**
  * 1. query options --> already set in req.query
  * 2. orders from view
@@ -63,9 +69,7 @@ const handle_sorting = function (req) {
   let select = req.query.SELECT
 
   // do not sort for /$count queries or queries only using aggregations
-  if (select.columns && select.columns.length && select.columns.every(col => col.func)) {
-    return
-  }
+  if (select.columns?.length && select.columns.every(col => containsAggregation(col))) return
 
   if (select.from && select.from.SELECT) {
     // add default sort to root query

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

@@ -53,15 +53,15 @@ const _inverseTransition = transition => {
   return inverseTransition
 }
 
-const revertData = (data, transition, service, options) => {
+const revertData = (data, transition, service) => {
   if (!transition || !transition.mapping.size) return data
   const inverseTransition = _inverseTransition(transition)
   return Array.isArray(data)
-    ? data.map(entry => _newData(entry, inverseTransition, true, service, options))
-    : _newData(data, inverseTransition, true, service, options)
+    ? data.map(entry => _newData(entry, inverseTransition, true, service))
+    : _newData(data, inverseTransition, true, service)
 }
 
-const _newSubData = (val, key, transition, el, inverse, service, options) => {
+const _newSubData = (val, key, transition, el, inverse, service, options = {}) => {
   if ((!Array.isArray(val) && typeof val === 'object') || (Array.isArray(val) && val.length !== 0)) {
     let mapped = transition.mapping.get(key)
     if (!mapped) {
@@ -70,7 +70,7 @@ const _newSubData = (val, key, transition, el, inverse, service, options) => {
     }
 
     if (!mapped.transition) {
-      const subTransition = getTransition(el._target, service, undefined, options?.event, { abort: options?.abort })
+      const subTransition = getTransition(el._target, service, null, options.event)
       mapped.transition = inverse ? _inverseTransition(subTransition) : subTransition
     }
 
@@ -196,7 +196,7 @@ const _newColumns = (columns = [], transition, service, withAlias = false, optio
 
       // reuse _newColumns with new transition
       const expandTarget = def._target
-      const subtransition = getTransition(expandTarget, service, undefined, options.event, { abort: options.abort })
+      const subtransition = getTransition(expandTarget, service, null, options.event)
       mapped.transition = subtransition
       newColumn.expand = _newColumns(column.expand, subtransition, service, withAlias, options)
     }
@@ -523,19 +523,26 @@ const _queryColumns = (target, columns = [], isAborted) => {
   return queryColumns
 }
 
-const _mappedValue = (col, alias) => {
+const _mappedValue = (col, alias, target) => {
   const key = col.as || col.ref[0]
 
   if (col.ref) {
-    const columnRef = col.ref.filter(columnName => columnName !== alias)
+    let columnRef = col.ref.filter(columnName => columnName !== alias)
+
+    if (columnRef.length > 1 && target) {
+      const firstElement = target.elements?.[columnRef[0]]
+      if (firstElement?.foreignKeys) {
+        // It's a managed association - use foreignKeys property to get the FK column name
+        if (columnRef[1] in firstElement.foreignKeys) columnRef = [`${firstElement.name}_${columnRef[1]}`]
+      }
+    }
+
     return [key, { ref: columnRef }]
   }
 
   return [key, { val: col.val }]
 }
 
-const getDBTable = target => cds.db.resolve.table(target)
-
 const _appendForeignKeys = (newColumns, target, columns, { as, ref = [] }) => {
   const el = target.elements[as] || target.query._target?.elements[ref.at(-1)]
 
@@ -578,26 +585,27 @@ const _checkForForbiddenViews = (queryTarget, event) => {
   }
 }
 
-const _getTransitionData = (target, columns, service, options) => {
-  let { abort, skipForbiddenViewCheck, event } = options
-  // REVISIT revert after cds-dbs pr
-  if (!abort) abort = service.resolve.abortDB
-  // REVISIT: Find less param polluting way to skip forbidden view check for reads
-  if (!skipForbiddenViewCheck) _checkForForbiddenViews(target, event)
-  const isAborted = abort(target)
+const _getTransitionData = (target, columns, service, event) => {
+  _checkForForbiddenViews(target, event)
+
+  const _dbAbort = target =>
+    !!(Object.prototype.hasOwnProperty.call(target, '@cds.persistence.table') || !target.query?._target)
+  const _defaultAbort = target => target._service?.name === service.definition?.name
+  const _abort = service.isDatabaseService ? _dbAbort : _defaultAbort
+
+  const isAborted = _abort(target)
   columns = _queryColumns(target, columns, isAborted)
 
   if (isAborted) return { target, transitionColumns: columns }
 
   if (!target.query?._target) {
     // for cross service in x4 and DRAFT.DraftAdministrativeData we cannot abort properly
-    // therefore return last resolved target
     if (cds.env.features.restrict_service_scope === false) return { target, transitionColumns: columns }
     return undefined
   } else {
     const newTarget = target.query._target
     // continue projection resolving for projections
-    return _getTransitionData(newTarget, columns, service, options)
+    return _getTransitionData(newTarget, columns, service, event)
   }
 }
 
@@ -606,24 +614,20 @@ const _getTransitionData = (target, columns, service, options) => {
  *
  * @param queryTarget
  * @param service
- * @param skipForbiddenViewCheck
+ * @param _dummy - unused positional argument (for db-service < 2.9)
+ * @param event
  */
-const getTransition = (queryTarget, service, skipForbiddenViewCheck, event, options) => {
+const getTransition = (queryTarget, service, _dummy, event) => {
   // Never resolve unknown targets (e.g. for drafts)
-  if (!queryTarget) {
-    return { target: queryTarget, queryTarget, mapping: new Map() }
-  }
+  if (!queryTarget) return { target: queryTarget, queryTarget, mapping: new Map() }
 
-  const transitionData = _getTransitionData(queryTarget, [], service, {
-    skipForbiddenViewCheck,
-    event,
-    abort: options?.abort
-  })
+  const transitionData = _getTransitionData(queryTarget, [], service, event)
   if (!transitionData) return undefined
   const { target: _target, transitionColumns } = transitionData
   const query = queryTarget.query
   const alias = query && query.SELECT && query.SELECT.from && query.SELECT.from.as
-  const mappedColumns = transitionColumns.map(column => _mappedValue(column, alias))
+  const mappingTarget = query?._target
+  const mappedColumns = transitionColumns.map(column => _mappedValue(column, alias, mappingTarget))
   const mapping = new Map(mappedColumns)
   return { target: _target, queryTarget, mapping }
 }
@@ -632,11 +636,7 @@ const _entityTransitionsForTarget = (from, model, service, options) => {
   let previousEntity = options.previousEntity
 
   if (typeof from === 'string') {
-    return (
-      model.definitions[from] && [
-        getTransition(model.definitions[from], service, undefined, options.event, { abort: options.abort })
-      ]
-    )
+    return model.definitions[from] && [getTransition(model.definitions[from], service, null, options.event)]
   }
 
   if (typeof from === 'object' && from.SELECT) {
@@ -651,7 +651,7 @@ const _entityTransitionsForTarget = (from, model, service, options) => {
       const entity = model.definitions[element]
       if (entity) {
         previousEntity = entity
-        return getTransition(entity, service, undefined, options.event, { abort: options.abort })
+        return getTransition(entity, service, null, options.event)
       }
     }
 
@@ -660,7 +660,7 @@ const _entityTransitionsForTarget = (from, model, service, options) => {
       if (entity) {
         // > assoc
         previousEntity = entity
-        return getTransition(entity, service, undefined, options.event, { abort: options.abort })
+        return getTransition(entity, service, null, options.event)
       }
 
       // > struct
@@ -674,7 +674,7 @@ const _entityTransitionsForTarget = (from, model, service, options) => {
   })
 }
 
-const resolveView = (query, model, service, abort) => {
+const resolveView = (query, model, service) => {
   // swap logger
   const _LOG = LOG
   LOG = cds.log(service.kind) // REVISIT: Avoid obtaining loggers per request!
@@ -699,7 +699,7 @@ const resolveView = (query, model, service, abort) => {
     DELETE: ['from', _newDelete]
   }[kind]
 
-  const options = { abort, event: kind, service, model }
+  const options = { event: kind, service, model }
   const transitions = _entityTransitionsForTarget(query[kind][_prop], model, service, options)
   if (!service.isDatabaseService && cds.env.features.restrict_service_scope !== false && transitions.some(t => !t))
     return
@@ -719,8 +719,15 @@ const resolveView = (query, model, service, abort) => {
   return newQuery
 }
 
+const _resolve_table = target => {
+  if (target.query?._target && !Object.prototype.hasOwnProperty.call(target, '@cds.persistence.table'))
+    return _resolve_table(target.query._target)
+  return target
+}
+
 module.exports = {
-  getDBTable,
+  // REVISIT: remove getDBTable with cds^10
+  getDBTable: _resolve_table,
   resolveView,
   getTransition,
   revertData

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

@@ -95,6 +95,7 @@ const rewriteExpandAsterisk = (columns, target) => {
 
     for (const elName in target.elements) {
       if (!target.elements[elName]._target) continue
+      if (target.elements[elName]._target?._service !== target._service) continue
       if (restrictions.includes(elName)) continue
       if (elName === 'SiblingEntity') continue
       if (columns.find(col => col.expand && col.ref && col.ref[0] === elName)) continue

package/libx/_runtime/fiori/lean-draft.js

@@ -6,6 +6,7 @@ const { Object_keys } = cds.utils
 const { Readable, PassThrough } = require('stream')
 
 const { getPageSize, commonGenericPaging } = require('../common/generic/paging')
+const { getPreferReturnHeader } = require('../../odata/utils')
 const { handler: commonGenericSorting } = require('../common/generic/sorting')
 const { addEtagColumns } = require('../common/utils/etag')
 const { handleStreamProperties } = require('../common/utils/streamProp')
@@ -710,7 +711,7 @@ const draftHandle = async function (req) {
   let newDraftAction = rootEntity['@Common.DraftRoot.NewAction']
   if (typeof newDraftAction != 'string' || !newDraftAction.length) newDraftAction = false
   else newDraftAction = newDraftAction.split('.').pop()
-  const shouldHandleNewDraftAction = isNewDraftViaActionEnabled && req.target === rootEntity
+  const shouldHandleNewDraftAction = isNewDraftViaActionEnabled && req.target.name === rootEntity.name
 
   // Create active instance of draft-enabled entity
   // REVISIT: New OData adapter only sets `NEW` for drafts... how to distinguish programmatic modifications?
@@ -781,7 +782,13 @@ const draftHandle = async function (req) {
     req.data = createNewResult
     req.res.status(201)
 
-    return _readAfterDraftAction.call(this, { req, payload: createNewResult, action: 'draftNew' })
+    const result = await _readAfterDraftAction.call(this, { req, payload: createNewResult, action: 'draftNew' })
+    if (result === null) req.res.status(204)
+    req.res.set(
+      'location',
+      '../' + location4(req.target.actives, this, result || { ...createNewResult, IsActiveEntity: false })
+    )
+    return result
   }
 
   // Handle draft-only events, that can only ever target entities in draft state
@@ -2442,6 +2449,8 @@ async function onPrepare(req, next) {
 }
 
 const _readAfterDraftAction = async function ({ req, payload, action }) {
+  if (getPreferReturnHeader(req) === 'minimal') return null
+
   const entity = action === 'draftActivate' ? req.target : req.target.drafts
 
   // read after write with query options

package/libx/_runtime/messaging/kafka.js

@@ -123,13 +123,14 @@ class KafkaService extends cds.MessagingService {
       eachMessage: async raw => {
         try {
           const msg = _normalizeIncomingMessage(raw.message.value.toString())
+
           msg.headers = {}
           for (const header in raw.message.headers || {}) {
             msg.headers[header] = raw.message.headers[header]?.toString()
           }
-          msg.event =
-            raw.message.headers['x-sap-cap-effective-topic']?.toString() ?? raw.message.headers.type?.toString()
-          msg.tenant = raw.message.headers['x-sap-cap-tenant-id']
+
+          msg.tenant = msg.headers['x-sap-cap-tenant-id']
+          msg.event = msg.headers['x-sap-cap-effective-topic'] ?? msg.headers.type
           if (!msg.event) return
 
           await this.processInboundMsg({ tenant: msg.tenant }, msg)
@@ -210,8 +211,8 @@ async function _getConfig(srv) {
   const caCerts = await _getCaCerts(srv)
 
   const allBrokers =
-    srv.options.credentials.cluster?.['brokers.client_ssl'] ||
-    srv.options.credentials['cluster.public']?.['brokers.client_ssl']
+    srv.options.credentials['cluster.public']?.['brokers.client_ssl'] ||
+    srv.options.credentials.cluster?.['brokers.client_ssl']
   const brokers = allBrokers.split(',')
 
   return {

package/libx/_runtime/remote/Service.js

@@ -45,7 +45,7 @@ const _buildPartialUrlFunctions = (url, data, params, kind = 'odata-v4') => {
     : `${url}(${funcParams.join(',')})?${queryOptions.join('&')}`
 }
 
-const _extractParamsFromData = (data, params = {}) => {
+const _extractParamsFromData = (data = {}, params = {}) => {
   return Object.keys(data).reduce((res, el) => {
     if (params[el]) Object.assign(res, { [el]: data[el] })
     return res
@@ -142,7 +142,16 @@ const _addHandlerActionFunction = (srv, def, target) => {
     srv.on(event, target, async function (req) {
       const shortEntityName = req.target.name.replace(`${this.definition.name}.`, '')
       if (this.kind === 'odata-v2') return _handleV2BoundActionFunction(srv, def, req, event, this.kind)
-      const url = `/${shortEntityName}(${_buildKeys(req, this.kind).join(',')})/${this.definition.name}.${event}`
+
+      const action = req.target.actions[req.event]
+      const onCollection = !!(
+        action['@cds.odata.bindingparameter.collection'] ||
+        (action?.params && [...action.params].some(p => p?.items?.type === '$self'))
+      )
+
+      const url = onCollection
+        ? `/${shortEntityName}/${this.definition.name}.${event}`
+        : `/${shortEntityName}(${_buildKeys(req, this.kind).join(',')})/${this.definition.name}.${event}`
       return _handleBoundActionFunction(srv, def, req, url)
     })
   } else {
@@ -240,6 +249,9 @@ class RemoteService extends cds.Service {
       const requestConfig = extractRequestConfig(req, query, this)
       requestConfig.headers = _getHeaders(requestConfig.headers, req)
 
+      if (this.kind === 'hcql' && req.iterator && !req.objectMode)
+        requestConfig.headers.accept = 'application/octet-stream,application/json'
+
       // REVISIT: we should not have to set the content-type at all for that
       if (requestConfig.headers.accept?.match(/stream|image|tar/)) requestConfig.responseType = 'stream'
 

package/libx/_runtime/remote/utils/client.js

@@ -43,9 +43,6 @@ const _executeHttpRequest = async ({ requestConfig, destination, destinationOpti
     else if (LOG._warn) LOG.warn('Missing JWT token for forwardAuthToken!')
   }
 
-  // Cloud SDK throws error if useCache is activated and jwt is undefined
-  if (destination.jwt === undefined) destination.useCache = false
-
   if (LOG._debug) _logRequest(requestConfig, destination)
 
   // cloud sdk requires a new mechanism to differentiate the priority of headers
@@ -250,7 +247,8 @@ module.exports.run = async (requestConfig, options) => {
   }
 
   const { kind, resolvedTarget, returnType } = options
-  if (kind === 'hcql') return response.data.data
+  if (kind === 'hcql')
+    return response.headers?.['content-type']?.includes('application/octet-stream') ? response.data : response.data.data
   if (kind === 'odata-v4') return _purgeODataV4(response.data)
   if (kind === 'odata-v2') return _purgeODataV2(response.data, resolvedTarget, returnType)
   if (kind === 'odata') {

package/libx/_runtime/remote/utils/query.js

@@ -26,11 +26,11 @@ const _cqnWithPublicEntries = query => {
 }
 
 const _cqnToHcqlRequestConfig = cqn => {
-  if (cqn.SELECT && cqn.SELECT.from) return { method: 'GET', data: { SELECT: _cqnWithPublicEntries(cqn.SELECT) } }
+  if (cqn.SELECT && cqn.SELECT.from) return { method: 'POST', data: { SELECT: _cqnWithPublicEntries(cqn.SELECT) } }
   if (cqn.INSERT && cqn.INSERT.into) return { method: 'POST', data: { INSERT: _cqnWithPublicEntries(cqn.INSERT) } }
-  if (cqn.UPDATE && cqn.UPDATE.entity) return { method: 'PATCH', data: { UPDATE: _cqnWithPublicEntries(cqn.UPDATE) } }
-  if (cqn.UPSERT && cqn.UPSERT.into) return { method: 'PUT', data: { UPSERT: _cqnWithPublicEntries(cqn.UPSERT) } }
-  if (cqn.DELETE && cqn.DELETE.from) return { method: 'DELETE', data: { DELETE: _cqnWithPublicEntries(cqn.DELETE) } }
+  if (cqn.UPDATE && cqn.UPDATE.entity) return { method: 'POST', data: { UPDATE: _cqnWithPublicEntries(cqn.UPDATE) } }
+  if (cqn.UPSERT && cqn.UPSERT.into) return { method: 'POST', data: { UPSERT: _cqnWithPublicEntries(cqn.UPSERT) } }
+  if (cqn.DELETE && cqn.DELETE.from) return { method: 'POST', data: { DELETE: _cqnWithPublicEntries(cqn.DELETE) } }
 
   cds.error(400, 'Invalid CQN object can not be processed.', JSON.stringify(cqn), _cqnToHcqlRequestConfig)
 }