@sap/cds 5.4.3 → 5.5.0

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

@@ -2,6 +2,11 @@ const cds = require('../../cds')
 
 const Differ = require('./utils/differ')
 
+const { resolveView, restoreLink, findQueryTarget } = require('../../common/utils/resolveView')
+const { postProcess } = require('../../common/utils/postProcessing')
+
+const _isSimpleCqnQuery = q => typeof q === 'object' && q !== null && !Array.isArray(q) && Object.keys(q).length > 0
+
 /**
  * Generic Service Event Handler.
  */
@@ -10,8 +15,7 @@ class ApplicationService extends cds.Service {
     // 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]
-    const o = { kind: options.use, ...options, service: name }
-    super(name, csn, o)
+    super(name, csn, options)
 
     // REVISIT: umbrella calls srv._calculateDiff
     this._differ = new Differ(this)
@@ -20,8 +24,7 @@ class ApplicationService extends cds.Service {
 
   set model(csn) {
     const m = csn && 'definitions' in csn ? cds.linked(cds.compile.for.odata(csn)) : csn
-    // with compiler v2 we always need to localized the csn
-    cds.alpha_localized(m)
+    cds.alpha_localized(m) // with compiler v2 we always need to localized the csn
     super.model = m
   }
 
@@ -36,7 +39,6 @@ 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)
-    require('../../common/generic/resolve-mock').call(this, this)
 
     // draft handlers needed?
     // REVISIT: serve 2 fiori
@@ -111,6 +113,39 @@ class ApplicationService extends cds.Service {
       })
     }
   }
+
+  // Overload .handle in order to resolve projections up to a definition that is known by the remote service instance.
+  // 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)
+    }
+
+    // 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) {
+      const q = resolveView(req.query, this.model, this)
+      const t = findQueryTarget(q) || req.target
+
+      // compat
+      restoreLink(req)
+      if (req.query.SELECT && req.query.SELECT._4odata) {
+        q.SELECT._4odata = req.query.SELECT._4odata
+      }
+
+      // REVISIT: We need to provide target explicitly because it's cached already within ensure_target
+      const newReq = new cds.Request({ query: q, target: t, _resolved: true })
+      const result = await super.dispatch(newReq)
+
+      return postProcess(q, result)
+    }
+
+    return super.handle(req)
+  }
 }
 
 module.exports = ApplicationService

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

@@ -99,10 +99,14 @@ const getSearchableColumns = entity => {
   const defaultSearchFilteredColumns = searchableColumns.filter(column => column[defaultSearchElementTerm])
 
   if (defaultSearchFilteredColumns.length > 0) {
-    LOG._warn &&
-      LOG.warn(
-        'Annotation "@Search.defaultSearchElement" is deprecated and will be removed in an upcoming release. Use "@cds.search" instead.'
-      )
+    if (!cds._deprecationWarningForDefaultSearchElement) {
+      LOG._warn &&
+        LOG.warn(
+          'Annotation "@Search.defaultSearchElement" is deprecated and will be removed in an upcoming release. Use "@cds.search" instead.'
+        )
+      cds._deprecationWarningForDefaultSearchElement = true
+    }
+
     return defaultSearchFilteredColumns.map(column => column.name)
   }
 
@@ -129,9 +133,11 @@ const computeColumnsToBeSearched = (cqn, entity = { _searchableColumns: [] }) =>
       }
 
       const columnRef = column.ref
-      const columnName = columnRef[columnRef.length - 1]
-      const csnColumn = entity.elements[columnName]
-      if (!csnColumn) toBeSearched.push({ ref: [columnName] })
+      if (columnRef) {
+        const columnName = columnRef[columnRef.length - 1]
+        const csnColumn = entity.elements[columnName]
+        if (!csnColumn) toBeSearched.push({ ref: [columnName] })
+      }
     })
 
   return toBeSearched

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

@@ -1,7 +1,22 @@
 const { DRAFT_COLUMNS } = require('../../../common/constants/draft')
 
-const _getCorrespondingEntryWithSameKeys = (source, entry, keys) =>
-  source.find(sourceEntry => keys.every(key => sourceEntry[key] === entry[key]))
+const _deepEqual = (val1, val2) => {
+  if (val1 && typeof val1 === 'object' && val2 && typeof val2 === 'object') {
+    for (const key in val1) {
+      if (!_deepEqual(val1[key], val2[key])) return false
+    }
+    return true
+  }
+  return val1 === val2
+}
+
+const _getCorrespondingEntryWithSameKeys = (source, entry, keys) => {
+  const idx = _getIdxCorrespondingEntryWithSameKeys(source, entry, keys)
+  return idx !== -1 ? source[idx] : undefined
+}
+
+const _getIdxCorrespondingEntryWithSameKeys = (source, entry, keys) =>
+  source.findIndex(sourceEntry => keys.every(key => _deepEqual(sourceEntry[key], entry[key])))
 
 const _getKeysOfEntity = entity =>
   Object.keys(entity.keys).filter(key => !DRAFT_COLUMNS.includes(key) && !entity.elements[key].isAssociation)
@@ -63,7 +78,21 @@ const _hasOpDeep = (entry, element) => {
 }
 
 const _addCompositionsToResult = (result, entity, prop, newValue, oldValue) => {
-  const composition = compareJsonDeep(entity.elements[prop]._target, newValue[prop], oldValue && oldValue[prop])
+  /*
+   * REVISIT: the current impl results in {} instead of keeping null for compo to one.
+   *          unfortunately, many follow-up errors occur (e.g., prop in null checks) if changed.
+   */
+  let composition
+  if (
+    newValue[prop] &&
+    typeof newValue[prop] === 'object' &&
+    !Array.isArray(newValue[prop]) &&
+    Object.keys(newValue[prop]).length === 0
+  ) {
+    composition = compareJsonDeep(entity.elements[prop]._target, undefined, oldValue && oldValue[prop])
+  } else {
+    composition = compareJsonDeep(entity.elements[prop]._target, newValue[prop], oldValue && oldValue[prop])
+  }
   if (composition.some(c => _hasOpDeep(c, entity.elements[prop]))) {
     result[prop] = entity.elements[prop].is2one ? composition[0] : composition
   }
@@ -246,4 +275,59 @@ const compareJson = (newValue, oldValue, entity) => {
   return Array.isArray(newValue) ? result : result[0]
 }
 
-module.exports = compareJson
+const _isObject = item => item && typeof item === 'object' && !Array.isArray(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, newValue) => {
+  if (_isObject(oldValue) && _isObject(newValue)) {
+    Object.keys(newValue).forEach(key => {
+      if (_isObject(newValue[key])) {
+        if (!(key in oldValue)) Object.assign(oldValue, { [key]: newValue[key] })
+        else {
+          const target = entity && entity.elements[key] && entity.elements[key]._target
+          oldValue[key] = mergeJsonDeep(target, oldValue[key], newValue[key])
+        }
+      } else if (Array.isArray(newValue[key])) {
+        if (!(key in oldValue)) Object.assign(oldValue, { [key]: newValue[key] })
+        else {
+          const target = entity && entity.elements[key] && entity.elements[key]._target
+          if (target) {
+            oldValue[key] = _mergeArrays(target, oldValue[key], newValue[key])
+          }
+          // Can't merge items without target
+        }
+      } else {
+        Object.assign(oldValue, { [key]: newValue[key] })
+      }
+    })
+  }
+  return oldValue
+}
+
+// Signature similar to Object.assign(oldValue, newValue)
+const mergeJson = (oldValue, newValue, entity) => {
+  const result = mergeJsonDeep(entity, oldValue, newValue)
+  return result
+}
+
+module.exports = {
+  compareJson,
+  mergeJson
+}

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

@@ -2,7 +2,7 @@ const cds = require('../../../cds')
 const LOG = cds.log('app')
 const { SELECT } = cds.ql
 
-const compareJson = require('./compareJson')
+const { compareJson } = require('./compareJson')
 const { selectDeepUpdateData } = require('../../../common/composition')
 const { ensureDraftsSuffix } = require('../../../fiori/utils/handler')
 
@@ -43,9 +43,20 @@ module.exports = class {
   }
 
   _diffDelete(req) {
-    const query = SELECT.from(req.target)
-      .columns(this._createSelectColumnsForDelete(req.target))
-      .where(this._createWhereCondition(req.target, req.data))
+    const { DELETE } = (req._ && req._.query) || req.query
+    const query = SELECT.from(DELETE.from).columns(this._createSelectColumnsForDelete(req.target))
+    if (DELETE.where) query.where(...DELETE.where)
+
+    // REVISIT: should be done in cqn2cqn4sql
+    if (req.target._isDraftEnabled && query.SELECT.from.ref.some(r => r.where)) {
+      query.SELECT.from.ref.forEach((r, i) => {
+        if (!r.where) return
+        const j = r.where.findIndex(w => w.ref && w.ref.some(r => r === 'IsActiveEntity'))
+        if (j === -1) return
+        r.where.splice(Math.max(j - 1, 0), 4)
+      })
+    }
+
     return cds
       .tx(req)
       .run(query)
@@ -53,7 +64,14 @@ module.exports = class {
   }
 
   async _addPartialPersistentState(req) {
-    const deepUpdateData = await selectDeepUpdateData(this._srv.model.definitions, req.query, req, true)
+    const deepUpdateData = await selectDeepUpdateData(
+      this._srv.model.definitions,
+      req.query,
+      req,
+      true,
+      true,
+      this._srv
+    )
     req._.partialPersistentState = deepUpdateData
   }
 
@@ -68,7 +86,7 @@ module.exports = class {
     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]
-    const revertedPersistent = revertData(req._.partialPersistentState, lastTransition)
+    const revertedPersistent = revertData(req._.partialPersistentState, lastTransition, this._srv)
     return compareJson(combinedData, revertedPersistent, req.target)
   }
 

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

@@ -20,7 +20,7 @@ const _getWheres = (key, data) => {
 
 const allKeysAreProvided = req => {
   const data = req.data && (Array.isArray(req.data) ? req.data : [req.data])
-  for (const key of Object.values(req.target.keys)) {
+  for (const key of Object.values(req.target.keys || {})) {
     if (key._isAssociationStrict || DRAFT_COLUMNS.includes(key.name)) {
       continue
     }
@@ -55,7 +55,7 @@ const _getSelectCQN = (req, columns) => {
 
   const data = req.data && (Array.isArray(req.data) ? req.data : [req.data])
 
-  for (const key of Object.values(req.target.keys)) {
+  for (const key of Object.values(req.target.keys || {})) {
     if (key._isAssociationStrict || DRAFT_COLUMNS.includes(key.name)) {
       continue
     }

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

@@ -1,5 +1,6 @@
 const { getCompositionTree } = require('./tree')
 const ctUtils = require('./utils')
+const { getEntityNameFromUpdateCQN } = require('../utils/cqn')
 
 const { ensureNoDraftsSuffix } = require('../utils/draft')
 const { getDBTable } = require('../utils/resolveView')
@@ -38,49 +39,50 @@ const _isSameEntity = (cqn, req) => {
   return true
 }
 
-const _from = query =>
-  (query.UPDATE.entity.ref && query.UPDATE.entity.ref[0]) || query.UPDATE.entity.name || query.UPDATE.entity
-
 const _getLinksOfCompTree = compositionTree => {
   const links = []
+  for (const link of [...compositionTree.backLinks, ...compositionTree.customBackLinks]) {
+    links.push(link.entityKey)
+  }
   for (const compElement of compositionTree.compositionElements || []) {
-    for (const link of compElement.links || []) {
-      links.push(link.entityKey)
+    for (const link of [...compElement.backLinks, ...compElement.customBackLinks]) {
+      links.push(link.targetKey)
     }
   }
   return links
 }
 
-const _dataElements = entity => {
-  // REVISIT: this is expensive
-  return Object.keys(entity.elements)
-    .map(key => entity.elements[key])
-    .filter(e => !e.virtual && !e.isAssociation)
-}
-
 const _whereKeys = keys => {
   const where = []
   keys.forEach(key => {
-    if (where.length > 0) {
-      where.push('or')
-    }
+    if (where.length) where.push('or')
     where.push('(', ...ctUtils.whereKey(key), ')')
   })
   return where
 }
 
 const _parentKey = (element, key) => {
-  const parentKey = {}
+  return [...element.customBackLinks, ...element.backLinks].reduce((parentKey, customBackLink) => {
+    // TODO: why Object.prototype.hasOwnProperty?
+    parentKey[customBackLink.entityKey] = Object.prototype.hasOwnProperty.call(key, customBackLink.targetKey)
+      ? key[customBackLink.targetKey]
+      : customBackLink.targetVal
 
-  element.customBackLinks.reduce((parentKey, customBackLink) => {
-    parentKey[customBackLink.entityKey] = key[customBackLink.targetKey] || customBackLink.targetVal
-    return parentKey
-  }, parentKey)
+    // nested
+    if (!parentKey[customBackLink.entityKey]) {
+      const splitted = customBackLink.targetKey.split('_')
+      let current
+      let joined = ''
+      while (splitted.length > 1) {
+        if (joined) joined += '_'
+        joined += splitted.shift()
+        if (Object.prototype.hasOwnProperty.call(key, joined)) current = key[joined]
+      }
+      if (current) parentKey[customBackLink.entityKey] = current[splitted[0]]
+    }
 
-  return element.backLinks.reduce((parentKey, backlink) => {
-    parentKey[backlink.entityKey] = key[backlink.targetKey] || backlink.targetVal
     return parentKey
-  }, parentKey)
+  }, {})
 }
 
 const _findWhere = (data, where) => {
@@ -98,9 +100,7 @@ const _keys = (entity, data) => {
 }
 
 const _parentKeys = (element, keys) => {
-  return keys.map(key => {
-    return _parentKey(element, key)
-  })
+  return keys.map(key => _parentKey(element, key)).filter(ele => Object.keys(ele).length)
 }
 
 const _subData = (data, prop) =>
@@ -113,8 +113,9 @@ const _subData = (data, prop) =>
     return result
   }, [])
 
-const _subWhere = (result, links) => {
+const _subWhere = (result, element) => {
   let where
+  const links = [...element.backLinks, ...element.customBackLinks]
   if (links && links.length > 0) {
     where = []
     for (const row of result) {
@@ -122,10 +123,12 @@ const _subWhere = (result, links) => {
         where.push('or')
       }
       const whereObj = links.reduce((res, currentLink) => {
-        res[currentLink.targetKey] = row[currentLink.entityKey]
+        if (Object.prototype.hasOwnProperty.call(row, currentLink.targetKey))
+          res[currentLink.entityKey] = row[currentLink.targetKey]
         return res
       }, {})
-      where.push('(', ...ctUtils.whereKey(whereObj), ')')
+      const whereCQN = ctUtils.whereKey(whereObj)
+      if (whereCQN.length) where.push('(', ...whereCQN, ')')
     }
   }
   return where
@@ -143,17 +146,7 @@ const _mergeResults = (result, selectData, root, definitions, compositionTree, e
       } else if (assoc.is2many) {
         selectEntry[compositionTree.name] = selectEntry[compositionTree.name] || []
       }
-      let pk = _parentKey(compositionTree, selectEntry)
-      // adjust pk for nested composition of one
-      if (
-        (!pk || Object.keys(pk).length === 0) &&
-        assoc.isComposition &&
-        assoc.is2one &&
-        compositionTree.links.length === 1
-      ) {
-        pk = { [compositionTree.links[0].targetKey]: selectEntry[compositionTree.links[0].entityKey] }
-      }
-      const newData = _findWhere(result, pk)
+      const newData = _findWhere(result, _parentKey(compositionTree, selectEntry))
       if (assoc.is2one && newData[0]) {
         selectEntry[compositionTree.name] = Object.assign(selectEntry[compositionTree.name], newData[0])
       } else if (assoc.is2many) {
@@ -165,23 +158,20 @@ const _mergeResults = (result, selectData, root, definitions, compositionTree, e
 }
 
 const _columns = (entity, data, compositionTree, selectAll) => {
-  const links = _getLinksOfCompTree(compositionTree)
-  const backLinkKeys = [
-    ...compositionTree.backLinks.map(backLink => backLink.entityKey),
-    ...compositionTree.customBackLinks.map(customBackLink => customBackLink.entityKey)
-  ]
-  const columns = _dataElements(entity)
-    .filter(
-      element =>
-        selectAll ||
-        element.key ||
-        links.includes(element.name) ||
-        backLinkKeys.includes(element.name) ||
-        (Array.isArray(data) && data.find(entry => element.name in entry))
-    )
-    .map(element => {
-      return { ref: [element.name] }
-    })
+  const backLinkKeys = _getLinksOfCompTree(compositionTree)
+  const columns = []
+  for (const elementName in entity.elements) {
+    const element = entity.elements[elementName]
+    if (element.virtual || element.isAssociation) continue
+    if (
+      selectAll ||
+      element.key ||
+      backLinkKeys.includes(element.name) ||
+      (Array.isArray(data) && data.find(entry => element.name in entry))
+    ) {
+      columns.push({ ref: [element.name] })
+    }
+  }
   return columns
 }
 
@@ -230,12 +220,16 @@ const _selectDeepUpdateData = async args => {
         compositionTree: element,
         entityName: element.source,
         data: _subData(data, element.name),
-        where: _subWhere(result, element.links),
+        where: _subWhere(result, element),
         selectData: result,
         parentKeys: _parentKeys(element, keys),
         orderBy: false,
         root: false
       }
+
+      // REVISIT: remove null elements
+      subs.data = subs.data.filter(d => d)
+
       return _selectDeepUpdateData({ ...args, ...subs })
     })
   )
@@ -247,7 +241,14 @@ const _selectDeepUpdateData = async args => {
  * exports
  */
 
-const selectDeepUpdateData = (definitions, cqn, req, includeAllRootColumns = false) => {
+const selectDeepUpdateData = (
+  definitions,
+  cqn,
+  req,
+  includeAllRootColumns = false,
+  includeAllColumns = false,
+  service
+) => {
   // REVISIT this should be done somewhere before, so it is not done twice for deep updates
   const sqlQuery = cqn2cqn4sql(cqn, { definitions })
 
@@ -255,7 +256,7 @@ const selectDeepUpdateData = (definitions, cqn, req, includeAllRootColumns = fal
     return Promise.resolve(req._.partialPersistentState)
   }
 
-  const from = _from(sqlQuery)
+  const from = getEntityNameFromUpdateCQN(sqlQuery)
   const alias = sqlQuery.UPDATE.entity.as
   const where = sqlQuery.UPDATE.where || []
   const entityName = ensureNoDraftsSuffix(from)
@@ -266,7 +267,8 @@ const selectDeepUpdateData = (definitions, cqn, req, includeAllRootColumns = fal
     definitions,
     rootEntityName: entityName, // REVISIT: drafts are resolved too eagerly
     checkRoot: false,
-    resolveViews: !draft
+    resolveViews: !draft,
+    service
   })
 
   return _selectDeepUpdateData({
@@ -281,8 +283,9 @@ const selectDeepUpdateData = (definitions, cqn, req, includeAllRootColumns = fal
     includeAllRootColumns,
     singleton: req && req.target && req.target._isSingleton,
     alias,
-    includeAllColumns: cqn._selectAll,
-    root: true
+    includeAllColumns: cqn._selectAll || includeAllColumns,
+    root: true,
+    service
   })
 }