@sap/cds 8.2.3 → 8.3.1

package/libx/odata/middleware/read.js

@@ -12,19 +12,19 @@ const { getKeysAndParamsFromPath } = require('../../common/utils')
 const { getPageSize } = require('../../_runtime/common/generic/paging')
 const { handleStreamProperties } = require('../../_runtime/common/utils/streamProp')
 
-const _getCount = result =>
-  Array.isArray(result)
-    ? result.reduce((acc, val) => {
-        return acc + ((val && (val.$count || val._counted_)) || (val[0] && (val[0].$count || val[0]._counted_))) || 0
-      }, 0)
-    : result.$count || result._counted_ || 0
+const _getCount = result => (Array.isArray(result) && result.length ? result[0].$count || 0 : result.$count || 0)
 
 const _setNextLink = (req, result) => {
   const $skiptoken = result.$nextLink ?? _calculateSkiptoken(req, result)
   if (!$skiptoken) return
 
   const queryParamsWithSkipToken = { ...req.req.query, $skiptoken }
-  result.$nextLink = req.req.path.slice(1) + '?' + querystring.stringify(queryParamsWithSkipToken)
+  const encodedQueryParams = querystring.stringify(queryParamsWithSkipToken)
+
+  // percent-encode all path segments with key values inside parentheses, but keep Navigation Properties untouched
+  const encodedPath = req.req.path.slice(1).replace(/\('([^']*)'\)/g, (match, key) => `('${encodeURIComponent(key)}')`)
+
+  result.$nextLink = `${encodedPath}?${encodedQueryParams}`
 }
 
 const _calculateSkiptoken = (req, result) => {
@@ -184,6 +184,8 @@ module.exports = adapter => {
     // $apply with concat -> multiple queries with special handling
     if (Array.isArray(req._query)) return _handleArrayOfQueries(req, res, next)
 
+    const model = cds.context.model ?? service.model
+
     // REVISIT: better solution for _propertyAccess
     let {
       SELECT: { from, one },
@@ -193,7 +195,7 @@ module.exports = adapter => {
     const { _query: query } = req
 
     // payload & params
-    const { keys, params } = getKeysAndParamsFromPath(from, service)
+    const { keys, params } = getKeysAndParamsFromPath(from, { model })
     const data = keys //> for read and delete, we provide keys in req.data
 
     // cdsReq.headers should contain merged headers of envelope and subreq
@@ -212,7 +214,7 @@ module.exports = adapter => {
 
     if (!query.SELECT.columns) query.SELECT.columns = ['*']
 
-    handleStreamProperties(target, query.SELECT.columns, service.model)
+    handleStreamProperties(target, query.SELECT.columns, model)
 
     // REVISIT: what is this for? some tests fail without it... we should find a better solution!
     Object.defineProperty(query.SELECT, '_4odata', { value: true })
@@ -246,10 +248,12 @@ module.exports = adapter => {
         if (result == null) {
           result = []
           if (req.query.$count) result.$count = 0
+        } else if (query.SELECT.count && !result.$count) {
+          result.$count = 0
         }
 
         if (!one) _setNextLink(cdsReq, result)
-        postProcess(cdsReq.target, service, result)
+        postProcess(cdsReq.target, model, result)
         if (result?.$etag) res.set('ETag', result.$etag) //> must be done after post processing
 
         const lastSeg = req.path.split('/').slice(-1)[0]

package/libx/odata/middleware/service-document.js

@@ -22,7 +22,7 @@ module.exports = adapter => {
       throw Object.assign(new Error(msg), { statusCode: 405 })
     }
 
-    const model = cds.context.model || cds.model
+    const model = cds.context.model ?? service.model
     const csnService = model.definitions[service.definition.name]
 
     if (req.headers['if-match']) {

package/libx/odata/middleware/stream.js

@@ -170,6 +170,7 @@ module.exports = adapter => {
 
     if (isRedirect(query)) {
       const cdsReq = adapter.request4({ query, req, res })
+
       service.dispatch(cdsReq).then(result => {
         if (result[query._propertyAccess]) res.set('Location', result[query._propertyAccess])
         return res.sendStatus(307)

package/libx/odata/middleware/update.js

@@ -69,9 +69,11 @@ module.exports = adapter => {
       throw Object.assign(new Error(`Method ${req.method} is not allowed for properties`), { statusCode: 405 })
     }
 
+    const model = cds.context.model ?? service.model
+
     // payload & params
     const data = _propertyAccess ? { [_propertyAccess]: req.body.value } : req.body
-    const { keys, params } = getKeysAndParamsFromPath(from, service)
+    const { keys, params } = getKeysAndParamsFromPath(from, { model })
     // add keys from url into payload (overwriting if already present)
     if (!_propertyAccess) Object.assign(data, keys)
 
@@ -111,7 +113,7 @@ module.exports = adapter => {
         if (result == null) return res.sendStatus(204)
 
         const isMinimal = getPreferReturnHeader(req) === 'minimal'
-        postProcess(cdsReq.target, service, result, isMinimal)
+        postProcess(cdsReq.target, model, result, isMinimal)
 
         if (isMinimal && !target._isSingleton) {
           // determine calculation based on result with req.data as fallback
@@ -139,7 +141,7 @@ module.exports = adapter => {
           // PUT / PATCH with if-match header means "only if already exists" -> no insert if it does not
           if (req.headers['if-match']) return next(Object.assign(new Error('412'), { statusCode: 412 }))
 
-          if (!upsertSupported(from, service.model)) return next(Object.assign(new Error('422'), { statusCode: 422 }))
+          if (!upsertSupported(from, model)) return next(Object.assign(new Error('422'), { statusCode: 422 }))
 
           // -> forward to POST
           req.method = 'POST'

package/libx/odata/parse/afterburner.js

@@ -383,6 +383,14 @@ function _processSegments(from, model, namespace, cqn, protocol) {
         ref[i] = { operation: current.name }
         if (params) ref[i].args = _getDataFromParams(params, current)
         if (current.returns && current.returns._type) one = true
+
+        if (current.returns) {
+          if (current.returns._type) {
+            one = true
+          }
+
+          target = current.returns.items ?? current.returns
+        }
       } else if (current.isAssociation) {
         if (!current._target._service) {
           // not exposed target
@@ -589,23 +597,26 @@ const _checkAllKeysProvided = (params, entity) => {
   }
 }
 
-const _doesNotExistError = (isExpand, refName, targetName) => {
+const _doesNotExistError = (isExpand, refName, targetName, targetKind) => {
   const msg = isExpand
     ? `Navigation property "${refName}" is not defined in "${targetName}"`
-    : `Property "${refName}" does not exist in "${targetName}"`
+    : `Property "${refName}" does not exist in ${targetKind === 'type' ? 'type ' : ''}"${targetName}"`
   throw Object.assign(new Error(msg), { statusCode: 400 })
 }
 
-function _validateXpr(xpr, ignoredColumns, target, isOne, model, aliases = []) {
+function _validateXpr(xpr, target, isOne, model, aliases = []) {
   if (!xpr) return []
 
+  const ignoredColumns = Object.values(target.elements ?? {})
+    .filter(element => element['@cds.api.ignore'] && !element.isAssociation)
+    .map(element => element.name)
   const _aliases = []
 
   for (const x of xpr) {
     if (x.as) _aliases.push(x.as)
 
     if (x.xpr) {
-      _validateXpr(x.xpr, ignoredColumns, target, isOne, model)
+      _validateXpr(x.xpr, target, isOne, model)
       continue
     }
 
@@ -614,101 +625,82 @@ function _validateXpr(xpr, ignoredColumns, target, isOne, model, aliases = []) {
 
       if (x.ref[0].where) {
         const element = target.elements[refName]
-
         if (!element) {
           _doesNotExistError(true, refName, target.name)
         }
-        _validateXpr(x.ref[0].where, ignoredColumns, element._target ?? element.items, isOne, model)
+        _validateXpr(x.ref[0].where, element._target ?? element.items, isOne, model)
       }
 
       if (!target?.elements) {
-        _doesNotExistError(false, refName, target.name)
+        _doesNotExistError(false, refName, target.name, target.kind)
       }
 
       if (ignoredColumns.includes(refName) || (!target.elements[refName] && !aliases.includes(refName))) {
         _doesNotExistError(x.expand, refName, target.name)
       } else if (x.ref.length > 1) {
         const element = target.elements[refName]
-
         if (element.isAssociation) {
           // navigation
-          const _target = element._target
-          const _ignoredColumns = Object.values(_target.elements ?? {})
-            .filter(element => element['@cds.api.ignore'])
-            .map(element => element.name)
-          if (element.is2one) {
-            _validateXpr([{ ref: x.ref.slice(1) }], _ignoredColumns, _target, false, model)
-          } else {
-            _validateXpr([{ ref: x.ref.slice(1) }], _ignoredColumns, _target, false, model)
-          }
+          _validateXpr([{ ref: x.ref.slice(1) }], element._target, false, model)
         } else if (element.kind === 'element') {
           // structured
-          _validateXpr([{ ref: x.ref.slice(1) }], ignoredColumns, element, isOne, model)
+          _validateXpr([{ ref: x.ref.slice(1) }], element, isOne, model)
         } else {
           throw new Error('not yet validated')
         }
       }
+
       if (x.expand) {
         let element = target.elements[refName]
         if (element.kind === 'element' && element.elements) {
           // structured
-          _validateXpr([{ ref: x.ref.slice(1) }], ignoredColumns, element, isOne, model)
+          _validateXpr([{ ref: x.ref.slice(1) }], element, isOne, model)
           element = _structProperty(x.ref.slice(1), element)
         }
-
         if (!element._target) {
           _doesNotExistError(true, refName, target.name)
         }
-
-        const _ignoredColumns = Object.values(element._target.elements ?? {})
-          .filter(element => element['@cds.api.ignore'])
-          .map(element => element.name)
-        _validateXpr(x.expand, _ignoredColumns, element._target, false, model)
-
+        _validateXpr(x.expand, element._target, false, model)
         if (x.where) {
-          _validateXpr(x.where, _ignoredColumns, element._target, false, model)
+          _validateXpr(x.where, element._target, false, model)
         }
-
         if (x.orderBy) {
-          _validateXpr(x.orderBy, _ignoredColumns, element._target, false, model)
+          _validateXpr(x.orderBy, element._target, false, model)
         }
       }
     }
 
     if (x.func) {
-      _validateXpr(x.args, ignoredColumns, target, isOne, model)
+      _validateXpr(x.args, target, isOne, model)
       continue
     }
 
     if (x.SELECT) {
       const { target } = targetFromPath(x.SELECT.from, model)
-      const _ignoredColumns = Object.values(target.elements ?? {})
-        .filter(element => element['@cds.api.ignore'])
-        .map(element => element.name)
-      _validateQuery(x.SELECT, _ignoredColumns, target, x.SELECT.one, model)
+      _validateQuery(x.SELECT, target, x.SELECT.one, model)
     }
   }
 
   return _aliases
 }
 
-function _validateQuery(SELECT, ignoredColumns, target, isOne, model) {
+function _validateQuery(SELECT, target, isOne, model) {
   const aliases = []
+
   if (SELECT.from.SELECT) {
     const { target } = targetFromPath(SELECT.from.SELECT.from, model)
-    const _ignoredColumns = Object.values(target.elements ?? {})
-      .filter(element => element['@cds.api.ignore'])
-      .map(element => element.name)
-    const subselectAliases = _validateQuery(SELECT.from.SELECT, _ignoredColumns, target, SELECT.from.SELECT.one, model)
+    const subselectAliases = _validateQuery(SELECT.from.SELECT, target, SELECT.from.SELECT.one, model)
     aliases.push(...subselectAliases)
   }
 
-  const columnAliases = _validateXpr(SELECT.columns, ignoredColumns, target, isOne, model)
+  const columnAliases = _validateXpr(SELECT.columns, target, isOne, model)
   aliases.push(...columnAliases)
-  _validateXpr(SELECT.orderBy, ignoredColumns, target, isOne, model, aliases)
-  _validateXpr(SELECT.where, ignoredColumns, target, isOne, model, aliases)
-  _validateXpr(SELECT.groupBy, ignoredColumns, target, isOne, model, aliases)
-  _validateXpr(SELECT.having, ignoredColumns, target, isOne, model, aliases)
+
+  _validateXpr(SELECT.orderBy, target, isOne, model, aliases)
+  _validateXpr(SELECT.where, target, isOne, model, aliases)
+  _validateXpr(SELECT.groupBy, target, isOne, model, aliases)
+  _validateXpr(SELECT.having, target, isOne, model, aliases)
+
   return aliases
 }
 
@@ -773,12 +765,8 @@ module.exports = (cqn, model, namespace, protocol) => {
   _processColumns(cqn, current, protocol)
 
   if (target) {
-    const ignoredColumns = Object.values(target.elements ?? {})
-      .filter(element => element['@cds.api.ignore'])
-      .map(element => element.name)
-
     // validate whether only known properties are used in query options
-    _validateQuery(cqn.SELECT, ignoredColumns, target, one, model)
+    _validateQuery(cqn.SELECT, target, one, model)
   }
 
   return cqn

package/libx/odata/utils/index.js

@@ -278,9 +278,11 @@ const skipToken = (token, cqn) => {
 const calculateLocationHeader = (target, srv, result) => {
   const targetName = target.name.replace(`${srv.definition.name}.`, '')
   const filteredKeys = [...target.keys].filter(k => !k.isAssociation).map(k => k.name)
+  if (!filteredKeys.every(k => k in result)) return
+
   const keyValuePairs = filteredKeys.reduce((acc, key) => {
     const value = result[key]
-    if (value === undefined) return
+    if (value === undefined) return acc
     if (Buffer.isBuffer(value)) {
       acc[key] = value.toString('base64')
     } else {
@@ -290,7 +292,6 @@ const calculateLocationHeader = (target, srv, result) => {
     }
     return acc
   }, {})
-  if (!keyValuePairs) return
   let keys
   const entries = Object.entries(keyValuePairs)
   if (entries.length === 1) {

package/libx/odata/utils/postProcess.js

@@ -1,5 +1,3 @@
-const cds = require('../../_runtime/cds')
-
 const getTemplate = require('../../_runtime/common/utils/template')
 
 const _addEtags = (row, key) => {
@@ -38,18 +36,15 @@ const _processorFn = elementInfo => {
 const _pick = element => {
   const categories = []
   if (element['@odata.etag']) categories.push('@odata.etag')
-  if (element['@cds.api.ignore']) categories.push('@cds.api.ignore')
+  if (element['@cds.api.ignore'] && !element.isAssociation) categories.push('@cds.api.ignore')
   if (element._type === 'cds.Binary') categories.push('binary')
   if (element.items) categories.push('array')
   if (categories.length) return { categories }
 }
 
-module.exports = function postProcess(target, service, result, isMinimal) {
+module.exports = function postProcess(target, model, result, isMinimal) {
   if (!result) return
 
-  let { model } = service
-  if (service.isExtensible) model = cds.context?.model || model
-
   if (!model.definitions[target.name]) {
     if (model.definitions[target.items?.type]) target = target.items
     else return
@@ -57,7 +52,7 @@ module.exports = function postProcess(target, service, result, isMinimal) {
 
   const cacheKey = isMinimal ? 'postProcessMinimal' : 'postProcess'
   const options = { pick: _pick, ignore: isMinimal ? el => el.isAssociation : undefined }
-  const template = getTemplate(cacheKey, service, target, options)
+  const template = getTemplate(cacheKey, { model }, target, options)
 
   if (template.elements.size === 0) return
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "8.2.3",
+  "version": "8.3.1",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [

package/libx/_runtime/cds-services/services/utils/compareJson.js

@@ -1,2 +0,0 @@
-// REVISIT: remove with cds^8
-module.exports = require('../../../common/utils/compareJson')