@sap/cds 8.9.4 → 9.0.2

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

@@ -17,7 +17,6 @@ const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 const propagateForeignKeys = require('../utils/propagateForeignKeys')
 const { checkInputConstraints, assertTargets } = require('../../cds-services/util/assert')
 const getTemplate = require('../utils/template')
-const { getDataFromCQN, setDataFromCQN } = require('../utils/data')
 const getRowUUIDGeneratorFn = require('../utils/rowUUIDGenerator')
 
 const _shouldSuppressErrorPropagation = (event, value) => {
@@ -102,7 +101,7 @@ const _processCategory = (req, category, value, elementInfo, assertMap) => {
   category = _getSimpleCategory(category)
 
   if (category === 'propagateForeignKeys') {
-    propagateForeignKeys(key, row, element._foreignKeys, element.isComposition, { enumerable: false })
+    propagateForeignKeys(key, row, element._foreignKeys, element.isComposition)
     return
   }
 
@@ -192,22 +191,6 @@ const _pick = element => {
     categories.push({ category: 'propagateForeignKeys' })
   }
 
-  // some checks are not needed if cds_validate is active (the default in cds^8)
-  if (!cds.env.features.cds_validate) {
-    if (element['@assert.range'] || element['@assert.format'] || element.type === 'cds.Decimal') {
-      categories.push('assert')
-    }
-
-    if (element._isMandatory) {
-      categories.push('mandatory')
-    }
-
-    if (element._isReadOnly) {
-      // > _isReadOnly includes @cds.on.insert and @cds.on.update
-      categories.push('readonly')
-    }
-  }
-
   // REVISIT: cleanse @Core.Immutable
   //          should be a db feature, as we cannot handle completely on service level (cf. deep update)
   //          -> add to attic env behavior once new dbs handle this
@@ -221,10 +204,10 @@ const _pick = element => {
   }
 
   if (
-    element._isAssociationStrict &&
-    !element.on && // managed assoc
+    element['@assert.target'] &&
+    element.isAssociation &&
     element.is2one &&
-    element['@assert.target'] === true
+    !element.on // managed assoc
   ) {
     categories.push('@assert.target')
   }
@@ -240,34 +223,38 @@ const _pick = element => {
   if (categories.length) return { categories }
 }
 
-// REVISIT: needed only for draftActivate with old adapter -> remove with okra
-const _getBoundAction = req => req.target.actions?.[req._?.event || req.context?.event]
-const _getBoundActionBindingParameter = action => action['@cds.odata.bindingparameter.name'] || 'in'
+async function validate_input(req) {
+  if (!req.target || req.target._unresolved) return // Validation requires resolved targets
+  if (req.event === 'CREATE' && req.target.isDraft) return // already handled in `NEW`, no need in `EDIT`
+
+  // REVISIT: remove once mtxs fixed its modeling
+  if (!req.query && req.target.name.match(/^cds\.xt\./)) return // skip validation for mtxs
 
-async function commonGenericInput(req) {
-  if (!req.query) return // FIXME: the code below expects req.query to be defined
-  if (!req.target) return
+  // REVISIT: can we get rid of this?
+  const _is_activate = req._?.event === 'draftActivate' && cds.env.features.preserve_computed !== false
 
   // validate data
-  if (cds.env.features.cds_validate) {
-    const assertOptions = { mandatories: req.event === 'CREATE' || req.method === 'PUT' }
+  const assertOptions = {
+    mandatories: req.event === 'CREATE' || req.method === 'PUT',
+    cleanse: _is_activate ? false : true,
+    protocol: req.protocol,
+    rejectIgnore: req.protocol && !_is_activate ? true : undefined
+  }
 
-    const _is_activate = req._?.event === 'draftActivate' && cds.env.features.preserve_computed !== false
-    const _is_create_after_new = req.target.isDraft && req.event === 'CREATE'
-    if (_is_activate || _is_create_after_new) assertOptions.cleanse = false
+  if (req.event === 'NEW') assertOptions.insert = true // treat NEW as INSERT even though no mandatories are checked
 
-    // REVISIT: initialize path if necessary (currently only done in lean-draft -> correct?)
-    const bound = req.target.actions?.[req.event] || req.target.actions?.[req._.event]
+  // REVISIT: initialize path if necessary (currently only done in lean-draft -> correct?)
+  const { actions } = req.target
+  if (actions) {
+    const bound = actions[req.event] || actions[req._.event]
     if (bound) assertOptions.path = [bound['@cds.odata.bindingparameter.name'] || 'in']
+  }
 
-    if (req.protocol && !_is_activate) assertOptions.rejectIgnore = true
+  const errs = cds.validate(req.data, req.target, assertOptions)
+  if (errs) return req._errors.push(...errs)
 
-    const errs = cds.validate(req.data, req.target, assertOptions)
-    if (errs) {
-      if (errs.length === 1) throw errs[0]
-      throw Object.assign(new Error('MULTIPLE_ERRORS'), { statusCode: 400, details: errs })
-    }
-  }
+  // -------------------------------------------------
+  // REVISIT: is the below still needed?
 
   const template = getTemplate('app-input', this, req.target, {
     pick: _pick,
@@ -275,41 +262,23 @@ async function commonGenericInput(req) {
   })
   if (template.elements.size === 0) return
 
+  if (req.query) enrichDataWithKeysFromWhere(req.data, req, this)
+  // REVISIT: ^^^^ quite questionable to do something like this in a validate function
+
   const errors = []
   const assertMap = {
     targets: new Map(),
     allTargets: []
   }
-
-  const pathOptions = {
+  template.process(req.data, _getProcessorFn(req, errors, assertMap), {
     rowUUIDGenerator: getRowUUIDGeneratorFn(req.event),
     includeKeyValues: true,
     pathSegmentsInfo: []
-  }
-
-  // REVISIT: needed only for correct error target in case of draftActivate with old adapter -> remove with okra
-  const boundAction = _getBoundAction(req)
-
-  if (boundAction) {
-    const pathSegment = _getBoundActionBindingParameter(boundAction)
-    if (pathSegment) pathOptions.pathSegmentsInfo.push(pathSegment)
-    const keys = req.params?.[0]
-    if (keys && 'IsActiveEntity' in keys) {
-      pathOptions.draftKeys = { IsActiveEntity: keys.IsActiveEntity }
-    }
-  }
-
-  const data = getDataFromCQN(req.query) // REVISIT: req.data should point into req.query
-  enrichDataWithKeysFromWhere(data, req, this)
-
-  template.process(data, _getProcessorFn(req, errors, assertMap), pathOptions)
-
+  })
   if (assertMap.targets.size > 0) {
     await assertTargets(assertMap, errors)
   }
 
-  setDataFromCQN(req) // REVISIT: req.data should point into req.query
-
   if (errors.length) for (const error of errors) req.error(error)
 }
 
@@ -350,42 +319,22 @@ const _processActionFunction = (row, eventParams, errors, event, service) => {
   }
 }
 
-const _getOperation = (req, service) => {
-  // in bound case
-  if (req.target) {
-    if (req.target.actions && req.target.actions[req.event]) {
-      return req.target.actions[req.event]
-    }
-
-    return req.target.functions[req.event]
-  }
-
-  // in unbound case
-  return service.model.definitions[`${service.definition.name}.${req.event}`]
-}
-
-function _actionFunctionHandler(req) {
-  const operation = _getOperation(req, this)
+function validate_action(req) {
+  const operation = this.actions?.[req.event] || req.target?.actions?.[req.event]
   if (!operation) return
 
   const data = req.data || {}
 
   // validate data
-  if (cds.env.features.cds_validate) {
-    const assertOptions = {
-      mandatories: true,
-      cleanse: !(operation.kind === 'action' || operation.kind === 'function')
-    }
-    let errs = cds.validate(data, operation, assertOptions)
-    if (errs) {
-      if (errs.length === 1) throw errs[0]
-      throw Object.assign(new Error('MULTIPLE_ERRORS'), { statusCode: 400, details: errs })
-    }
+  const assertOptions = {
+    mandatories: true,
+    cleanse: false,
+    protocol: req.protocol
   }
+  let errs = cds.validate(data, operation, assertOptions)
+  if (errs) return req._errors.push(...errs)
 
-  // REVISIT: the below is still needed if !cds.env.features.cds_validate because cds.validate doesn't throw missing mandatory struct.
-  //          look for comment "skip struct-likes as we check flat payloads above, and deep payloads via struct.validate()".
-  //          structured params are _not_ flattened and, hence, the assumption in the comment is incorrect (or the flattening must be done).
+  // REVISIT: we still need the following because cds.validate doesn't check for @mandatory params (both flat and nested)
   const errors = []
   const arrayData = Array.isArray(data) ? data : [data]
   for (const row of arrayData) _processActionFunction(row, operation.params, errors, req.event, this)
@@ -400,38 +349,17 @@ function _actionFunctionHandler(req) {
     })
 }
 
-commonGenericInput._initial = true
-_actionFunctionHandler._initial = true
+// FIXME: we should remove the below, but then 6 tests fail.
+// 4 in cds/tests/_runtime
+// 2 in cap/incidents/test
+validate_input._initial = true
+validate_action._initial = true
 
 module.exports = cds.service.impl(function () {
-  this.before(['CREATE', 'UPDATE'], '*', commonGenericInput)
-
-  const operationNames = []
-
-  for (const operation of this.operations) {
-    operationNames.push(operation.name.substring(this.name.length + 1))
-  }
-
-  if (operationNames.length > 0) {
-    this.before(operationNames, _actionFunctionHandler)
-  }
-
-  for (const entity of this.entities) {
-    const boundOps = []
-
-    if (entity.actions) {
-      boundOps.push(...Object.keys(entity.actions))
-    }
-
-    if (entity.functions) {
-      boundOps.push(...Object.keys(entity.functions))
-    }
-
-    if (boundOps.length > 0) {
-      this.before(boundOps, entity.name, _actionFunctionHandler)
-    }
-  }
+  this.before(['CREATE', 'UPDATE', 'NEW'], '*', validate_input)
+  for (const each of this.actions) this.before(each, validate_action)
+  for (const entity of this.entities) for (let a in entity.actions) this.before(a, entity, validate_action)
 })
 
 // needed for testing
-module.exports.commonGenericInput = commonGenericInput
+module.exports.commonGenericInput = validate_input

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

@@ -1,8 +1,7 @@
 const cds = require('../../cds')
 
 module.exports = exports = cds.service.impl(function () {
-  commonGenericPaging._initial = true
-  this.before('READ', '*', commonGenericPaging)
+  this.before('READ', '*', handle_paging)
 })
 
 const DEFAULT = cds.env.query?.limit?.default ?? 1000
@@ -24,7 +23,7 @@ const getPageSize = def => {
   return def.set(_cached, { default: _default, max })
 }
 
-const commonGenericPaging = function (req) {
+const handle_paging = function (req) {
   // only if http request
   if (!req.http?.req) return
 
@@ -44,7 +43,8 @@ const _addPaging = function ({ SELECT }, target) {
   //Handle nested limits
   if (SELECT.from.SELECT?.limit) _addPaging(SELECT.from, target)
 }
+handle_paging._initial = true
 
 // needed in lean draft
 exports.getPageSize = getPageSize
-exports.commonGenericPaging = commonGenericPaging
+exports.commonGenericPaging = handle_paging

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

@@ -3,23 +3,12 @@ const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 const _getStaticOrders = req => {
   const { target: entity, query } = req
-  const defaultOrders = entity['@cds.default.order'] || entity['@odata.default.order'] || []
-
-  if (entity['@cds.default.order']) {
-    // Remove with cds^8
-    cds.utils.deprecated({ kind: 'Annotation', old: '@cds.default.order of entity ' + entity.name })
-  }
-  if (entity['@odata.default.order']) {
-    // Remove with cds^8
-    cds.utils.deprecated({ kind: 'Annotation', old: '@odata.default.order of entity ' + entity.name })
-  }
-
   const ordersFromKeys = []
 
   if (req.target._isSingleton || query.SELECT.limit) {
     const keys = [...(entity.keys || [])].filter(k => !k.isAssociation).map(k => k.name)
     for (const key of keys) {
-      if (!(key in DRAFT_COLUMNS_MAP) && !defaultOrders.some(o => o.by['='] === key)) {
+      if (!(key in DRAFT_COLUMNS_MAP)) {
         ordersFromKeys.push({ by: { '=': key }, implicit: true })
       }
     }
@@ -31,10 +20,10 @@ const _getStaticOrders = req => {
       by: { '=': keyName.ref[keyName.ref.length - 1] },
       desc: keyName.sort === 'desc'
     }))
-    return [...ordersFromView, ...defaultOrders, ...ordersFromKeys]
+    return [...ordersFromView, ...ordersFromKeys]
   }
 
-  return [...defaultOrders, ...ordersFromKeys]
+  return ordersFromKeys
 }
 
 const _addDefaultSortOrder = (req, select) => {
@@ -63,12 +52,12 @@ const _addDefaultSortOrder = (req, select) => {
 
 /**
  * 1. query options --> already set in req.query
- * 2. orders from view || @cds.default.order/@odata.default.order
+ * 2. orders from view
  * 3. orders from keys if singleton or limit is set
  *
  * @param req
  */
-const commonGenericSorting = function (req) {
+const handle_sorting = function (req) {
   if (!req.query || !req.query.SELECT || req.query.SELECT.one) return
 
   let select = req.query.SELECT
@@ -87,14 +76,14 @@ const commonGenericSorting = function (req) {
   }
   _addDefaultSortOrder(req, select)
 }
+handle_sorting._initial = true
 
 /**
  * handler registration
  */
 module.exports = cds.service.impl(function () {
-  commonGenericSorting._initial = true
-  this.before('READ', '*', commonGenericSorting)
+  this.before('READ', '*', handle_sorting)
 })
 
 // needed in lean draft
-module.exports.handler = commonGenericSorting
+module.exports.handler = handle_sorting

package/libx/_runtime/common/generic/stream-only.js

@@ -0,0 +1,26 @@
+// Parked variant of ./stream.js that registers handlers not to all services,
+// but only to the ones that actually have media type elements.
+const cds = require('../../cds')
+
+module.exports = cds.service.impl(function () {
+  for (let each of this.entities) {
+    if (_is_irrelevant(each)) continue
+    for (let e in each.elements) {
+      const ref = _media_type_ref4(each.elements[e])
+      if (ref) {
+        this.before('UPDATE', _entity(each), function fill_media_type(req) {
+          if (e in req.data && _is_field_request(req)) {
+            let content_type = req.req?.get('content-type')
+            if (_is_valid(content_type)) req.data[ref] = content_type
+          }
+        })
+      }
+    }
+  }
+})
+
+const _is_irrelevant = d => d['@readonly'] || d.name.endsWith('.texts')
+const _entity = d => (!d.drafts ? d : [d, d.drafts])
+const _media_type_ref4 = media_element => media_element['@Core.MediaType']?.['=']
+const _is_field_request = req => req.req?._query?._propertyAccess
+const _is_valid = content_type => content_type && !content_type.includes('multipart')

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

@@ -1,53 +1,21 @@
 const cds = require('../../cds')
-// REVISIT: Remove after removing okra
-const { isStreaming } = require('../../cds-services/adapter/odata-v4/utils/stream')
-
-const _isStream = query => {
-  const { _propertyAccess, target } = query
-  if (!_propertyAccess) return
-
-  const element = target.elements[_propertyAccess]
-  return element._type === 'cds.LargeBinary' && element['@Core.MediaType']
-}
-
-const _getStreamingProperties = elements => {
-  const result = []
-  for (const key in elements) {
-    const element = elements[key]
-    if (typeof element['@Core.MediaType'] === 'object') {
-      result.push({ stream: key, type: element['@Core.MediaType']['='] })
-    }
-  }
-
-  return result
-}
-
-const _getMediaTypeValue = () => {
-  const ctx = cds.context
-  return !ctx?.http?.req?.headers?.['content-type']?.match(/multipart/i) && ctx?.http?.req?.headers?.['content-type']
-}
-
-function _addContentType(req, mtValue) {
-  if (!req.data) return
-  const streamProp = _getStreamingProperties(req.target.elements).find(prop => req.data[prop.stream])
-  if (streamProp) req.data[streamProp.type] = mtValue
-}
-
-async function addContentType(req) {
-  if (!req.query || !req.target) return
-  if (req._.odataReq) {
-    if (!isStreaming(req._.odataReq.getUriInfo().getPathSegments())) return
-  } else if (req.req?._query) {
-    if (!_isStream(req.req._query)) return
-  }
-
-  const mtValue = _getMediaTypeValue()
-  if (!mtValue) return
-
-  _addContentType(req, mtValue)
-}
 
 // register after input.js in order to write content-type also for @Core.Computed fields
 module.exports = cds.service.impl(function () {
-  this.before(['PATCH', 'UPDATE'], '*', addContentType)
+  this.before('UPDATE', '*', function fill_media_types(req) {
+    if (!req.data || !req.target) return
+    if (_is_field_request(req)) {
+      for (let e in req.data) {
+        let ref = _media_type_ref4(req.target.elements[e])
+        if (ref) {
+          let content_type = req.req?.get('content-type')
+          if (_is_valid(content_type)) req.data[ref] = content_type
+        }
+      }
+    }
+  })
 })
+
+const _media_type_ref4 = media_element => media_element['@Core.MediaType']?.['=']
+const _is_field_request = req => req.req?._query?._propertyAccess
+const _is_valid = content_type => content_type && !content_type.includes('multipart')

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

@@ -39,9 +39,8 @@ const _getTimeDelta = (target, queryOption) => {
  *
  * @param req
  */
-const commonGenericTemporal = function (req) {
-  // REVISIT: remove req._queryOptions with okra
-  const _queryOptions = req.constructor.name === 'ODataRequest' ? req._queryOptions : req.req?.query
+function handle_temporal_data(req) {
+  const _queryOptions = req.req?.query
 
   // REVISIT: stable access
   const _ = (req.context && req.context._) || req._
@@ -85,12 +84,22 @@ const commonGenericTemporal = function (req) {
     req._['VALID-TO'] = _['VALID-TO']
   }
 }
+handle_temporal_data._initial = true
 
 /**
  * handler registration
  */
 module.exports = cds.service.impl(function () {
-  commonGenericTemporal._initial = true
-  // always run to allow interaction with temporal data in custom handlers
-  this.before('*', commonGenericTemporal)
+  // Register handler only if at least one entity has temporal annotation
+  let temporal_required = false
+  for (const each of this.entities) {
+    for (const element of each.elements) {
+      if (element['@cds.valid.from'] || element['@cds.valid.to']) {
+        temporal_required = true
+        break
+      }
+    }
+    if (temporal_required) break
+  }
+  if (temporal_required) this.before('READ', '*', handle_temporal_data)
 })

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

@@ -6,29 +6,4 @@ const toBase64url = value => {
   return base64url.padEnd(Math.ceil(base64url.length / 4) * 4, '=')
 }
 
-const normalizeBase64string = value => {
-  if (typeof value !== 'string') return value
-  // add last byte(s) and '=' padding in case of shortend base64
-  return Buffer.from(value, 'base64').toString('base64')
-}
-
-// REVISIT: The function is only used in okra.
-// To be removed with the function normalizeBase64string above
-const isInvalidBase64string = value => {
-  if (Buffer.isBuffer(value)) return // ok
-
-  // convert to standard base64 string; let it crash if typeof value !== 'string'
-  const base64value = value.replace(/_/g, '/').replace(/-/g, '+')
-  const normalized = normalizeBase64string(value)
-
-  // example of invalid base64 string --> 'WTGTdDsD/k21LnFRb+uNcAi=' <-- '...i=' must be '...g='
-  // see https://datatracker.ietf.org/doc/html/rfc4648#section-4
-  if (base64value.replace(/=/g, '') !== normalized.replace(/=/g, '')) return true
-  return base64value.length > normalized.length
-}
-
-module.exports = {
-  normalizeBase64string,
-  isInvalidBase64string,
-  toBase64url
-}
+module.exports = { toBase64url }

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

@@ -362,10 +362,9 @@ const compareJson = (newValue, oldValue, entity, opts = {}) => {
     oldBucketMap = _getBucketMap(oldValue, entity, metaCache)
   }
   const result = compareJsonDeep(entity, newValue, oldValue, options, { newBucketMap, oldBucketMap }, metaCache)
-
   // in case of batch insert, result is an array
   // in all other cases it is an array with just one entry
-  return Array.isArray(newValue) ? result : result[0]
+  return Array.isArray(newValue) ? result : result[0] // Drops all but the first entry !!!
 }
 
 module.exports = {

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

@@ -26,22 +26,23 @@ const getEntityNameFromUpdateCQN = cqn => {
 
 // scope: simple wheres à la "[{ ref: ['foo'] }, '=', { val: 'bar' }, 'and', ... ]"
 function where2obj(where, target = null, data = {}) {
-  for (let i = 0; i < where.length; i++) {
-    const whereEl = where[i]
-
-    if (whereEl.xpr) {
-      where2obj(whereEl.xpr, target, data)
+  for (let i = 0; i < where.length; ) {
+    const a = where[i++]
+    if (a.xpr) {
+      where2obj(a.xpr, target, data)
+      continue
     }
+    if (!a.ref) continue
 
-    const colName = whereEl.ref && whereEl.ref[whereEl.ref.length - 1]
-    // optional validation if target is passed
-    if (target) {
-      const colEl = target.elements[colName]
-      if (!colEl || !colEl.key) continue
-    }
-    const opWhere = where[i + 1]
-    const valWhere = where[i + 2]
-    if (opWhere === '=' && valWhere && 'val' in valWhere) data[colName] = valWhere.val
+    const el = a.ref.at(-1)
+    if (target && el in target.keys === false) continue
+
+    const op = where[i++]
+    if (op !== '=') continue
+
+    const b = where[i++]
+    if (!b || 'val' in b === false) continue
+    else data[el] = b.val
   }
   return data
 }