@sap/cds 7.9.4 → 8.0.4

package/libx/odata/middleware/create.js

@@ -1,29 +1,27 @@
 const cds = require('../../../')
 const { INSERT } = cds.ql
 
-const { toODataResult, postProcess } = require('../utils/result')
-const {
-  calculateLocationHeader,
-  getKeysAndParamsFromPath,
-  handleSapMessages,
-  getPreferReturnHeader
-} = require('../utils')
-const { getDeepSelect, getSimpleSelectCQN } = require('../utils/handler')
-
-const { deepCopy } = require('../../_runtime/common/utils/copy')
-
-const readAfterWrite = require('../utils/readAfterWrite')
-const metaInfo = require('../utils/metaInfo')
-
-module.exports = srv =>
-  function create(req, res, next) {
+const { calculateLocationHeader, handleSapMessages, getPreferReturnHeader } = require('../utils')
+const getODataMetadata = require('../utils/metadata')
+const postProcess = require('../utils/postProcess')
+const readAfterWrite4 = require('../utils/readAfterWrite')
+const getODataResult = require('../utils/result')
+
+const { getKeysAndParamsFromPath } = require('../../common/utils')
+
+module.exports = (adapter, isUpsert) => {
+  // REVISIT: adapter should be this
+  const { service } = adapter
+  const _readAfterWrite = readAfterWrite4(adapter, 'create')
+
+  return function create(req, res, next) {
     const {
       SELECT: { one, from },
       target
     } = req._query
 
     // req.__proto__.method is set in case of upsert
-    const isUpsert = req.__proto__.method in { PUT: 1, PATCH: 1 }
+    // const isUpsert = req.__proto__.method in { PUT: 1, PATCH: 1 }
 
     if (one && !isUpsert) {
       const msg = 'Method POST is not allowed for singletons and individual entities'
@@ -31,18 +29,12 @@ module.exports = srv =>
     }
 
     // payload & params
-    const data = deepCopy(req.body)
-    const { keys, params } = getKeysAndParamsFromPath(from, srv)
+    const data = req.body
+    const { keys, params } = getKeysAndParamsFromPath(from, service)
     // add keys from url into payload (overwriting if already present)
     Object.assign(data, keys)
 
-    // assert payload
-    const assertOptions = { filter: true, http: { req }, mandatories: true }
-    const errs = cds.assert(data, target, assertOptions)
-    if (errs) {
-      if (errs.length === 1) throw errs[0]
-      throw Object.assign(new Error('MULTIPLE_ERRORS'), { statusCode: 400, details: errs })
-    }
+    const _isDraft = target.drafts && data.IsActiveEntity !== true
 
     // query
     const query = INSERT.into(from).entries(data)
@@ -51,56 +43,49 @@ module.exports = srv =>
     const headers = { ...cds.context.http.req.headers, ...req.headers }
 
     // we need a cds.Request for multiple reasons, incl. params, headers, sap-messages, read after write, ...
-    const cdsReq = new cds.Request({ query, params, headers, req, res })
-    Object.defineProperty(cdsReq, 'protocol', { value: 'odata-v4' })
-
-    // API for subrequests of $batch (or incoming request)
-    cdsReq.req = req
-    cdsReq.res = res
+    const cdsReq = adapter.request4({ query, params, headers, req, res })
 
     // rewrite event for draft-enabled entities
-    if (target._isDraftEnabled) cdsReq.event = 'NEW'
-
-    // REVISIT: only via srv.run in combination with srv.dispatch inside
-    //          we automatically either use a single auto-managed tx for the req (i.e., insert and read after write in same tx)
-    //          or the auto-managed tx opened for the respective atomicity group, if exists
-    return srv
+    if (_isDraft) cdsReq.event = 'NEW'
+
+    // NOTES:
+    // - only via srv.run in combination with srv.dispatch inside,
+    //   we automatically either use a single auto-managed tx for the req (i.e., insert and read after write in same tx)
+    //   or the auto-managed tx opened for the respective atomicity group, if exists
+    // - in the then block of .run(), the transaction is committed (i.e., before sending the response) if a single auto-managed tx is used
+    return service
       .run(() => {
-        return srv.dispatch(cdsReq).then(result => {
-          handleSapMessages(cdsReq, req, res)
-
+        return service.dispatch(cdsReq).then(result => {
+          // REVISIT: shouldn't read after write be the default behavior (that could be suppressed)?
           // generic handlers indicate that read after write is required
-          if (cdsReq._.readAfterWrite) {
-            // const keys = cdsReq.target.keys?.filter(k => !k.isAssociation)?.reduce((prev, k) => { prev[k] = result[k]; return prev}, {}  )
-            // const query = SELECT.one(cdsReq.query.INSERT.into, keys)
-            const query = cdsReq.event === 'NEW' ? getSimpleSelectCQN(cdsReq.target, result) : getDeepSelect(cdsReq)
-            return readAfterWrite(cdsReq, srv, query)
-          }
-
+          if (cdsReq._.readAfterWrite) return _readAfterWrite(cdsReq)
           return result
         })
       })
       .then(result => {
-        // we use an extra then block, after getting the result, so the transaction is commited, before sending the response
-
-        // determine calculation based on result with req.data as fallback
-        if (!target._isSingleton)
-          res.set('location', calculateLocationHeader(cdsReq.target, srv, result || cdsReq.data))
+        handleSapMessages(cdsReq, req, res)
 
+        // case: read after write returns no results, e.g., due to auth (academic but possible)
         if (result == null) return res.sendStatus(204)
-        const isMinimal = getPreferReturnHeader(req) === 'minimal'
-        postProcess(cdsReq.target, srv, result, isMinimal)
 
-        if (result['$etag']) res.set('etag', result['$etag'])
+        if (!target._isSingleton) {
+          // determine calculation based on result with req.data as fallback
+          res.set('location', calculateLocationHeader(cdsReq.target, service, result || cdsReq.data))
+        }
+
+        const isMinimal = getPreferReturnHeader(req) === 'minimal'
+        postProcess(cdsReq.target, service, result, isMinimal)
+        if (result?.$etag) res.set('ETag', result.$etag) //> must be done after post processing
         if (isMinimal) return res.sendStatus(204)
 
-        const info = metaInfo(query, 'CREATE', srv, result, req)
-        result = toODataResult(result, info)
-        res.set('content-type', 'application/json;IEEE754Compatible=true')
+        const metadata = getODataMetadata(query, { result })
+        result = getODataResult(result, metadata)
         res.status(201).send(result)
       })
       .catch(err => {
         handleSapMessages(cdsReq, req, res)
+
         next(err)
       })
   }
+}

package/libx/odata/middleware/delete.js

@@ -1,10 +1,14 @@
 const cds = require('../../../')
 const { UPDATE, DELETE } = cds.ql
 
-const { getKeysAndParamsFromPath, handleSapMessages, getPreferReturnHeader } = require('../utils')
+const { handleSapMessages, getPreferReturnHeader } = require('../utils')
 
-module.exports = srv =>
-  function deleete(req, res, next) {
+const { getKeysAndParamsFromPath } = require('../../common/utils')
+
+module.exports = adapter => {
+  const { service } = adapter
+
+  return function deleet(req, res, next) {
     if (getPreferReturnHeader(req)) {
       const msg = "The 'return' preference is not allowed in DELETE requests"
       throw Object.assign(new Error(msg), { statusCode: 400 })
@@ -22,7 +26,7 @@ module.exports = srv =>
     }
 
     // payload & params
-    const { keys, params } = getKeysAndParamsFromPath(from, srv)
+    const { keys, params } = getKeysAndParamsFromPath(from, service)
     const data = keys //> for read and delete, we provide keys in req.data
     if (_propertyAccess) data[_propertyAccess] = null //> delete of property -> set to null
 
@@ -33,18 +37,23 @@ module.exports = srv =>
     const headers = { ...cds.context.http.req.headers, ...req.headers }
 
     // we need a cds.Request for multiple reasons, incl. params, headers, sap-messages, read after write, ...
-    const cdsReq = new cds.Request({ query, data, headers, params, req, res })
-    Object.defineProperty(cdsReq, 'protocol', { value: 'odata-v4' })
-
-    // API for subrequests of $batch (or incoming request)
-    cdsReq.req = req
-    cdsReq.res = res
+    const cdsReq = adapter.request4({ query, data, headers, params, req, res })
 
     // rewrite event for draft-enabled entities
     if (target._isDraftEnabled && cdsReq.data.IsActiveEntity === false) cdsReq.event = 'CANCEL'
 
-    return srv
-      .dispatch(cdsReq)
+    // NOTES:
+    // - only via srv.run in combination with srv.dispatch inside,
+    //   we automatically either use a single auto-managed tx for the req (i.e., insert and read after write in same tx)
+    //   or the auto-managed tx opened for the respective atomicity group, if exists
+    // - in the then block of .run(), the transaction is committed (i.e., before sending the response) if a single auto-managed tx is used
+    return service
+      .run(() => {
+        return service.dispatch(cdsReq).then(result => {
+          // nothing to do
+          return result
+        })
+      })
       .then(() => {
         handleSapMessages(cdsReq, req, res)
 
@@ -52,6 +61,8 @@ module.exports = srv =>
       })
       .catch(err => {
         handleSapMessages(cdsReq, req, res)
+
         next(err)
       })
   }
+}

package/libx/odata/middleware/error.js

@@ -1,9 +1,33 @@
-const { normalizeError } = require('../../_runtime/common/error/frontend')
+const cds = require('../../../lib')
 
-module.exports = _srv =>
-  function error(err, req, res, _next) {
-    const { error, statusCode } = normalizeError(err, req)
+const _log = require('../../_runtime/common/error/log')
 
-    // NOTE: normalizeError already does sanatization -> we can use as is
-    res.status(statusCode).json({ error })
+const { normalizeError, unwrapMultipleErrors } = require('../../_runtime/common/error/frontend')
+
+module.exports = () => {
+  return function odata_error(err, req, res, next) {
+    if (err == 401 || err.code == 401) return next(err) // speed up logins, at least temporary until we reviewed and eliminated overhead that may be involved below
+    // REVISIT: keep?
+    // log the error (4xx -> warn)
+    _log(err)
+
+    const { error, statusCode } = normalizeError(err, req) // REVISIT: that's killing error objects and stacks -> get rid of it
+
+    const content_id = req.headers['content-id']
+    if (content_id) {
+      error['@Core.ContentID'] = content_id
+      error.details?.forEach(e => (e['@Core.ContentID'] = content_id))
+    }
+
+    if (error.details && cds.env.fiori.wrap_multiple_errors === false) {
+      unwrapMultipleErrors(error)
+    }
+
+    // NOTE: express also looks for numbers in err.status or err.statusCode
+    error.statusCode = statusCode
+    // if (err.stack) Object.defineProperty (error, 'stack', { value: err.stack })
+    // REVISIT: we can't do that ^^^^^ currently because the _http_common parsers we use for $batch requests can't handle that
+
+    next(error)
   }
+}

package/libx/odata/middleware/metadata.js

@@ -6,6 +6,7 @@ const crypto = require('crypto')
 const _requestedFormat = (queryOption, header) => {
   if (queryOption) return queryOption.match(/json/i) ? 'json' : 'xml'
   if (header) {
+    if (header.indexOf('*/*') > -1) return 'xml' //> default to xml for backward compatibility
     const jsonIndex = header.indexOf('application/json')
     if (jsonIndex === -1) return 'xml'
     const xmlIndex = header.indexOf('application/xml')
@@ -17,12 +18,12 @@ const _requestedFormat = (queryOption, header) => {
 
 const _metadataFromFile = async srv => {
   const fs = require('fs')
-  const filePath = cds.root + `/srv/odata/v4/${srv.name}.xml`
+  const filePath = cds.root + `/srv/odata/v4/${srv.definition.name}.xml`
   let exists
   try {
     exists = !(await fs.promises.access(filePath, fs.constants.F_OK))
-  } catch (e) {
-    LOG._debug && LOG.debug(`No metadata file found for service ${srv.name} at ${filePath}`)
+  } catch {
+    LOG._debug && LOG.debug(`No metadata file found for service ${srv.definition.name} at ${filePath}`)
   }
   if (exists) {
     const file = await fs.promises.readFile(filePath)
@@ -49,19 +50,20 @@ const mpSupportsEmptyLocale = () => {
   return major > 1 || (major === 1 && minor >= 12)
 }
 
-module.exports = srv =>
-  async function metadata(req, res, _next) {
+module.exports = adapter => {
+  const { service } = adapter
+
+  return async function metadata(req, res, next) {
     if (req.method !== 'GET') {
       const msg = `Method ${req.method} is not allowed for calls to the metadata endpoint`
-      throw Object.assign(new Error(msg), { statusCode: 405 })
+      return next(Object.assign(new Error(msg), { statusCode: 405 }))
     }
 
-    const tenant = cds.context.tenant
-    const locale = cds.context.locale
     const format = _requestedFormat(req.query['$format'], req.headers['accept'])
+    const locale = cds.context.locale
 
     // REVISIT: edm(x) and etag cache is only evicted with model
-    const csnService = (cds.context.model || cds.model).definitions[srv.name]
+    const csnService = (cds.context.model || cds.model).definitions[service.definition.name]
     const metadataCache = (csnService.metadataCache = csnService.metadataCache || { jsonEtag: {}, xmlEtag: {} }) // REVISIT: yet another uncontrolled cache?
 
     const etag = format === 'json' ? metadataCache.jsonEtag?.[locale] : metadataCache.xmlEtag?.[locale]
@@ -77,8 +79,8 @@ module.exports = srv =>
       if (etag) {
         const unchanged = validate_etag(req.headers['if-none-match'], etag)
         if (unchanged) {
-          res.set('etag', etag)
-          return res.status(304).end()
+          res.set('ETag', etag)
+          return res.sendStatus(304)
         }
       }
     }
@@ -86,28 +88,35 @@ module.exports = srv =>
     const { 'cds.xt.ModelProviderService': mps } = cds.services
     if (mps) {
       if (format === 'json') {
-        LOG._warn && LOG.warn('JSON metadata is not supported in case of cds.requires.extensibilty: true')
+        LOG._warn && LOG.warn('JSON metadata is not supported in case of cds.requires.extensibility: true')
         const msg = 'JSON metadata is not supported for this service'
-        throw Object.assign(new Error(msg), { statusCode: 501 })
+        return next(Object.assign(new Error(msg), { statusCode: 501 }))
       }
 
+      const { tenant, features } = cds.context
+
       try {
         let edmx
         // REVISIT: remove check later
         if (mpSupportsEmptyLocale()) {
           // If no extensibility nor fts, do not provide model to mtxs
-          const modelNeeded = cds.env.requires.extensibility || cds.context.features?.given
+          const modelNeeded = cds.env.requires.extensibility || features?.given
           edmx =
             metadataCache.edm ||
-            (await mps.getEdmx({ tenant, model: modelNeeded && srv.model, service: srv.definition.name }))
+            (await mps.getEdmx({
+              tenant,
+              model: modelNeeded ? await mps.getCsn(tenant, features) : undefined,
+              service: service.definition.name
+            }))
           metadataCache.edm = edmx
           const extBundle = cds.env.requires.extensibility && (await mps.getI18n({ tenant, locale }))
-          edmx = cds.localize(srv.model, locale, edmx, extBundle)
+          edmx = cds.localize(service.model, locale, edmx, extBundle)
         } else {
-          edmx = await mps.getEdmx({ tenant, model: srv.model, service: srv.definition.name, locale })
+          edmx = await mps.getEdmx({ tenant, model: service.model, service: service.definition.name, locale })
         }
         metadataCache.xmlEtag[locale] = generateEtag(edmx)
-        res.set('content-type', 'application/xml')
+        res.set('ETag', metadataCache.xmlEtag[locale])
+        res.set('Content-Type', 'application/xml')
         res.send(edmx)
         return
       } catch (e) {
@@ -115,25 +124,28 @@ module.exports = srv =>
           e.message = 'Unable to get EDMX for tenant ' + tenant + ' due to error: ' + e.message
           LOG.error(e)
         }
-        throw Object.assign(new Error('503'), { statusCode: 503 })
+        return next(Object.assign(new Error('503'), { statusCode: 503 }))
       }
     }
 
     if (format === 'json') {
       const edm =
-        metadataCache.edm || (metadataCache.edm = cds.compile.to.edm(srv.model, { service: srv.definition.name }))
-      const localized = cds.localize(srv.model, locale, edm)
+        metadataCache.edm ||
+        (metadataCache.edm = cds.compile.to.edm(service.model, { service: service.definition.name }))
+      const localized = cds.localize(service.model, locale, edm)
       metadataCache.jsonEtag[locale] = generateEtag(localized)
+      res.set('ETag', metadataCache.jsonEtag[locale])
       return res.json(JSON.parse(localized))
     }
 
     const edmx =
       metadataCache.edmx ||
-      (await _metadataFromFile(srv)) ||
-      (metadataCache.edmx = cds.compile.to.edmx(srv.model, { service: srv.definition.name }))
-    const localized = cds.localize(srv.model, locale, edmx)
+      (await _metadataFromFile(service)) ||
+      (metadataCache.edmx = cds.compile.to.edmx(service.model, { service: service.definition.name }))
+    const localized = cds.localize(service.model, locale, edmx)
     metadataCache.xmlEtag[locale] = generateEtag(localized)
-    res.set('etag', metadataCache.xmlEtag[locale])
-    res.set('content-type', 'application/xml')
+    res.set('ETag', metadataCache.xmlEtag[locale])
+    res.set('Content-Type', 'application/xml')
     return res.send(localized)
   }
+}

package/libx/odata/middleware/operation.js

@@ -1,48 +1,82 @@
 const cds = require('../../../')
 
-const { toODataResult, postProcess } = require('../utils/result')
-const { cds2edm, getKeysAndParamsFromPath, handleSapMessages } = require('../utils')
-
-const { deepCopy } = require('../../_runtime/common/utils/copy')
+const { cds2edm, handleSapMessages, calculateLocationHeader } = require('../utils')
+const getODataMetadata = require('../utils/metadata')
+const postProcess = require('../utils/postProcess')
+const getODataResult = require('../utils/result')
+
+const { getKeysAndParamsFromPath } = require('../../common/utils')
+
+const _findEdmNameFor = (definition, namespace, fullyQualified = false) => {
+  let name
+  if (!definition) return ''
+  if (definition._isStructured) {
+    const structured = [definition.name]
+    while (definition.parent) {
+      definition = definition.parent
+      structured.unshift(definition.name)
+    }
+    name = structured.join('_')
+  } else {
+    name = definition.name
+  }
+  if (!name.startsWith(`${namespace}.`)) return name
+  return fullyQualified ? name : name.replace(new RegExp(`^${namespace}\\.`), '')
+}
+
+const _opResultName = ({ service, returnType, operation }) => {
+  const { definition: { name: namespace } } = service // prettier-ignore
+  if (returnType.name) {
+    const resultName = _findEdmNameFor(returnType, namespace)
+    if (returnType.name.startsWith(`${namespace}.`)) {
+      return `${namespace}.${resultName.replace(/\./g, '_')}`
+    }
+    return resultName
+  }
+  // bound action / function returns inline structure
+  if (operation.parent) {
+    const boundEntityName = _findEdmNameFor(operation.parent, namespace, true).replace(/\./g, '_')
+    // REVISIT exactly this return type name is generated in edm by compiler
+    return `${namespace}.return_${boundEntityName}_${_findEdmNameFor(operation, namespace)}`
+  }
+  // unbound action / function returns inline structure
+  // REVISIT exactly this return type name is generated in edm by compiler
+  return `${namespace}.return_${_findEdmNameFor(operation, namespace, true).replace(/\./g, '_')}`
+}
 
-const metaInfo = require('../utils/metaInfo')
+module.exports = adapter => {
+  const { service } = adapter
 
-module.exports = srv =>
-  function operation(req, res, next) {
+  return function odata_operation(req, res, next) {
     let { operation, args } = req._query.SELECT?.from.ref?.slice(-1)[0] || {}
     if (!operation) return next() //> create or read
 
+    // REVISIT: should not be necessary
+    const _originalQuery = JSON.parse(JSON.stringify(req._query))
+
     // unbound vs. bound
-    let entity, /* keys, */ params
-    if (srv.model.definitions[operation]) {
-      operation = srv.model.definitions[operation]
+    let entity, params
+    if (service.model.definitions[operation]) {
+      operation = service.model.definitions[operation]
     } else {
       req._query.SELECT.from.ref.pop()
-      let cur = { elements: srv.model.definitions }
+      let cur = { elements: service.model.definitions }
       for (const each of req._query.SELECT.from.ref) {
         cur = cur.elements[each.id || each]
         if (cur._target) cur = cur._target
       }
       operation = cur.actions[operation]
       entity = cur
-      const keysAndParams = getKeysAndParamsFromPath(req._query.SELECT.from, srv)
+      const keysAndParams = getKeysAndParamsFromPath(req._query.SELECT.from, service)
       params = keysAndParams.params
     }
 
     // payload & params
-    const data = args || deepCopy(req.body)
-
-    // assert payload
-    const assertOptions = { filter: true, http: { req }, mandatories: true }
-    const errs = cds.assert(data, operation, assertOptions)
-    if (errs) {
-      if (errs.length === 1) throw errs[0]
-      throw Object.assign(new Error('MULTIPLE_ERRORS'), { statusCode: 400, details: errs })
-    }
+    const data = args || req.body
 
     // event
     // REVISIT: when is operation.name actually prefixed with the service name?
-    const event = operation.name.replace(`${srv.name}.`, '')
+    const event = operation.name.replace(`${service.definition.name}.`, '')
 
     const query = entity ? req._query : undefined
 
@@ -50,63 +84,52 @@ module.exports = srv =>
     const headers = { ...cds.context.http.req.headers, ...req.headers }
 
     // we need a cds.Request for multiple reasons, incl. params, headers, sap-messages, read after write, ...
-    const cdsReq = new cds.Request({ query, event, data, params, headers, target: query?.target, req, res })
-    Object.defineProperty(cdsReq, 'protocol', { value: 'odata-v4' })
-
-    // API for subrequests of $batch (or incoming request)
-    cdsReq.req = req
-    cdsReq.res = res
-
-    // REVISIT: only via srv.run in combination with srv.dispatch inside
-    //          we automatically either use a single auto-managed tx for the req (i.e., insert and read after write in same tx)
-    //          or the auto-managed tx opened for the respective atomicity group, if exists
-    return srv
-      .run(() => {
-        return srv.dispatch(cdsReq).then(result => {
-          handleSapMessages(cdsReq, req, res)
-          return result
-        })
-      })
+    const cdsReq = adapter.request4({ query, event, data, params, headers, target: query?.target, req, res })
+
+    // NOTES:
+    // - only via srv.run in combination with srv.dispatch inside,
+    //   we automatically either use a single auto-managed tx for the req (i.e., insert and read after write in same tx)
+    //   or the auto-managed tx opened for the respective atomicity group, if exists
+    // - in the then block of .run(), the transaction is committed (i.e., before sending the response) if a single auto-managed tx is used
+    return service
+      .run(() => service.dispatch(cdsReq))
       .then(result => {
-        // we use an extra then block, after getting the result, so the transaction is commited, before sending the response
-
-        if (!operation.returns || result == null) return res.status(204).end()
+        handleSapMessages(cdsReq, req, res)
 
-        if (operation.returns._type?.match?.(/^cds\./)) {
-          res.set('content-type', 'application/json;IEEE754Compatible=true')
-          // TODO: check result type
-          return res.send({
-            '@odata.context': `${'../'.repeat(query?.SELECT?.from?.ref?.length)}$metadata#${cds2edm[operation.returns._type]}`,
-            value: result
-          })
-        }
+        if (operation.returns?.items && result == null) result = []
 
-        const info = metaInfo(req._query, event, srv, result, req)
+        if (!operation.returns || result == null) return res.sendStatus(204)
 
-        // FIXME: info.metadata.isCollection is incorrect
-        if (!operation.returns.items) info.metadata.isCollection = false
+        if (operation.returns._type?.match?.(/^cds\./)) {
+          const context = `${'../'.repeat(query?.SELECT?.from?.ref?.length)}$metadata#${cds2edm[operation.returns._type]}`
 
-        // REVISIT impl of context url generation
-        if (
-          !info.metadata.isCollection &&
-          info.metadata.isServiceEntity &&
-          !info.metadata.contextUrl.endsWith('$entity')
-        ) {
-          info.metadata.contextUrl += '/$entity'
+          result = { '@odata.context': context, value: result }
+          return res.send(result)
         }
 
-        if (info.metadata.returnType) {
-          postProcess(info.metadata.returnType, srv, result)
-          if (result['$etag']) res.set('etag', result['$etag'])
+        if (res.statusCode === 201 && !res.hasHeader('location')) {
+          const locationHeader = calculateLocationHeader(operation.returns, service, result)
+          if (locationHeader) res.set('location', locationHeader)
         }
 
-        result = toODataResult(result, info)
-
-        // FIXME: toODataResult() doesn't seem to handle this case
-        if (entity && !result['@odata.context'].match(/^\.\.\//))
-          result['@odata.context'] = '../' + result['@odata.context']
+        if (operation.returns) {
+          postProcess(operation.returns, service, result)
+          if (result?.$etag) res.set('ETag', result.$etag) //> must be done after post processing
+        }
 
-        res.set('content-type', 'application/json;IEEE754Compatible=true')
+        // REVISIT: enterprise search result? -> simply return what was provided
+        if (operation.returns.type !== 'sap.esh.SearchResult') {
+          const isCollection = !!operation.returns.items
+          const _target = operation.returns.items ?? operation.returns
+          // REVISIT: when is edmName needed?
+          const edmName = _opResultName({ service, operation, returnType: _target })
+          const metadata = getODataMetadata(
+            { SELECT: { from: _originalQuery?.SELECT?.from, one: !isCollection }, _target },
+
+            { result, isCollection, edmName }
+          )
+          result = getODataResult(result, metadata, { isCollection })
+        }
         res.send(result)
       })
       .catch(err => {
@@ -114,3 +137,4 @@ module.exports = srv =>
         next(err)
       })
   }
+}

package/libx/odata/middleware/parse.js

@@ -1,18 +1,16 @@
 const cds = require('../../../')
 
-module.exports = srv =>
-  function parse(req, _, next) {
+module.exports = adapter => {
+  const { service } = adapter
+
+  return function odata_parse_url(req, _, next) {
     // REVISIT: can't we register the batch handler before the parse handler to avoid this?
     if (req.path.startsWith('/$batch')) return next()
 
     if (req._query) return next() //> already parsed (e.g., upsert)
 
-    // if not a GET, use req.path instead of req.url to ignore query parameters
-    req._query = cds.odata.parse(req.method === 'GET' ? req.url : req.path, {
-      service: srv,
-      baseUrl: req.baseUrl,
-      strict: true
-    })
+    req._query = cds.odata.parse(req.url, { service, baseUrl: req.baseUrl, strict: true })
 
     next()
   }
+}