@sap/cds 5.7.5 → 5.8.2

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

@@ -5,6 +5,9 @@ const { SELECT } = cds.ql
 
 const { targetFromPath, isPathToDraft } = require('../../../../common/utils/cqn')
 const { deepCopyArray } = require('../../../../common/utils/copy')
+const { cqn2cqn4sql } = require('../../../../common/utils/cqn2cqn4sql')
+const { ensureDraftsSuffix } = require('../../../../fiori/utils/handler')
+const { removeIsActiveEntityRecursively, isActiveEntityRequested } = require('../../../../fiori/utils/where')
 
 const isStreaming = segments => {
   const lastSegment = segments[segments.length - 1]
@@ -15,10 +18,38 @@ const isStreaming = segments => {
   )
 }
 
+const _adaptSubSelectsDraft = select => {
+  if (select.SELECT.from.ref) {
+    const index = select.SELECT.from.ref.length - 1
+    select.SELECT.from.ref[index] = ensureDraftsSuffix(select.SELECT.from.ref[index])
+  }
+
+  if (select.SELECT.where) {
+    for (let i = 0; i < select.SELECT.where.length; i++) {
+      const element = select.SELECT.where[i]
+      if (element.SELECT) {
+        _adaptSubSelectsDraft(element)
+      } else if (element.xpr) {
+        for (const ele of element.xpr.filter(e => e.SELECT)) {
+          _adaptSubSelectsDraft(ele)
+        }
+      }
+    }
+  }
+}
+
+const adaptStreamCQN = (cqn, isDraft = false) => {
+  if (isDraft || !isActiveEntityRequested(cqn.SELECT.where)) {
+    _adaptSubSelectsDraft(cqn)
+  } else {
+    cqn.SELECT.where = removeIsActiveEntityRecursively(cqn.SELECT.where)
+  }
+}
+
 const getStreamProperties = (req, model) => {
   const mediaTypeProperty = Object.values(req.target.elements).find(val => val['@Core.MediaType'])
 
-  let contentType, contentDisposition
+  let contentType, contentDispositionFilename
   const columns = []
   if (typeof mediaTypeProperty['@Core.MediaType'] === 'object') {
     let contentTypeProperty = mediaTypeProperty['@Core.MediaType']['=']
@@ -46,36 +77,42 @@ const getStreamProperties = (req, model) => {
             `@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' })
+        columns.push({ ref: [contentDispositionProperty], as: 'contentDispositionFilename' })
       }
     } else {
-      contentDisposition = mediaTypeProperty['@Core.ContentDisposition.Filename']
+      contentDispositionFilename = mediaTypeProperty['@Core.ContentDisposition.Filename']
     }
   }
+  const contentDispositionType = mediaTypeProperty['@Core.ContentDisposition.Type']
 
   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)
-
-    if (req.target._isDraftEnabled && isPathToDraft(select.SELECT.from.ref, model))
-      select.SELECT.from.ref[0].id = select.SELECT.from.ref[0].id + '_drafts'
+    let select = SELECT.one.from({ ref: deepCopyArray(req.query.SELECT.from.ref) }).columns(columns)
 
     // 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 pathToDraft = isPathToDraft(select.SELECT.from.ref, model)
+    if (req.target._isDraftEnabled && pathToDraft) {
+      select = cqn2cqn4sql(select, model)
+      adaptStreamCQN(select, pathToDraft)
+    }
+
     return cds
       .tx(req)
       .run(select)
       .then(res => ({
         contentType: (res && res.contentType) || contentType,
-        contentDisposition: (res && res.contentDisposition) || contentDisposition
+        contentDispositionFilename: (res && res.contentDispositionFilename) || contentDispositionFilename,
+        contentDispositionType
       }))
   }
 
-  return Promise.resolve({ contentType, contentDisposition })
+  return Promise.resolve({ contentType, contentDispositionFilename, contentDispositionType })
 }
 
 module.exports = {
   isStreaming,
-  getStreamProperties
+  getStreamProperties,
+  adaptStreamCQN
 }

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

@@ -12,9 +12,10 @@ const { contentTypeCheck } = require('./utils/header-checks')
 const parse = require('./utils/parse-url')
 const { base64toBuffer } = require('./utils/binary')
 
-const { UNAUTHORIZED, FORBIDDEN, getRequiresAsArray } = require('../../../common/utils/auth')
+const { UNAUTHORIZED, FORBIDDEN, getRequiresAsArray } = require('../../../auth/utils')
 
 const PPP = { POST: 1, PUT: 1, PATCH: 1 }
+const GH = { GET: 1, HEAD: 1 }
 
 let _i18n
 const i18n = (...args) => {
@@ -93,6 +94,21 @@ class Rest {
         throw FORBIDDEN
       }
 
+      // service root
+      if (req.path === '/' && GH[req.method]) {
+        if (req.method === 'HEAD') return res.json({})
+        else
+          return res.json(
+            Object.keys(srv.entities).reduce(
+              (acc, cur) => {
+                acc.entities.push({ name: cur, url: cur })
+                return acc
+              },
+              { entities: [] }
+            )
+          )
+      }
+
       // content-type check, parse url, and base64 to buffer
       try {
         if (PPP[req.method]) contentTypeCheck(req)
@@ -115,6 +131,11 @@ class Rest {
       }
     })
 
+    // HEAD
+    this.router.head('/*', (req, res, next) => {
+      read(req, res, next)
+    })
+
     // GET
     this.router.get('/*', (req, res, next) => {
       // READ or custom operation?

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

@@ -28,9 +28,7 @@ module.exports = service => {
 
       result = await tx.dispatch(req)
 
-      if (result == null) {
-        throw getError(404, 'NO_MATCHING_RESOURCE')
-      }
+      if (result == null) throw getError(404, 'NO_MATCHING_RESOURCE')
 
       bufferToBase64(result, segments[0])
 
@@ -41,6 +39,13 @@ module.exports = service => {
       await tx.rollback(e).catch(() => {})
     } finally {
       if (err) next(err)
+      else if (restReq.method === 'HEAD')
+        restRes
+          .set({
+            'content-type': 'application/json; charset=utf-8',
+            'content-length': JSON.stringify(result).length
+          })
+          .end()
       else restRes.send(toRestResult(result))
     }
   }

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

@@ -230,6 +230,9 @@ module.exports = {
   POST: (service, req) => {
     return parseCreateOrReadUrl('CREATE', service, req)
   },
+  HEAD: (service, req) => {
+    return parseCreateOrReadUrl('READ', service, req)
+  },
   GET: (service, req) => {
     return parseCreateOrReadUrl('READ', service, req)
   },

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

@@ -17,7 +17,10 @@ const { DRAFT_COLUMNS_UNION } = require('../../../common/constants/draft')
  * @param [options.filterVirtual=false]
  * @returns {Array<object>} - array of columns
  */
-const getColumns = (entity, { onlyNames = false, removeIgnore = false, filterDraft = true, filterVirtual = false }) => {
+const getColumns = (
+  entity,
+  { onlyNames = false, removeIgnore = false, filterDraft = true, filterVirtual = false, keysOnly = false }
+) => {
   const skipDraft = filterDraft && entity._isDraftEnabled
   const columns = []
   const elements = entity.elements
@@ -28,6 +31,7 @@ const getColumns = (entity, { onlyNames = false, removeIgnore = false, filterDra
     if (filterVirtual && element.virtual) continue
     if (removeIgnore && element['@cds.api.ignore']) continue
     if (skipDraft && DRAFT_COLUMNS_UNION.includes(each)) continue
+    if (keysOnly && !element.key) continue
     columns.push(onlyNames ? each : element)
   }
 

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

@@ -285,30 +285,29 @@ const _mergeArrays = (entity, oldValue, newValue) => {
   return merged
 }
 
-const mergeJsonDeep = (entity, oldValue, newValue) => {
+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)) {
-    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
+    // 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) {
-            oldValue[key] = _mergeArrays(target, oldValue[key], newValue[key])
+            newValue[key] = _mergeArrays(target, oldValue[key], newValue[key])
           }
           // Can't merge items without target
         }
-      } else {
-        Object.assign(oldValue, { [key]: newValue[key] })
       }
     })
   }
-  return oldValue
+  return newValue
 }
 
 // Signature similar to Object.assign(oldValue, newValue)

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

@@ -45,14 +45,8 @@ module.exports = class {
   }
 
   async _addPartialPersistentState(req) {
-    const deepUpdateData = await selectDeepUpdateData(
-      this._srv.model.definitions,
-      req.query,
-      req,
-      true,
-      true,
-      this._srv
-    )
+    // REVISIT: cds.context.model?
+    const deepUpdateData = await selectDeepUpdateData(this._srv, this._srv.model, req, true)
     req._.partialPersistentState = deepUpdateData
   }
 

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

@@ -1,11 +1,24 @@
 // global.cds is used on purpose here!
 const cds = global.cds
 
+// requesting logger without module on purpose!
+const LOG = cds.log()
+
 const ODATA_CONTAINED = '@odata.contained'
 
 const { isSelfManaged, isBacklink, getAnchor, getBacklink } = require('./utils')
 const { foreignKeyPropagations } = require('../utils/foreignKeyPropagations')
 
+const _logDeprecationForODataContained = () => {
+  if (!cds._deprecationWarningForODataContained) {
+    LOG._warn &&
+      LOG.warn(
+        'Annotation "@odata.contained" is deprecated and will be removed in an upcoming release. Use compositions instead of associations.'
+      )
+    cds._deprecationWarningForODataContained = true
+  }
+}
+
 module.exports = class {
   get _isAssociationStrict() {
     return (
@@ -15,6 +28,7 @@ module.exports = class {
   }
 
   get _isAssociationEffective() {
+    this[ODATA_CONTAINED] && _logDeprecationForODataContained()
     return (
       this.own('__isAssociationEffective') ||
       this.set(
@@ -25,6 +39,7 @@ module.exports = class {
   }
 
   get _isCompositionEffective() {
+    this[ODATA_CONTAINED] && _logDeprecationForODataContained()
     return (
       this.own('__isCompositionEffective') ||
       this.set(
@@ -36,6 +51,7 @@ module.exports = class {
   }
 
   get _isContained() {
+    this[ODATA_CONTAINED] && _logDeprecationForODataContained()
     return (
       this.own('__isContained') ||
       this.set(

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

@@ -120,26 +120,26 @@ const _subWhere = (result, element) => {
   if (links && links.length > 0) {
     where = []
     for (const row of result) {
-      if (where.length > 0) {
-        where.push('or')
-      }
       const whereObj = links.reduce((res, currentLink) => {
-        if (Object.prototype.hasOwnProperty.call(row, currentLink.targetKey))
+        if (Object.prototype.hasOwnProperty.call(row, currentLink.targetKey) && row[currentLink.targetKey] !== null)
           res[currentLink.entityKey] = row[currentLink.targetKey]
         return res
       }, {})
       const whereCQN = ctUtils.whereKey(whereObj)
-      if (whereCQN.length) where.push('(', ...whereCQN, ')')
+      if (whereCQN.length) {
+        if (where.length > 0) where.push('or')
+        where.push('(', ...whereCQN, ')')
+      }
     }
   }
   return where
 }
 
-const _mergeResults = (result, selectData, root, definitions, compositionTree, entityName) => {
+const _mergeResults = (result, selectData, root, model, compositionTree, entityName) => {
   if (root) {
     return [...selectData, ...result]
   } else {
-    const parent = definitions[compositionTree.target] || definitions[entityName]
+    const parent = model.definitions[compositionTree.target] || model.definitions[entityName]
     const assoc = (parent && parent.elements[compositionTree.name]) || {}
     return selectData.map(selectEntry => {
       if (assoc.is2one) {
@@ -148,8 +148,9 @@ const _mergeResults = (result, selectData, root, definitions, compositionTree, e
         selectEntry[compositionTree.name] = selectEntry[compositionTree.name] || []
       }
       const newData = _findWhere(result, _parentKey(compositionTree, selectEntry))
-      if (assoc.is2one && newData[0]) {
-        selectEntry[compositionTree.name] = Object.assign(selectEntry[compositionTree.name], newData[0])
+      if (assoc.is2one) {
+        if (newData[0]) selectEntry[compositionTree.name] = Object.assign(selectEntry[compositionTree.name], newData[0])
+        else selectEntry[compositionTree.name] = null
       } else if (assoc.is2many) {
         selectEntry[compositionTree.name].push(...newData)
       }
@@ -158,14 +159,14 @@ const _mergeResults = (result, selectData, root, definitions, compositionTree, e
   }
 }
 
-const _columns = (entity, data, compositionTree, selectAll) => {
+const _columns = (entity, data, compositionTree, selectAllColumns) => {
   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 ||
+      selectAllColumns ||
       element.key ||
       backLinkKeys.includes(element.name) ||
       (Array.isArray(data) && data.find(entry => element.name in entry))
@@ -177,45 +178,42 @@ const _columns = (entity, data, compositionTree, selectAll) => {
 }
 
 const _select = ({
-  definitions,
+  model,
   entityName,
   draft,
   alias,
   compositionTree,
   data,
-  root,
-  includeAllRootColumns,
-  includeAllColumns,
+  selectAllColumns,
   where,
   parentKeys,
   orderBy,
   singleton
 }) => {
-  const entity = definitions && definitions[entityName]
+  const entity = model.definitions[entityName]
   const from = ctUtils.addDraftSuffix(draft, entity.name)
   const selectCQN = SELECT.from(from)
   if (alias) selectCQN.SELECT.from.as = alias
-  const selectAll = includeAllColumns || (includeAllRootColumns && root)
-  selectCQN.SELECT.columns = _columns(entity, data, compositionTree, selectAll)
+  selectCQN.SELECT.columns = _columns(entity, data, compositionTree, selectAllColumns)
   if (where) selectCQN.SELECT.where = where
   else if (parentKeys) selectCQN.SELECT.where = _whereKeys(parentKeys)
   if (orderBy) selectCQN.SELECT.orderBy = orderBy
   if (singleton) selectCQN.SELECT.limit = { rows: { val: 1 } }
   // REVISIT: remove once SELECT builder does flattening!
-  return cqn2cqn4sql(selectCQN, { definitions })
+  return cqn2cqn4sql(selectCQN, model)
 }
 
 const _selectDeepUpdateData = async args => {
-  const { definitions, compositionTree, entityName, data, includeAllColumns, root, selectData, tx } = args
+  const { model, compositionTree, entityName, data, root, selectData, tx, selectAllColumns } = args
   const selectCQN = _select(args)
   const result = await tx.run(selectCQN)
   if (!result.length) return Promise.resolve(result)
 
-  const keys = _keys(definitions[entityName], result)
+  const keys = _keys(model.definitions[entityName], result)
   await Promise.all(
     compositionTree.compositionElements.map(element => {
       if (element.skipPersistence) return Promise.resolve()
-      if (data !== undefined && !data.find(entry => element.name in entry) && !(includeAllColumns && result.length))
+      if (data !== undefined && !data.find(entry => element.name in entry) && !(selectAllColumns && result.length))
         return Promise.resolve()
       const subs = {
         compositionTree: element,
@@ -235,23 +233,17 @@ const _selectDeepUpdateData = async args => {
     })
   )
 
-  return _mergeResults(result, selectData || [], root, definitions, compositionTree, entityName)
+  return _mergeResults(result, selectData || [], root, model, compositionTree, entityName)
 }
 
 /*
  * exports
  */
 
-const selectDeepUpdateData = (
-  definitions,
-  cqn,
-  req,
-  includeAllRootColumns = false,
-  includeAllColumns = false,
-  service
-) => {
+const selectDeepUpdateData = (service, model, req, selectAllColumns = false) => {
+  const query = req.query
   // REVISIT this should be done somewhere before, so it is not done twice for deep updates
-  const sqlQuery = cqn2cqn4sql(cqn, { definitions })
+  const sqlQuery = cqn2cqn4sql(query, model)
 
   if (req && _isSameEntity(sqlQuery, req)) {
     return Promise.resolve(req._.partialPersistentState)
@@ -263,9 +255,9 @@ const selectDeepUpdateData = (
   const entityName = ensureNoDraftsSuffix(from)
   const draft = entityName !== from
   const orderBy = req && req.target && req.target.query && req.target.query.SELECT && req.target.query.SELECT.orderBy
-  const data = Object.assign({}, sqlQuery.UPDATE.data || {}, cqn.UPDATE.with || {})
+  const data = Object.assign({}, sqlQuery.UPDATE.data || {}, query.UPDATE.with || {})
   const compositionTree = getCompositionTree({
-    definitions,
+    definitions: model.definitions,
     rootEntityName: entityName, // REVISIT: drafts are resolved too eagerly
     checkRoot: false,
     resolveViews: !draft,
@@ -274,17 +266,16 @@ const selectDeepUpdateData = (
 
   return _selectDeepUpdateData({
     tx: cds.tx(req),
-    definitions,
+    model,
     compositionTree,
     entityName,
     data: [data],
     where,
     orderBy,
     draft,
-    includeAllRootColumns,
     singleton: req && req.target && req.target._isSingleton,
     alias,
-    includeAllColumns: cqn._selectAll || includeAllColumns,
+    selectAllColumns,
     root: true,
     service
   })