@sap/cds 5.9.8 → 6.0.3

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

@@ -1,7 +1,5 @@
 const cds = require('../../cds')
 
-const Differ = require('./utils/differ')
-
 const { resolveView, restoreLink, findQueryTarget } = require('../../common/utils/resolveView')
 const { postProcess } = require('../../common/utils/postProcessing')
 
@@ -16,21 +14,7 @@ const CRUD = Object.assign({ READ: 1 }, WRITE_EVENTS)
  * Generic Service Event Handler.
  */
 class ApplicationService extends cds.Service {
-  constructor(name, csn, options) {
-    // REVISIT: do we still need that -> likely due to legacy test?
-    // If not we should remove this legacy constructor
-    if (typeof name === 'object') [name, csn, options] = [csn.service, name, csn]
-    super(name, csn, options)
-
-    // REVISIT: umbrella calls srv._calculateDiff
-    this._differ = new Differ(this)
-    this._calculateDiff = this._differ.calculate
-  }
-
   init() {
-    /*
-     * .before handlers (all with _initial === true)
-     */
     require('../../common/generic/auth').call(this, this)
     require('../../common/generic/etag').call(this, this)
     require('../../common/generic/input').call(this, this)
@@ -38,21 +22,9 @@ class ApplicationService extends cds.Service {
     require('../../common/generic/temporal').call(this, this)
     require('../../common/generic/paging').call(this, this) // > paging must be executed before sorting
     require('../../common/generic/sorting').call(this, this)
-
-    // draft handlers needed?
-    // REVISIT: serve 2 fiori
-    this._2fiori = Object.values(this.entities).some(e => e._isDraftEnabled)
-    if (this._2fiori) this.registerFioriHandlers()
-
-    // personal data audit logging
-    this._4audit = cds.env.features.audit_personal_data && Object.values(this.entities).some(e => e._hasPersonalData)
-    if (this._4audit) this.registerPersonalDataHandlers()
-
-    /*
-     * .on handlers
-     */
-    require('../../common/generic/crud').call(this, this)
-
+    this.registerFioriHandlers(this)
+    this.registerPersonalDataHandlers(this)
+    this.registerCrudHandlers(this) // default .on handlers, have to go last
     return this
   }
 
@@ -66,7 +38,6 @@ class ApplicationService extends cds.Service {
 
   /**
    * Registers custom handlers.
-   *
    * @param {string | object | Function} serviceImpl - init function to register custom handlers.
    */
   impl(serviceImpl) {
@@ -74,43 +45,16 @@ class ApplicationService extends cds.Service {
     return this.prepend(serviceImpl)
   }
 
+  registerPersonalDataHandlers() {
+    return cds.env.features.audit_personal_data && require('../../audit/generic/personal').impl.call(this)
+  }
+
   registerFioriHandlers() {
-    if (this._draftHandlersRegistered) return
-    this._draftHandlersRegistered = true
-
-    /*
-     * .before handlers (all with _initial === true)
-     */
-    require('../../fiori/generic/before').call(this, this)
-
-    /*
-     * .on handlers
-     */
-    require('../../fiori/generic/new').call(this, this) // > NEW
-    require('../../fiori/generic/patch').call(this, this) // > PATCH
-    require('../../fiori/generic/cancel').call(this, this) // > CANCEL
-    require('../../fiori/generic/edit').call(this, this) // > EDIT
-    require('../../fiori/generic/prepare').call(this, this) // > draftPrepare (-> should be PREPARE)
-    require('../../fiori/generic/activate').call(this, this) // > draftActivate (-> should be ACTIVATE)
-    require('../../fiori/generic/readOverDraft').call(this, this) // > READ non-draft via navigation
-    require('../../fiori/generic/read').call(this, this) // > READ
-    require('../../fiori/generic/delete').call(this, this) // > DELETE
+    return require('../../fiori/generic').impl.call(this)
   }
 
-  registerPersonalDataHandlers() {
-    // register directly if cds.db is already set, otherwise on connect of a DatabaseService
-    if (cds.db && !this._personalDataHandlersRegistered) {
-      require('../../audit/generic/personal').call(this, this)
-      this._personalDataHandlersRegistered = true
-    } else {
-      const that = this
-      cds.on('connect', srv => {
-        if (srv instanceof cds.DatabaseService && !that._personalDataHandlersRegistered) {
-          require('../../audit/generic/personal').call(that, that)
-          that._personalDataHandlersRegistered = true
-        }
-      })
-    }
+  registerCrudHandlers() {
+    return require('../../common/generic/crud').impl.call(this)
   }
 
   /**
@@ -128,18 +72,18 @@ class ApplicationService extends cds.Service {
    */
   getRestrictions(definition, event, user) {
     let restrictions = getNormalizedRestrictions(definition, this.model.definitions, event)
-    if ((!restrictions || !restrictions.length) && (event in CRUD || !definition.parent)) {
+    if (!restrictions && (event in CRUD || !definition.parent)) {
       // > unrestricted entity or unbound
       return null
     }
-    if (event in CRUD && restrictions.every(r => r.grant !== '*' && !(r.grant in CRUD))) {
+    if (event in CRUD && restrictions.length && restrictions.every(r => r.grant !== '*' && !(r.grant in CRUD))) {
       // > only bounds are restricted
       return null
     }
-    if (!(event in CRUD) && (!restrictions || !restrictions.length) && definition.parent) {
+    if (!(event in CRUD) && !restrictions && definition.parent) {
       // > bound without own restrictions -> get from parent
       restrictions = getNormalizedRestrictions(definition.parent, this.model.definitions, event)
-      if (!restrictions || !restrictions.length) {
+      if (!restrictions) {
         // > unrestricted bound
         return null
       }
@@ -152,16 +96,13 @@ class ApplicationService extends cds.Service {
   // Result is post processed according to the inverse projection in order to reflect the correct result of the original query.
   async handle(req) {
     // compat mode
-    if (req._resolved || cds.env.features.resolve_views === false) return super.handle(req)
-
-    if (req.target && req.target.name && this.definition && req.target.name.startsWith(this.definition.name + '.')) {
-      return super.handle(req)
-    }
+    if (req._resolved) return super.handle(req)
+    if (req.target && req.target.name && req.target.name.startsWith(this.namespace + '.')) return super.handle(req)
 
     // req.query can be:
     // - empty object in case of unbound action/function
     // - undefined/null in case of plain string queries
-    if (_isSimpleCqnQuery(req.query) && this.model) {
+    if (this.model && _isSimpleCqnQuery(req.query)) {
       const q = resolveView(req.query, this.model, this)
       const t = findQueryTarget(q) || req.target
 

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

@@ -39,7 +39,7 @@ const getColumns = (
   return columns
 }
 
-const getSearchableColumns = entity => {
+const _getSearchableColumns = entity => {
   const columnsOptions = { removeIgnore: true, filterVirtual: true }
   const columns = getColumns(entity, columnsOptions)
   const cdsSearchTerm = '@cds.search'
@@ -121,9 +121,11 @@ const getSearchableColumns = entity => {
 /**
  * @returns {import('../../../types/api').ColumnRefs}
  */
-const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }, alias) => {
+const computeColumnsToBeSearched = (cqn, entity = { __searchableColumns: [] }, alias) => {
   // if there is a group by clause, only columns in it may be searched
-  let toBeSearched = [...entity._searchableColumns]
+  let toBeSearched =
+    entity.own('__searchableColumns') || entity.set('__searchableColumns', _getSearchableColumns(entity))
+
   if (cqn.SELECT.groupBy) toBeSearched = toBeSearched.filter(tbs => cqn.SELECT.groupBy.some(gb => gb.ref[0] === tbs))
   toBeSearched = toBeSearched.map(c => {
     const col = { ref: [c] }
@@ -142,6 +144,7 @@ const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }, al
           (column.as === '_counted_' || column.as === '$count')
         )
           return
+
         toBeSearched.push(column)
         return
       }
@@ -162,6 +165,5 @@ const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }, al
 
 module.exports = {
   getColumns,
-  getSearchableColumns,
   computeColumnsToBeSearched
 }

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

@@ -265,58 +265,6 @@ const compareJson = (newValue, oldValue, entity) => {
   return Array.isArray(newValue) ? result : result[0]
 }
 
-const _isObject = item => item && typeof item === 'object' && !Array.isArray(item) && !Buffer.isBuffer(item)
-
-const _mergeArrays = (entity, oldValue, newValue) => {
-  const merged = []
-  const foundIdxNew = []
-  const keys = _getKeysOfEntity(entity)
-  for (const entry of oldValue) {
-    const idxNew = _getIdxCorrespondingEntryWithSameKeys(newValue, entry, keys)
-    if (idxNew === -1) merged.push(entry)
-    else {
-      foundIdxNew.push(idxNew)
-      merged.push(mergeJsonDeep(entity, entry, newValue[idxNew]))
-    }
-  }
-  for (let i = 0; i < newValue.length; i++) {
-    if (!foundIdxNew.includes(i)) merged.push(newValue[i])
-  }
-  return merged
-}
-
-const mergeJsonDeep = (entity, oldValue, value) => {
-  // REVISIT readAfterWrite -> commit -> postProcessing
-  // Detach result from req.data
-  const newValue = value ? Object.assign({}, value) : oldValue // if newValue === undefined
-  if (_isObject(oldValue) && _isObject(newValue)) {
-    // append to newValue to keep an order of attributes as might be defined in custom handler
-    Object.keys(oldValue).forEach(key => {
-      if (!(key in newValue)) {
-        Object.assign(newValue, { [key]: oldValue[key] })
-      } else {
-        const target = entity && entity.elements[key] && entity.elements[key]._target
-        if (_isObject(newValue[key])) {
-          newValue[key] = mergeJsonDeep(target, oldValue[key], newValue[key])
-        } else if (Array.isArray(newValue[key])) {
-          if (target) {
-            newValue[key] = _mergeArrays(target, oldValue[key], newValue[key])
-          }
-          // Can't merge items without target
-        }
-      }
-    })
-  }
-  return newValue
-}
-
-// Signature similar to Object.assign(oldValue, newValue)
-const mergeJson = (oldValue, newValue, entity) => {
-  const result = mergeJsonDeep(entity, oldValue, newValue)
-  return result
-}
-
 module.exports = {
-  compareJson,
-  mergeJson
+  compareJson
 }

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

@@ -1,5 +1,4 @@
 const cds = require('../../../cds')
-const LOG = cds.log('app')
 const { SELECT } = cds.ql
 
 const { compareJson } = require('./compareJson')
@@ -11,7 +10,7 @@ const { cqn2cqn4sql, convertPathExpressionToWhere } = require('../../../common/u
 const { revertData } = require('../../../common/utils/resolveView')
 const { removeIsActiveEntityRecursively } = require('../../../fiori/utils/where')
 
-module.exports = class {
+module.exports = class Differ {
   constructor(srv) {
     this._srv = srv
   }
@@ -51,16 +50,7 @@ module.exports = class {
   }
 
   async _diffUpdate(req, providedData) {
-    if (cds.db) {
-      // REVISIT: remove try catch with cds^6
-      try {
-        await this._addPartialPersistentState(req)
-      } catch (e) {
-        // NOTE: unofficial compat flag!
-        if (cds.env.features.throw_diff_error !== false) throw e
-        else LOG.error('Unable to calculate diff due to error: ' + e.message, e)
-      }
-    }
+    if (cds.db) await this._addPartialPersistentState(req)
     const newQuery = cqn2cqn4sql(req.query, this._srv.model)
     const combinedData = providedData || Object.assign({}, req.query.UPDATE.data || {}, req.query.UPDATE.with || {})
     const lastTransition = newQuery.UPDATE._transitions[newQuery.UPDATE._transitions.length - 1]
@@ -93,13 +83,19 @@ module.exports = class {
   }
 
   async calculate(req, providedData) {
-    // umbrella calls _calculateDiff with srv as this
-    const that = this._differ || this
-
-    if (req.event === 'CREATE') return that._diffCreate(req, providedData)
+    if (req.event === 'CREATE') return this._diffCreate(req, providedData)
     if (req.target._hasPersistenceSkip) return
-    if (req.event === 'DELETE') return that._diffDelete(req)
-    if (req.event === 'UPDATE') return that._diffUpdate(req, providedData)
-    if (req.event === 'PATCH') return that._diffPatch(req, providedData)
+    if (req.event === 'DELETE') return this._diffDelete(req)
+    if (req.event === 'UPDATE') return this._diffUpdate(req, providedData)
+    if (req.event === 'PATCH') return this._diffPatch(req, providedData)
+  }
+
+  // is used as a req instance method
+  static reqDiff(req = this, data) {
+    const { _service: d } = req.target
+    if (!d) return Promise.resolve([])
+    const srv = cds.services[d.name]
+    if (!srv) return Promise.resolve([])
+    return new Differ(srv).calculate(req, data)
   }
 }

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

@@ -1,3 +1,6 @@
+const cds = require('../../cds')
+const LOG = cds.log('app')
+
 // REVISIT: replace with cds.Request
 const getEntry = require('../../common/error/entry')
 
@@ -28,11 +31,13 @@ const _enumValues = element => {
   return Object.keys(element).map(enumKey => {
     const enum_ = element[enumKey]
     const enumValue = enum_ && enum_.val
+
     if (enumValue !== undefined) {
       if (enumValue['=']) return enumValue['=']
       if (enum_ && enum_.literal && enum_.literal === 'number') return Number(enumValue)
       return enumValue
     }
+
     return enumKey
   })
 }
@@ -40,35 +45,41 @@ const _enumValues = element => {
 // REVISIT: this needs a cleanup!
 const assertError = (code, element, value, key, pathSegments = []) => {
   let args
+
   if (typeof code === 'object') {
     args = code.args
     code = code.code
   }
+
   const { name, type, precision, scale } = element
-  pathSegments = pathSegments.slice(0)
-  pathSegments.push({ key: name || key })
-  const path = pathSegments.map(({ key, url }) => url || key).join('/')
+  const path = `${pathSegments.join('/')}${pathSegments.length ? '/' : ''}${name || key}`
+
+  const error = new Error()
+  const errorEntry = {
+    code,
+    message: code,
+    target: path,
+    args: args || [name || key]
+  }
 
-  const e = new Error()
-  const error = Object.assign(e, getEntry({ code, message: code, target: path, args: args || [name || key] }))
-  Object.assign(error, {
+  const assertError = Object.assign(error, getEntry(errorEntry))
+  Object.assign(assertError, {
     entity: element.parent && element.parent.name,
     element: name, // > REVISIT: when is error.element needed?
     type: element.items ? element.items._type : type,
     value
   })
 
-  if (element.enum) error.enum = _enumValues(element)
-
-  if (precision) error.precision = precision
-  if (scale) error.scale = scale
+  if (element.enum) assertError.enum = _enumValues(element)
+  if (precision) assertError.precision = precision
+  if (scale) assertError.scale = scale
 
   if (element.target) {
     // REVISIT: when does this case apply?
-    error.target = element.target
+    assertError.target = element.target
   }
 
-  return error
+  return assertError
 }
 
 const _checkString = value => {
@@ -97,7 +108,8 @@ const _checkBoolean = value => {
 }
 
 const _checkBuffer = value => {
-  return Buffer.isBuffer(value)
+  // REVISIT: Extension parameter in push is an object with buffer data
+  return Buffer.isBuffer(value) || value.type === 'Buffer'
 }
 
 const _checkUUID = value => {
@@ -170,7 +182,7 @@ const checkComplexType = ([key, value], elements, ignoreNonModelledData) => {
   return found || ignoreNonModelledData
 }
 
-const _checkStaticElementByKey = (definition, key, value, result = [], ignoreNonModelledData = true) => {
+const checkStaticElementByKey = (definition, key, value, result = [], ignoreNonModelledData = true) => {
   const elementsOrParameters = definition.elements || definition.params
   if (!elementsOrParameters) return result
   const elementOrParameter = elementsOrParameters[key]
@@ -217,11 +229,13 @@ const _getEnumElement = element => {
 const _checkEnumElement = (element, value, errors, key, pathSegments) => {
   const enumElements = _getEnumElement(element)
   const enumValues = enumElements && _enumValues(enumElements)
+
   if (enumElements && !enumValues.includes(value)) {
     const args =
       typeof value === 'string'
         ? ['"' + value + '"', enumValues.map(ele => '"' + ele + '"').join(', ')]
         : [value, enumValues.join(', ')]
+
     errors.push(assertError({ code: ASSERT_ENUM, args }, element, value, key, pathSegments))
   }
 }
@@ -244,6 +258,7 @@ const _checkFormatElement = (element, value, errors, key, pathSegments) => {
 // check for forbidden deep operations for association
 const checkIfAssocDeep = (element, value, req) => {
   if (!value) return
+
   if (element.on) {
     req.error(
       assertError(
@@ -254,20 +269,24 @@ const checkIfAssocDeep = (element, value, req) => {
         value
       )
     )
-  } else if (element.is2one) {
+
+    return
+  }
+
+  if (element.is2one) {
     // managed to one
     Object.keys(value).forEach(prop => {
       if (typeof value[prop] !== 'object') {
-        const key = element.keys.find(el => el.ref[0] === prop)
-        if (!key) {
-          const err = assertError(
-            { code: ASSERT_DEEP_ASSOCIATION, args: ['managed to-one', element.name] },
-            element,
-            value
-          )
-          err.target += `.${prop}`
-          req.error(err)
-        }
+        const key = element.keys.find(element => element.ref[0] === prop)
+        if (key) return
+
+        const err = assertError(
+          { code: ASSERT_DEEP_ASSOCIATION, args: ['managed to-one', element.name] },
+          element,
+          value
+        )
+        err.target += `.${prop}`
+        req.error(err)
       }
     })
   }
@@ -276,18 +295,18 @@ const checkIfAssocDeep = (element, value, req) => {
 /**
  * @param {import('../../types/api').InputConstraints} constraints
  */
-const checkInputConstraints = ({ element, value, errors, key, path, event }) => {
+const checkInputConstraints = ({ element, value, errors, key, pathSegments }) => {
   if (!element) return errors
 
-  _checkMandatoryElement(element, value, errors, key, path)
+  _checkMandatoryElement(element, value, errors, key, pathSegments)
 
   if (value == null) return errors
 
-  _checkEnumElement(element, value, errors, key, path)
+  _checkEnumElement(element, value, errors, key, pathSegments)
 
-  _checkRangeElement(element, value, errors, key, path)
+  _checkRangeElement(element, value, errors, key, pathSegments)
 
-  _checkFormatElement(element, value, errors, key, path)
+  _checkFormatElement(element, value, errors, key, pathSegments)
 
   return errors
 }
@@ -297,9 +316,9 @@ const checkStatic = (definition, data, ignoreNonModelledData = false) => {
 
   return data.reduce((result, row) => {
     return Object.entries(row)
-      .filter(([key, value]) => value !== null && value !== undefined)
+      .filter(([, value]) => value !== null && value !== undefined)
       .reduce((result, [key, value]) => {
-        return _checkStaticElementByKey(definition, key, value, result, ignoreNonModelledData)
+        return checkStaticElementByKey(definition, key, value, result, ignoreNonModelledData)
       }, result)
   }, [])
 }
@@ -315,12 +334,65 @@ const checkKeys = (entity, data) => {
       if (row[key] === undefined && !entity.elements[key].isAssociation)
         result.push(assertError(ASSERT_NOT_NULL, entity.elements[key]))
     }
+
     return result
   }, [])
 }
 
 const assertNotNullError = element => assertError(ASSERT_NOT_NULL, element)
 
+/**
+ * Check whether the target entity referenced by the association (the reference's target) exists and assert an error if
+ * the the reference's target doesn't exist.
+ *
+ * In other words, use this annotation to check whether a non-null foreign key input in a table has a corresponding
+ * primary key (also known as a parent key) in the associated/referenced target table (also known as a parent table).
+ *
+ * @param {import('../../types/api').assertTargetMap} assertMap
+ * @param {array} errors An array to appends the possible errors.
+ * @see {@link https://pages.github.tools.sap/cap/docs/guides/providing-services#assert-target @assert.target} for
+ * further information.
+ */
+const assertTargets = async (assertMap, errors) => {
+  const { targets: targetsMap, allTargets } = assertMap
+  if (targetsMap.size === 0) return
+
+  const targets = Array.from(targetsMap.values())
+  const transactions = targets.map(({ keys, entity }) => {
+    const where = Object.assign({}, ...keys)
+    return cds.db.exists(entity, where).forShareLock()
+  })
+  const targetsExistsResults = await Promise.allSettled(transactions)
+
+  targetsExistsResults.forEach((txPromise, index) => {
+    const isPromiseRejected = txPromise.status === 'rejected'
+    const shouldAssertError = (txPromise.status === 'fulfilled' && txPromise.value === null) || isPromiseRejected
+    if (!shouldAssertError) return
+
+    const target = targets[index]
+    const { element } = target.assocInfo
+
+    if (isPromiseRejected) {
+      LOG._debug &&
+        LOG.debug(
+          `The transaction to check the @assert.target constraint for foreign key "${element.name}" failed`,
+          txPromise.reason
+        )
+
+      throw new Error(txPromise.reason.message)
+    }
+
+    allTargets
+      .filter(t => t.key === target.key)
+      .forEach(target => {
+        const { row, pathSegments } = target.assocInfo
+        const key = target.foreignKey.name
+        const error = assertError('ASSERT_TARGET', target.foreignKey, row[key], key, pathSegments)
+        errors.push(error)
+      })
+  })
+}
+
 module.exports = {
   CDS_TYPE_CHECKS,
   checkComplexType,
@@ -329,6 +401,7 @@ module.exports = {
   checkKeys,
   assertError,
   checkIfAssocDeep,
-  checkStaticElementByKey: _checkStaticElementByKey,
-  assertNotNullError
+  checkStaticElementByKey,
+  assertNotNullError,
+  assertTargets
 }

package/libx/_runtime/cds.js

@@ -1,5 +1,5 @@
 /** @type {import('../../lib')} */
-const cds = global.cds || require('../../lib')
+const cds = require('../../lib')
 module.exports = cds
 
 /*
@@ -9,33 +9,3 @@ const { any, entity, Association } = cds.builtin.classes
 cds.extend(any).with(require('./common/aspects/any'))
 cds.extend(Association).with(require('./common/aspects/Association'))
 cds.extend(entity).with(require('./common/aspects/entity'))
-
-/*
- * mtx?
- */
-Object.defineProperty(cds, '_mtxEnabled', {
-  get: () => cds.mtx && typeof cds.mtx.in === 'function' && !cds.env.features.streamlined_mtx,
-  configurable: true
-})
-Object.defineProperty(cds, '_mpsEnabled', {
-  get: () =>
-    cds.requires.extensibility ||
-    cds.requires.toggles ||
-    (cds.requires.multitenancy && cds.env.features.streamlined_mtx),
-  configurable: true
-})
-
-/*
- * (lazy) feature flags
- */
-// referential integrity
-// REVISIT: why is _db_foreign_key_constraints necessary?
-// REVISIT: Do not access cds.env too early!
-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
-})