@sap/cds 5.6.2 → 5.7.2

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/uri/UriParser.js

@@ -25,7 +25,7 @@ const FORMAT_REGEXP = new RegExp(
 )
 
 const parseNonNegativeInteger = value => {
-  let tokenizer = new UriTokenizer(value)
+  const tokenizer = new UriTokenizer(value)
   if (tokenizer.next(TokenKind.UnsignedIntegerValue) && tokenizer.next(TokenKind.EOF)) {
     const result = Number.parseInt(value, 10)
     if (Number.isSafeInteger(result)) return result
@@ -66,19 +66,22 @@ queryOptionParserMap.set(QueryOptions.FORMAT, value => {
   throw new UriSyntaxError(UriSyntaxError.Message.WRONG_OPTION_VALUE, QueryOptions.FORMAT)
 })
 queryOptionParserMap.set(QueryOptions.SEARCH, value => {
-  let tokenizer = new UriTokenizer(value)
+  const trimmedValue = value.trim()
+  if (!trimmedValue) return
+
+  const tokenizer = new UriTokenizer(trimmedValue)
   const searchOption = new SearchParser().parse(tokenizer)
   tokenizer.requireNext(TokenKind.EOF)
   return searchOption
 })
 queryOptionParserMap.set(QueryOptions.FILTER, (value, edm, referringType, crossjoinEntitySets, aliases) => {
-  let tokenizer = new UriTokenizer(value)
+  const tokenizer = new UriTokenizer(value)
   const filterOption = new FilterParser(edm).parse(tokenizer, referringType, crossjoinEntitySets, aliases)
   tokenizer.requireNext(TokenKind.EOF)
   return filterOption
 })
 queryOptionParserMap.set(QueryOptions.ORDERBY, (value, edm, referringType, crossjoinEntitySets, aliases) => {
-  let tokenizer = new UriTokenizer(value)
+  const tokenizer = new UriTokenizer(value)
   const orderByOption = new OrderByParser(edm).parse(tokenizer, referringType, crossjoinEntitySets, aliases)
   tokenizer.requireNext(TokenKind.EOF)
   return orderByOption
@@ -86,14 +89,14 @@ queryOptionParserMap.set(QueryOptions.ORDERBY, (value, edm, referringType, cross
 queryOptionParserMap.set(
   QueryOptions.SELECT,
   (value, edm, referringType, crossjoinEntitySets, aliases, isCollection) => {
-    let tokenizer = new UriTokenizer(value)
+    const tokenizer = new UriTokenizer(value)
     const selectOption = new SelectParser(edm).parse(tokenizer, referringType, isCollection)
     tokenizer.requireNext(TokenKind.EOF)
     return selectOption
   }
 )
 queryOptionParserMap.set(QueryOptions.EXPAND, (value, edm, referringType, crossjoinEntitySets, aliases) => {
-  let tokenizer = new UriTokenizer(value)
+  const tokenizer = new UriTokenizer(value)
   const expandOption = new ExpandParser(edm).parse(tokenizer, referringType, crossjoinEntitySets, aliases)
   tokenizer.requireNext(TokenKind.EOF)
   return expandOption
@@ -170,7 +173,7 @@ class UriParser {
 
     // $apply must be parsed first.
     if (queryOptions[QueryOptions.APPLY] !== undefined) {
-      let tokenizer = new UriTokenizer(queryOptions[QueryOptions.APPLY])
+      const tokenizer = new UriTokenizer(queryOptions[QueryOptions.APPLY])
       referringType = new TransientStructuredType(referringType)
       const parseApplyQueryOptionPm = parseQueryOptionsPm
         ? parseQueryOptionsPm.createChild('Parse query option $apply').start()
@@ -219,7 +222,7 @@ class UriParser {
    */
   _parseRelativeUri (uriPathSegments, aliases) {
     let currentUriSegment = uriPathSegments[0]
-    let tokenizer = new UriTokenizer(currentUriSegment)
+    const tokenizer = new UriTokenizer(currentUriSegment)
 
     if (tokenizer.next(TokenKind.EOF)) {
       uriPathSegments.shift()
@@ -257,7 +260,7 @@ class UriParser {
     // Type casts are explicitly not supported (although the parser can parse them)
     FeatureSupport.failUnsupported(FeatureSupport.features.TypeCast, uriPathSegment, 0)
 
-    let tokenizer = new UriTokenizer(uriPathSegment)
+    const tokenizer = new UriTokenizer(uriPathSegment)
     tokenizer.requireNext(TokenKind.QualifiedName)
     const qualifiedName = tokenizer.getText()
     const type = this._edm.getEntityType(FullQualifiedName.createFromNameSpaceAndName(qualifiedName))
@@ -275,7 +278,7 @@ class UriParser {
    */
   _parseResourcePath (uriPathSegments, aliases) {
     let currentUriSegment = uriPathSegments[0]
-    let tokenizer = new UriTokenizer(currentUriSegment)
+    const tokenizer = new UriTokenizer(currentUriSegment)
 
     if (tokenizer.next(TokenKind.ALL)) {
       FeatureSupport.failUnsupported(FeatureSupport.features.All)

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/invocation/ConditionalRequestControlCommand.js

@@ -34,13 +34,6 @@ class ConditionalRequestControlCommand extends Command {
   execute (next) {
     // Validate that the ETag validation has been called by the data handler.
     if (this._request.isConditional()) {
-      if (!this._request.validateEtagHasBeenCalled()) {
-        throw new InternalServerError(
-          'Error in conditional request processing. ' +
-            ' The function validateEtag(etag) has to be called by the application.'
-        )
-      }
-
       // Do not set statusCode directly because of internal response cache.
       if (this._request.getETAGValidationStatus() === StatusCodes.NOT_MODIFIED) {
         this._response.setStatusCode(StatusCodes.NOT_MODIFIED)

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/validator/ConditionalRequestValidator.js

@@ -34,14 +34,6 @@ class ConditionalRequestValidator {
         ) {
           throw new PreconditionFailedError()
         }
-      } else if (
-        method !== HttpMethods.GET ||
-        (ifMatch && ifMatch.trim() !== '*' && ifMatch.trim() !== '"*"') ||
-        ifNoneMatch
-      ) {
-        // A GET request with an If-Match header value of '*' (or '"*"', despite not in RFC 7232) is allowed,
-        // but otherwise concurrency-control headers are not expected here.
-        throw new ConflictError('The requested resource is not concurrent')
       }
     }
   }

package/libx/_runtime/cds-services/adapter/odata-v4/utils/stream.js

@@ -1,9 +1,10 @@
 const cds = require('../../../../cds')
+const LOG = cds.log('odata')
+
 const { SELECT } = cds.ql
-const { isActiveEntityRequested } = require('../../../../fiori/utils/where')
-const { ensureDraftsSuffix } = require('../../../../fiori/utils/handler')
-const { cqn2cqn4sql } = require('../../../../common/utils/cqn2cqn4sql')
-const { findCsnTargetFor } = require('../../../../common/utils/csn')
+
+const { targetFromPath, isPathToDraft } = require('../../../../common/utils/cqn')
+const { deepCopyArray } = require('../../../../common/utils/copy')
 
 const isStreaming = segments => {
   const lastSegment = segments[segments.length - 1]
@@ -14,87 +15,64 @@ const isStreaming = segments => {
   )
 }
 
-const _getProperties = async (properties, req) => {
-  const isActiveRequested = isActiveEntityRequested(req.query.SELECT.from.ref[0].where)
-
-  // REVISIT DRAFT HANDLING: cqn2cqn4sql should not happen here, but adaptStreamCQN relies on exists clause
-  const cqn = cqn2cqn4sql(SELECT.one(req.query.SELECT.from), req._model).columns(properties)
-
-  // REVISIT: renaming of media type property (e.g., mimeType as MimeType in AFC) not reflected in @Core.MediaType
-  if (req.target.query && req.target.query._target && !req.target.drafts) {
-    cqn.SELECT.from.ref[0] = req.target.query._target.name
-  }
-
-  if (!isActiveRequested) {
-    cqn.SELECT.from.ref[0] = ensureDraftsSuffix(cqn.SELECT.from.ref[0])
-  }
-
-  try {
-    return await cds.tx(req).run(cqn)
-  } catch (e) {
-    // REVISIT: why ignore?
-  }
-}
+const getStreamProperties = (req, model) => {
+  const mediaTypeProperty = Object.values(req.target.elements).find(val => val['@Core.MediaType'])
 
-const _getDynamicProperties = (contentType, contentDisposition) => {
-  const properties = {}
-  if (contentType && typeof contentType === 'object') {
-    properties.contentType = Object.values(contentType)[0]
+  let contentType, contentDisposition
+  const columns = []
+  if (typeof mediaTypeProperty['@Core.MediaType'] === 'object') {
+    let contentTypeProperty = mediaTypeProperty['@Core.MediaType']['=']
+    if (!req.target.elements[contentTypeProperty]) {
+      LOG._warn &&
+        LOG.warn(
+          `@Core.MediaType in entity "${req.target.name}" points to property "${contentTypeProperty}" which was renamed or is not part of the projection. You must update the annotation value.`
+        )
+      contentTypeProperty = (Object.values(req.target.elements).find(val => val['@Core.IsMediaType']) || {}).name
+    }
+    if (!req.target.elements[contentTypeProperty]) {
+      LOG._warn && LOG.warn(`No @Core.IsMediaType found in entity "${req.target.name}".`)
+    } else {
+      columns.push({ ref: [contentTypeProperty], as: 'contentType' })
+    }
+  } else {
+    contentType = mediaTypeProperty['@Core.MediaType']
   }
-  if (contentDisposition) {
-    properties.contentDisposition = Object.values(contentDisposition)[0]
+  if (mediaTypeProperty['@Core.ContentDisposition.Filename']) {
+    if (typeof mediaTypeProperty['@Core.ContentDisposition.Filename'] === 'object') {
+      const contentDispositionProperty = mediaTypeProperty['@Core.ContentDisposition.Filename']['=']
+      if (!req.target.elements[contentDispositionProperty]) {
+        LOG._warn &&
+          LOG.warn(
+            `@Core.ContentDisposition.Filename in entity "${req.target.name}" points to property "${contentDispositionProperty}" which was renamed or is not part of the projection. You must update the annotation value.`
+          )
+      } else {
+        columns.push({ ref: [contentDispositionProperty], as: 'contentDisposition' })
+      }
+    } else {
+      contentDisposition = mediaTypeProperty['@Core.ContentDisposition.Filename']
+    }
   }
 
-  return properties
-}
-
-const getStreamProperties = async (segments, srv, req) => {
-  // REVISIT: we need to read directly from db, which might not be there!
-  if (!cds.db) return {}
+  if (columns.length && cds.db && !req.target._hasPersistenceSkip) {
+    // used cloned path
+    const select = SELECT.one.from({ ref: deepCopyArray(req.query.SELECT.from.ref) }).columns(columns)
 
-  let contentType, entityName, namespace, contentDisposition
-  const previous = segments[segments.length - 2]
-  if (previous.getKind() === 'ENTITY') {
-    entityName = previous.getEntitySet().getName()
-    namespace = previous.getEdmType().getFullQualifiedName().namespace
-  } else if (previous.getKind() === 'NAVIGATION.TO.ONE' && previous.getTarget()) {
-    entityName = previous.getTarget().getName()
-    namespace = previous.getTarget().getEntityType().getFullQualifiedName().namespace
-  }
+    if (req.target._isDraftEnabled && isPathToDraft(select.SELECT.from.ref, model))
+      select.SELECT.from.ref[0].id = select.SELECT.from.ref[0].id + '_drafts'
 
-  if (entityName) {
-    const entityDefinition = findCsnTargetFor(entityName, srv.model, namespace)
-    if (entityDefinition._hasPersistenceSkip) return {}
+    // new parser has media property as last ref element -> remove
+    if (targetFromPath(select.SELECT.from.ref, model).kind === 'element') select.SELECT.from.ref.pop()
 
-    const mediaProperty = Object.values(entityDefinition.elements).find(ele => ele['@Core.MediaType'])
-    contentType = mediaProperty['@Core.MediaType']
-    // @Core.ContentDisposition.Filename is correct, but we released with @Core.ContentDisposition, so we should stay compatible
-    contentDisposition = mediaProperty['@Core.ContentDisposition.Filename'] || mediaProperty['@Core.ContentDisposition']
-    // contentDisposition can be only dynamic
-    if (typeof contentType === 'object' || contentDisposition) {
-      const properties = _getDynamicProperties(contentType, contentDisposition)
-      const result = await _getProperties(Object.values(properties), req)
-      if (properties.contentDisposition && result[properties.contentDisposition] !== undefined) {
-        contentDisposition = result[properties.contentDisposition]
-      }
-      // REVISIT: renaming of media type property (e.g., mimeType as MimeType in AFC) not reflected in @Core.MediaType
-      if (properties.contentType) {
-        if (result[properties.contentType] !== undefined) contentType = result[properties.contentType]
-        else {
-          let ct
-          for (const k in entityDefinition.elements) {
-            if (entityDefinition.elements[k]['@Core.IsMediaType']) {
-              ct = k
-              break
-            }
-          }
-          contentType = result[ct]
-        }
-      }
-    }
+    return cds
+      .tx(req)
+      .run(select)
+      .then(res => ({
+        contentType: (res && res.contentType) || contentType,
+        contentDisposition: (res && res.contentDisposition) || contentDisposition
+      }))
   }
 
-  return { contentType, contentDisposition }
+  return Promise.resolve({ contentType, contentDisposition })
 }
 
 module.exports = {

package/libx/_runtime/cds-services/adapter/rest/RestRequest.js

@@ -58,13 +58,6 @@ class RestRequest extends cds.Request {
           return cds.tx(this).run(...args)
         }
     })
-
-    if (this._.req.performanceMeasurement) {
-      this.performanceMeasurement = this._.req.performanceMeasurement
-    }
-    if (this._.req.dynatrace) {
-      this.dynatrace = this._.req.dynatrace
-    }
   }
 }
 

package/libx/_runtime/cds-services/adapter/rest/handlers/create.js

@@ -50,7 +50,7 @@ module.exports = service => {
     const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
     cds.context = tx
 
-    let result, err, commit, location
+    let result, err, location
     try {
       const reqs = data.map(d => new RestRequest(parsed, d, restReq, restRes, service))
       result = await Promise.all(reqs.map(req => tx.dispatch(req)))
@@ -64,14 +64,11 @@ module.exports = service => {
         location = _locationHeader(target, service.name, result)
       }
 
-      commit = true
       await tx.commit(result)
     } catch (e) {
       err = e
-      if (!commit) {
-        // ignore rollback error, which should never happen
-        await tx.rollback(e).catch(() => {})
-      }
+      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
+      await tx.rollback(e).catch(() => {})
     } finally {
       if (err) next(err)
       else {

package/libx/_runtime/cds-services/adapter/rest/handlers/delete.js

@@ -18,18 +18,15 @@ module.exports = service => {
 
     const req = new RestRequest(parsed, data, restReq, restRes, service)
 
-    let err, commit
+    let err
     try {
       await tx.dispatch(req)
 
-      commit = true
       await tx.commit(null)
     } catch (e) {
       err = e
-      if (!commit) {
-        // ignore rollback error, which should never happen
-        await tx.rollback(e).catch(() => {})
-      }
+      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
+      await tx.rollback(e).catch(() => {})
     } finally {
       if (err) next(err)
       else {

package/libx/_runtime/cds-services/adapter/rest/handlers/operation.js

@@ -32,7 +32,7 @@ module.exports = service => {
 
     const req = new RestRequest(parsed, data, restReq, restRes, service)
 
-    let result, err, commit, status, body
+    let result, err, status, body
     try {
       result = await tx.dispatch(req)
 
@@ -44,14 +44,11 @@ module.exports = service => {
         body = _convertCustomOperationReturnValue(operation.returns, result)
       }
 
-      commit = true
       await tx.commit(result)
     } catch (e) {
       err = e
-      if (!commit) {
-        // ignore rollback error, which should never happen
-        await tx.rollback(e).catch(() => {})
-      }
+      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
+      await tx.rollback(e).catch(() => {})
     } finally {
       if (err) next(err)
       else {

package/libx/_runtime/cds-services/adapter/rest/handlers/read.js

@@ -22,7 +22,7 @@ module.exports = service => {
     const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
     cds.context = tx
 
-    let result, err, commit
+    let result, err
     try {
       const req = new RestRequest(parsed, data, restReq, restRes, service)
 
@@ -34,14 +34,11 @@ module.exports = service => {
 
       bufferToBase64(result, segments[0])
 
-      commit = true
       await tx.commit(result)
     } catch (e) {
       err = e
-      if (!commit) {
-        // ignore rollback error, which should never happen
-        await tx.rollback(e).catch(() => {})
-      }
+      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
+      await tx.rollback(e).catch(() => {})
     } finally {
       if (err) next(err)
       else restRes.send(toRestResult(result))

package/libx/_runtime/cds-services/adapter/rest/handlers/update.js

@@ -52,7 +52,7 @@ const update = service => {
     const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
     cds.context = tx
 
-    let result, err, commit, status
+    let result, err, status
     try {
       // try UPDATE and, on 404 error, try CREATE
       result = await _updateThenCreate(parsed, restReq, restRes, tx)
@@ -62,14 +62,11 @@ const update = service => {
 
       bufferToBase64(result, target)
 
-      commit = true
       await tx.commit(result)
     } catch (e) {
       err = e
-      if (!commit) {
-        // ignore rollback error, which should never happen
-        await tx.rollback(e).catch(() => {})
-      }
+      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
+      await tx.rollback(e).catch(() => {})
     } finally {
       if (err) next(err)
       else {

package/libx/_runtime/cds-services/adapter/rest/rest-to-cqn/index.js

@@ -4,7 +4,7 @@ const { INSERT, SELECT, UPDATE, DELETE } = cds.ql
 
 const { createCqlString } = require('./utils')
 const { getColumns } = require('../../../services/utils/columns')
-const { getMaxPageSize } = require('../../../../common/utils/page')
+const { getMaxPageSize, getDefaultPageSize } = require('../../../../common/utils/page')
 
 const _readToCQN = ({ isCollection, segments }, target, restReq) => {
   const key = Object.keys(target.keys)[0]
@@ -20,7 +20,7 @@ const _readToCQN = ({ isCollection, segments }, target, restReq) => {
   if (!isCollection) cqn.SELECT.one = true
 
   if (isCollection && (restReq.query.$top || restReq.query.$skip)) {
-    const top = restReq.query.$top ? parseInt(restReq.query.$top) : Number.MAX_SAFE_INTEGER
+    const top = restReq.query.$top ? parseInt(restReq.query.$top) : getDefaultPageSize(target)
     cqn.limit(Math.min(top, getMaxPageSize(target)), parseInt(restReq.query.$skip) || 0)
   }
 

package/libx/_runtime/cds-services/adapter/rest/utils/parse-url.js

@@ -48,7 +48,7 @@ const _parseEntityOrOperation = part => {
 
 const _findEntityOrCustomOperation = (customOperation, service, name) => {
   const thing =
-    service.entities[name] || service.operations[name] || findCsnTargetFor(name, service.model, service.name)
+    service.entities[name] || service.operations[name] || findCsnTargetFor(name, service.model, service.namespace)
   if (!thing) {
     throw getError(404, 'INVALID_RESOURCE', [name])
   }
@@ -152,13 +152,15 @@ const _parseCreateOrRead2 = (event, parsed, service, parts) => {
   }
 
   parsed.segments.push(
-    _validateEntity(service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.name)),
+    _validateEntity(service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.namespace)),
     parts[1]
   )
 }
 
 const _parseCreateOrRead3 = (service, parts, customOperation, parsed) => {
-  const entity = _validateEntity(service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.name))
+  const entity = _validateEntity(
+    service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.namespace)
+  )
   const key = parts[1]
   const { name, params } = _parseEntityOrOperation(parts[2])
   const operation = _validateCustomOperation(entity, name, customOperation)
@@ -209,7 +211,9 @@ const parseUpdateOrDeleteUrl = (event, service, req) => {
     throw getError(400, 'INVALID_PUT')
   }
 
-  const entity = _validateEntity(service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.name))
+  const entity = _validateEntity(
+    service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.namespace)
+  )
   const segments = [entity]
 
   if (parts[1]) {

package/libx/_runtime/cds-services/services/Service.js

@@ -22,12 +22,6 @@ class ApplicationService extends cds.Service {
     this._calculateDiff = this._differ.calculate
   }
 
-  set model(csn) {
-    const m = csn && 'definitions' in csn ? cds.linked(cds.compile.for.odata(csn)) : csn
-    cds.alpha_localized(m) // with compiler v2 we always need to localized the csn
-    super.model = m
-  }
-
   init() {
     /*
      * .before handlers (all with _initial === true)

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

@@ -116,11 +116,15 @@ const getSearchableColumns = entity => {
 /**
  * @returns {import('../../../types/api').ColumnRefs}
  */
-const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }) => {
+const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }, alias) => {
   // if there is a group by clause, only columns in it may be searched
   let toBeSearched = [...entity._searchableColumns]
   if (cqn.SELECT.groupBy) toBeSearched = toBeSearched.filter(tbs => cqn.SELECT.groupBy.some(gb => gb.ref[0] === tbs))
-  toBeSearched = toBeSearched.map(c => ({ ref: [c] }))
+  toBeSearched = toBeSearched.map(c => {
+    const col = { ref: [c] }
+    if (alias) col.ref.unshift(alias)
+    return col
+  })
 
   // add aggregations
   cqn.SELECT.columns &&
@@ -141,7 +145,10 @@ const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }) =>
       if (columnRef) {
         const columnName = columnRef[columnRef.length - 1]
         const csnColumn = entity.elements[columnName]
-        if (!csnColumn) toBeSearched.push({ ref: [columnName] })
+        if (csnColumn) return
+        const col = { ref: [columnName] }
+        if (alias) col.ref.unshift(alias)
+        toBeSearched.push(col)
       }
     })
 

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

@@ -131,14 +131,11 @@ const _addToBeDeletedEntriesToResult = (results, entity, keys, newValues, oldVal
   }
 }
 
-const _normalizeToArray = value => (Array.isArray(value) ? value : [value])
+const _normalizeToArray = value => (Array.isArray(value) ? value : value === null ? [] : [value])
 
 const _addKeysToEntryIfNotExists = (keys, newEntry) => {
-  for (const key of keys) {
-    if (!(key in newEntry)) {
-      newEntry[key] = undefined
-    }
-  }
+  if (!newEntry) return
+  for (const key of keys) if (!(key in newEntry)) newEntry[key] = undefined
 }
 
 const _isUnManaged = element => {
@@ -268,7 +265,7 @@ const compareJson = (newValue, oldValue, entity) => {
   return Array.isArray(newValue) ? result : result[0]
 }
 
-const _isObject = item => item && typeof item === 'object' && !Array.isArray(item)
+const _isObject = item => item && typeof item === 'object' && !Array.isArray(item) && !Buffer.isBuffer(item)
 
 const _mergeArrays = (entity, oldValue, newValue) => {
   const merged = []

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

@@ -58,10 +58,13 @@ module.exports = class {
 
   async _diffUpdate(req, providedData) {
     if (cds.db) {
+      // REVISIT: remove try catch with cds^6
       try {
         await this._addPartialPersistentState(req)
       } catch (e) {
-        LOG._warn && LOG.warn('Unable to calculate diff due to error: ' + e.message, e)
+        // NOTE: unofficial compat flag!
+        if (cds.env.features.throw_diff_error !== false) throw e
+        else LOG._error && LOG.error('Unable to calculate diff due to error: ' + e.message, e)
       }
     }
     const newQuery = cqn2cqn4sql(req.query, this._srv.model)

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

@@ -1,9 +1,7 @@
 const cds = require('../../../cds')
-
 const { SELECT } = cds.ql
 
-const { checkReferenceIntegrity } = require('../../util/assert')
-const { processDeep, processDeepAsync } = require('../../util/dataProcessUtils')
+const { processDeep } = require('../../util/dataProcessUtils')
 
 const { DRAFT_COLUMNS } = require('../../../common/constants/draft')
 
@@ -145,43 +143,6 @@ const flattenDeepToOneAssociations = (req, csn) => {
   )
 }
 
-const checkIntegrityWrapper = (req, csn, run) => async (data, entity) => {
-  const errors = await checkReferenceIntegrity(entity, data, req, csn, run)
-  if (errors && errors.length !== 0) {
-    for (const err of errors) {
-      req.error(err)
-    }
-  }
-}
-
-const _isUncheckableInsert = query => {
-  return query.INSERT && (query.INSERT.rows || query.INSERT.values || query.INSERT.as)
-}
-
-// REVISIT: lower to db layer, where it's used
-const checkIntegrityUtil = async (req, csn, run) => {
-  if (!run) return
-
-  // REVISIT
-  if (typeof req.query === 'string' || req.target._unresolved) return
-
-  // FIXME: doesn't work for uncheckable inserts
-  if (_isUncheckableInsert(req.query)) return
-
-  // REVISIT: integrity check needs context.data
-  if (Object.keys(req.data).length === 0) {
-    // REVISIT: We may need to double-check re req.data being undefined or empty
-    if (req.query.DELETE) {
-      req.data = req._beforeDeleteData || {}
-    } else if (req.context && req.context.data && Object.keys(req.context.data).length > 0) {
-      req.data = req.context.data
-    }
-  }
-  if (Object.keys(req.data).length === 0) return
-
-  await processDeepAsync(checkIntegrityWrapper(req, csn, run), req.data, req.target, false, true)
-}
-
 /*
  * merge CQNs
  */
@@ -235,6 +196,5 @@ const getDeepSelect = req => {
 module.exports = {
   getDeepSelect,
   allKeysAreProvided,
-  checkIntegrityUtil,
   flattenDeepToOneAssociations
 }