@sap/cds 5.6.1 → 5.7.1

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
 }

package/libx/_runtime/cds-services/util/assert.js

@@ -1,10 +1,5 @@
-const cds = require('../../cds')
-const { all, resolve } = require('../../common/utils/thenable')
-const { getDependents } = require('../../common/utils/csn')
-
 // REVISIT: replace with cds.Request
 const getEntry = require('../../common/error/entry')
-const crypto = require('crypto')
 
 const ISO_DATE_PART1 =
   '[1-9]\\d{3}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1\\d|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)'
@@ -27,11 +22,8 @@ const ASSERT_FORMAT = 'ASSERT_FORMAT'
 const ASSERT_DATA_TYPE = 'ASSERT_DATA_TYPE'
 const ASSERT_ENUM = 'ASSERT_ENUM'
 const ASSERT_NOT_NULL = 'ASSERT_NOT_NULL'
-const ASSERT_REFERENCE_INTEGRITY = 'ASSERT_REFERENCE_INTEGRITY'
 const ASSERT_DEEP_ASSOCIATION = 'ASSERT_DEEP_ASSOCIATION'
 
-const ASSERT_INTEGRITY_ANNOTATION = '@assert.integrity'
-
 const _enumValues = element => {
   return Object.keys(element).map(enumKey => {
     const enum_ = element[enumKey]
@@ -178,6 +170,7 @@ const checkComplexType = ([key, value], elements, ignoreNonModelledData) => {
 
 const _checkStaticElementByKey = (definition, key, value, result, ignoreNonModelledData) => {
   const elementsOrParameters = definition.elements || definition.params
+  if (!elementsOrParameters) return result
   const elementOrParameter = elementsOrParameters[key]
 
   if (!elementOrParameter) {
@@ -309,259 +302,6 @@ const checkStatic = (definition, data, ignoreNonModelledData = false) => {
   }, [])
 }
 
-const _checkExistsWhere = (entity, whereList, run) => {
-  const checks = whereList.map(where => {
-    if (where.length === 0) {
-      return true
-    }
-
-    const cqn = {
-      SELECT: {
-        columns: [{ val: 1, as: '_exists' }],
-        from: { ref: [entity.name || entity] },
-        where: where
-      }
-    }
-
-    if (cds.context) {
-      const hash = crypto.createHash('sha1').update(JSON.stringify(cqn)).digest('base64') // fastest hash
-      if (!cds.context.__alreadyExecutedIntegrityChecks) cds.context.__alreadyExecutedIntegrityChecks = new Map()
-      if (cds.context.__alreadyExecutedIntegrityChecks.has(hash)) {
-        return cds.context.__alreadyExecutedIntegrityChecks.get(hash)
-      } else {
-        const promise = run(cqn).then(exists => {
-          return exists.length !== 0
-        })
-        // we store the promise object in the map, it won't get executed twice when calling await Promise.all([promise, promise])
-        cds.context.__alreadyExecutedIntegrityChecks.set(hash, promise)
-        return promise
-      }
-    }
-    return run(cqn).then(exists => {
-      return exists.length !== 0
-    })
-  })
-
-  return all(checks)
-}
-
-const _checkExists = (entity, data, req, run) => {
-  if (!Array.isArray(data)) {
-    return _checkExists(entity, [data], req, run).then(result => {
-      return result[0]
-    })
-  }
-
-  const where = data.map(row => {
-    return Object.keys(entity.keys).reduce((where, name) => {
-      if (row[name] !== undefined && row[name] !== null) {
-        if (where.length > 0) {
-          where.push('and')
-        }
-        where.push({ ref: [name] }, '=', { val: row[name] })
-      }
-
-      return where
-    }, [])
-  })
-  return _checkExistsWhere(entity, where, run)
-}
-
-const _getFullForeignKeyName = (elementName, foreignKeyName) => `${elementName}_${foreignKeyName}`
-
-const _foreignKeyReducer = (key, foreignKeyName, row, element, ref) => {
-  const fullForeignKeyName = _getFullForeignKeyName(element.name, foreignKeyName)
-
-  if (ref.length > 1) {
-    // ref includes assoc name, so we need to replace it by foreign key name
-    const refWithFlatForeignKey = [...ref.slice(0, ref.length - 1), fullForeignKeyName]
-    key[foreignKeyName] = _getDataFromRef(row, refWithFlatForeignKey)
-  } else {
-    key[foreignKeyName] = Object.prototype.hasOwnProperty.call(row, fullForeignKeyName) ? row[fullForeignKeyName] : null
-  }
-
-  return key
-}
-
-const _buildForeignKey = (element, row, ref) => {
-  let foreignKey
-
-  if (element.keys) {
-    foreignKey = element.keys
-      .map(obj => obj.ref[obj.ref.length - 1])
-      .reduce((key, foreignKeyName) => {
-        return _foreignKeyReducer(key, foreignKeyName, row, element, ref)
-      }, {})
-  }
-
-  return foreignKey
-}
-
-const _getDataFromRef = (row, ref) => {
-  if (row === undefined) return
-
-  if (ref.length > 1) {
-    return _getDataFromRef(row[ref[0]], ref.slice(1))
-  }
-
-  return row[ref[0]]
-}
-
-const _getElement = (entity, ref) => {
-  if (ref.length > 1) {
-    // structured
-    return _getElement(entity.elements[ref[0]], ref.slice(1))
-  }
-
-  return entity.elements[ref[0]]
-}
-
-const _checkCreateUpdate = (result, ref, rootEntity, checks, data, req, run) => {
-  const resolvedElement = _getElement(rootEntity, ref)
-
-  return data.reduce((result, row) => {
-    if (resolvedElement.on) return result
-
-    const foreignKey = _buildForeignKey(resolvedElement, row, ref)
-    if (foreignKey === undefined) return result
-
-    checks.push(
-      _checkExists(resolvedElement._target, foreignKey, req, run).then(exists => {
-        if (!exists) {
-          result.push(assertError(ASSERT_REFERENCE_INTEGRITY, resolvedElement, foreignKey))
-        }
-      })
-    )
-
-    return result
-  }, result)
-}
-
-const _buildWhereDelete = (result, key, element, data) => {
-  return data
-    .map(d => {
-      return Object.keys(d).reduce((result, name) => {
-        if (key.ref[0] === name) {
-          if (result.length > 0) {
-            result.push('and')
-          }
-          result.push({ ref: [_getFullForeignKeyName(element.name, key.ref[0])] }, '=', { val: d[name] })
-        }
-
-        return result
-      }, result)
-    })
-    .reduce((accumulatedWhere, currentWhere, i) => {
-      if (i > 0) accumulatedWhere.push('or')
-      accumulatedWhere.push(...currentWhere)
-      return accumulatedWhere
-    }, [])
-}
-
-const _checkDelete = (result, key, entity, checks, req, csn, run, data) => {
-  const elements = csn.definitions[key].elements
-  const source = csn.definitions[key].name
-
-  const dependents = getDependents(req.target, csn) || []
-  const sourceDependent = dependents.find(dep => dep.parent.name === source)
-  if (!sourceDependent) return result
-
-  return Object.keys(elements).reduce((result, assoc) => {
-    if (!elements[assoc].target || !elements[assoc].keys) return result
-
-    const targetDependent = dependents.find(dep => dep.target.name === elements[assoc].target)
-    if (!targetDependent) return result
-
-    const where = elements[assoc].keys.reduce((buildWhere, key) => {
-      return _buildWhereDelete(buildWhere, key, elements[assoc], data)
-    }, [])
-    checks.push(
-      _checkExistsWhere(source, [where], run).then(exists => {
-        if (exists.includes(true)) {
-          result.push(assertError(ASSERT_REFERENCE_INTEGRITY, elements[assoc], req.data))
-        }
-      })
-    )
-    return result
-  }, result)
-}
-
-function _filterStructured(element, structuredAssocs, prefix) {
-  const elements = element.elements
-  for (const subElement in elements) {
-    if (_filterAssocs(elements[subElement], structuredAssocs, prefix)) {
-      structuredAssocs.push([...prefix, elements[subElement].name])
-    }
-  }
-}
-
-const _filterAssocs = (element, structuredAssocs, prefix = []) => {
-  if (element.elements) {
-    _filterStructured(element, structuredAssocs, [...prefix, element.name])
-  }
-
-  return (
-    element._isAssociationStrict &&
-    !element.virtual &&
-    !element.abstract &&
-    element[ASSERT_INTEGRITY_ANNOTATION] !== false &&
-    !element['@odata.contained'] &&
-    !element._target._hasPersistenceSkip
-  )
-}
-
-// can be removed ones we switch to db integrity check
-const checkReferenceIntegrity = (entity, data, req, csn, run) => {
-  const service = entity._service
-  if (entity[ASSERT_INTEGRITY_ANNOTATION] === false || (service && service[ASSERT_INTEGRITY_ANNOTATION] === false)) {
-    return
-  }
-
-  if (!Array.isArray(data)) data = [data]
-
-  const checks = []
-  let result
-  if (req.event === 'CREATE' || req.event === 'UPDATE') {
-    const structuredAssocRefs = []
-    const associationRefs = Object.keys(entity.elements)
-      .filter(elementName => _filterAssocs(entity.elements[elementName], structuredAssocRefs))
-      .map(name => [name])
-    result = [...associationRefs, ...structuredAssocRefs].reduce((createUpdateResult, ref) => {
-      return _checkCreateUpdate(createUpdateResult, ref, entity, checks, data, req, run)
-    }, [])
-  }
-  if (req.event === 'DELETE') {
-    // we are only interested in table-level references not all derived ones on view levels
-    // TODO: why?
-    while (entity.query && entity.query._target) {
-      entity = csn.definitions[entity.query._target.name]
-    }
-
-    result = Object.keys(csn.definitions)
-      .filter(
-        key =>
-          !csn.definitions[key]['@cds.persistence.skip'] &&
-          csn.definitions[key].elements !== undefined &&
-          // skip check for events, aspects and localized tables
-          csn.definitions[key].kind !== 'event' &&
-          csn.definitions[key].kind !== 'aspect' &&
-          csn.definitions[key].kind !== 'type' &&
-          !csn.definitions[key].name.startsWith('localized.')
-      )
-      .reduce((deleteResult, key) => {
-        return _checkDelete(deleteResult, key, entity, checks, req, csn, run, data)
-      }, [])
-  }
-
-  if (checks.length) {
-    return Promise.all(checks).then(() => {
-      return result
-    })
-  }
-
-  return resolve(result || [])
-}
-
 const checkKeys = (entity, data) => {
   if (!Array.isArray(data)) {
     return checkKeys(entity, [data])
@@ -583,7 +323,6 @@ module.exports = {
   checkStatic,
   checkInputConstraints,
   checkKeys,
-  checkReferenceIntegrity,
   assertError,
   checkIfAssocDeep
 }

package/libx/_runtime/cds.js

@@ -22,15 +22,12 @@ Object.defineProperty(cds, '_mtxEnabled', {
  * (lazy) feature flags
  */
 // referential integrity
-Object.defineProperty(cds.env.features, '_foreign_key_constraints', {
-  get: () => cds.env.cdsc.beta && cds.env.cdsc.beta.foreignKeyConstraints,
-  configurable: true
-})
-let assertIntegrity = cds.env.features.assert_integrity
-Object.defineProperty(cds.env.features, 'assert_integrity', {
-  get: () => (assertIntegrity != null ? assertIntegrity : !cds.env.features._foreign_key_constraints),
-  set: val => {
-    assertIntegrity = val
+// REVISIT: why is _db_foreign_key_constraints necessary?
+Object.defineProperty(cds.env.features, '_db_foreign_key_constraints', {
+  get: () => {
+    const { assert_integrity: ai, assert_integrity_type: ait } = cds.env.features
+    if ((typeof ai === 'string' && ai.match(/individual/i)) || (ait && ait.match(/db/i))) return true
+    return false
   },
   configurable: true
 })

package/libx/_runtime/common/aspects/entity.js

@@ -35,7 +35,7 @@ module.exports = class {
         '__isDraftEnabled',
         (this.associations && this.associations.DraftAdministrativeData) ||
           this.name.match(/\.DraftAdministrativeData$/) ||
-          this.own('@odata.draft.enabled') // > case: entity not in service (tests only?)
+          (this.own('@odata.draft.enabled') && this.own('@Common.DraftRoot.ActivationAction'))
       )
     )
   }

package/libx/_runtime/common/composition/delete.js

@@ -140,7 +140,8 @@ const _addToCQNs = (cqns, subCQN, element, definitions, level) => {
   // Since `>2.5.2` compiler generates constraints for compositions of one like for annotations
   // Thus only single 2one case (`$self`-managed composition) has DELETE CASCADE
   // Here it's ignored to simplify i.e. handle all "2ones" in a same manner
-  if (!cds.env.features._foreign_key_constraints || _is2oneComposition(element, definitions)) {
+  // REVISIT: why is _db_foreign_key_constraints necessary?
+  if (!cds.env.features._db_foreign_key_constraints || _is2oneComposition(element, definitions)) {
     cqns[level].push(subCQN)
   }
 }
@@ -251,7 +252,8 @@ const getDeepDeleteCQNs = (definitions, cqn) => {
     _recursivelyAliasRefs(parentWhere, 'ALIAS0', parentAlias)
   }
   const setNullUpdates = []
-  if (cds.env.features._foreign_key_constraints && definitions[entityName].own('__oneCompositionParents')) {
+  // REVISIT: why is _db_foreign_key_constraints necessary?
+  if (cds.env.features._db_foreign_key_constraints && definitions[entityName].own('__oneCompositionParents')) {
     setNullUpdates.push(..._getSetNullParentForeignKeyCQNs(definitions, entityName, parentWhere, draft))
   }
   const subCascadeDeletes = _addSubCascadeDeleteCQN(definitions, compositionTree, parentWhere, 0, [], draft)

package/libx/_runtime/common/composition/update.js

@@ -76,10 +76,13 @@ const _diffData = (newData, oldData, entity, newEntry, oldEntry, definitions) =>
     const oldVal = ctUtils.val(oldData[key])
 
     if (newVal !== undefined && newVal !== oldVal) {
+      if (!entity.elements[key]) continue
+
       if (entity.elements[key]._isStructured && Object.keys(newData[key]).length === 0) {
         // empty structured -> skip
         continue
       }
+
       result[key] = newData[key]
       continue
     }
@@ -135,36 +138,12 @@ function _addSubDeepUpdateCQNForUpdateInsert({
   return deepUpdateData
 }
 
-function _addSubDeepUpdateCQNCollectDelete(deleteCQNs, cqns, index) {
-  deleteCQNs.forEach(deleteCQN => {
-    if (
-      !cqns.find((subCQNs, subIndex) => {
-        if (subIndex > 0) {
-          const deleteIndex = subCQNs.findIndex(cqn => {
-            return cqn.DELETE && cqn.DELETE.from === deleteCQN.DELETE.from
-          })
-          if (deleteIndex > -1) {
-            if (subIndex < index) {
-              subCQNs.splice(deleteIndex, 1)
-            } else {
-              return true
-            }
-          }
-        }
-        return false
-      })
-    ) {
-      cqns[index] = cqns[index] || []
-      cqns[index].push(deleteCQN)
-    }
-  })
-}
-
 function _addSubDeepUpdateCQNCollect(definitions, cqns, updateCQNs, insertCQN, deleteCQN) {
   if (updateCQNs.length > 0) {
     cqns[0] = cqns[0] || []
     cqns[0].push(...updateCQNs)
   }
+
   if (insertCQN.INSERT.entries.length > 0) {
     cqns[0] = cqns[0] || []
     const deepInsertCQNs = getDeepInsertCQNs(definitions, insertCQN)
@@ -184,7 +163,10 @@ function _addSubDeepUpdateCQNCollect(definitions, cqns, updateCQNs, insertCQN, d
     cqns[0] = cqns[0] || []
     const deepDeleteCQNs = getDeepDeleteCQNs(definitions, deleteCQN)
     deepDeleteCQNs.forEach((deleteCQNs, index) => {
-      _addSubDeepUpdateCQNCollectDelete(deleteCQNs, cqns, index)
+      deleteCQNs.forEach(el => {
+        cqns[index] = cqns[index] || []
+        cqns[index].push(el)
+      })
     })
   }
 }
@@ -200,18 +182,26 @@ const _addToData = (subData, entity, element, entry) => {
 
 function _addSubDeepUpdateCQNRecursion({ definitions, compositionTree, entity, data, selectData, cqns, draft }) {
   const selectDataByKey = _dataByKey(entity, selectData)
+
   for (const element of compositionTree.compositionElements) {
     const subData = []
     const selectSubData = []
+
     for (const entry of data) {
       if (element.name in entry) {
-        _addToData(subData, entity, element, entry)
         const selectEntry = selectDataByKey.get(_serializedKey(entity, entry))
+
         if (selectEntry && element.name in selectEntry) {
+          if (selectEntry[element.name] === null && entry[element.name] === null) {
+            continue
+          }
           _addToData(selectSubData, entity, element, selectEntry)
         }
+
+        _addToData(subData, entity, element, entry)
       }
     }
+
     _addSubDeepUpdateCQN({
       definitions,
       compositionTree: element,
@@ -221,6 +211,7 @@ function _addSubDeepUpdateCQNRecursion({ definitions, compositionTree, entity, d
       draft
     })
   }
+
   return cqns
 }
 
@@ -245,11 +236,11 @@ const _addSubDeepUpdateCQN = ({ definitions, compositionTree, data, selectData,
     insertCQN,
     definitions
   })
+
   _addSubDeepUpdateCQNCollect(definitions, cqns, updateCQNs, insertCQN, deleteCQN)
 
-  if (deepUpdateData.length === 0) {
-    return Promise.resolve()
-  }
+  if (deepUpdateData.length === 0) return Promise.resolve()
+
   return _addSubDeepUpdateCQNRecursion({
     definitions,
     compositionTree,
@@ -267,15 +258,16 @@ const _addSubDeepUpdateCQN = ({ definitions, compositionTree, data, selectData,
 
 const hasDeepUpdate = (definitions, cqn) => {
   if (cqn && cqn.UPDATE && cqn.UPDATE.entity && (cqn.UPDATE.data || cqn.UPDATE.with)) {
-    const entityName =
-      (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) || cqn.UPDATE.entity.name || cqn.UPDATE.entity
+    const updateEntity = cqn.UPDATE.entity
+    const entityName = (updateEntity.ref && updateEntity.ref[0]) || updateEntity.name || updateEntity
     const entity = definitions && definitions[ensureNoDraftsSuffix(entityName)]
+
     if (entity) {
-      return !!Object.keys(Object.assign({}, cqn.UPDATE.data || {}, cqn.UPDATE.with || {})).find(k => {
-        return ctUtils.isCompOrAssoc(entity, k)
-      })
+      const keys = Object.keys(Object.assign({}, cqn.UPDATE.data || {}, cqn.UPDATE.with || {}))
+      return !!keys.find(k => ctUtils.isCompOrAssoc(entity, k))
     }
   }
+
   return false
 }
 

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

@@ -32,13 +32,9 @@ const val = element => (element && element.val) || element
 
 const array = x => (Array.isArray(x) ? x : [x])
 
-const isCompOrAssoc = (entity, k, onlyToOne) => {
-  return (
-    entity.elements &&
-    entity.elements[k] &&
-    entity.elements[k].isAssociation &&
-    ((onlyToOne && entity.elements[k].is2one) || !onlyToOne)
-  )
+const isCompOrAssoc = (entity, elementName, onlyToOne) => {
+  const element = entity.elements && entity.elements[elementName]
+  return !!(element && element.isAssociation && ((onlyToOne && element.is2one) || !onlyToOne))
 }
 
 const cleanDeepData = (entity, data, onlyToOne = false) => {

package/libx/_runtime/common/error/standardError.js

@@ -0,0 +1,11 @@
+const isStandardError = err => {
+  return (
+    err instanceof TypeError ||
+    err instanceof ReferenceError ||
+    err instanceof SyntaxError ||
+    err instanceof RangeError ||
+    err instanceof URIError
+  )
+}
+
+module.exports = { isStandardError }