@sap/cds 7.9.2 → 8.0.3

package/libx/odata/utils/index.js

@@ -1,7 +1,6 @@
 // TODO: split into multiple files
 
 const cds = require('../../../')
-const _path = require('./path')
 const _etag = require('./etag')
 
 const { toBase64url } = require('../../_runtime/common/utils/binary')
@@ -227,7 +226,7 @@ const skipToken = (token, cqn) => {
     let decoded
     try {
       decoded = JSON.parse(Buffer.from(token, 'base64').toString())
-    } catch (err) {
+    } catch {
       LOG.warn('$skiptoken is not in expected format. Ignoring it.')
       return
     }
@@ -277,35 +276,103 @@ const skipToken = (token, cqn) => {
 }
 
 const calculateLocationHeader = (target, srv, result) => {
-  const targetName = target.name.replace(`${srv.name}.`, '')
-
-  const keyValuePairs = Object.keys(target.keys).reduce((acc, key) => {
+  const targetName = target.name.replace(`${srv.definition.name}.`, '')
+  const filteredKeys = target.keys.filter(k => !k.isAssociation).map(k => k.name)
+  const keyValuePairs = filteredKeys.reduce((acc, key) => {
     const value = result[key]
+    if (value === undefined) return
     if (Buffer.isBuffer(value)) {
       acc[key] = value.toString('base64')
     } else {
-      acc[key] = value
+      const _type = target.elements[key]._type
+      if (typeof value === 'string' && _type !== 'cds.UUID') acc[key] = `'${value}'`
+      else acc[key] = value
     }
     return acc
   }, {})
-
+  if (!keyValuePairs) return
   let keys
   const entries = Object.entries(keyValuePairs)
   if (entries.length === 1) {
     keys = entries[0][1]
+    if (target.elements[entries[0][0]]['@odata.Type'] === 'Edm.String') keys = `'${keys}'`
   } else {
-    keys = entries.map(([key, value]) => `${key}=${value}`).join(',')
+    keys = entries
+      .map(([key, value]) => `${key}=${target.elements[key]['@odata.Type'] === 'Edm.String' ? `'${value}'` : value}`)
+      .join(',')
   }
-
   return `${targetName}(${keys})`
 }
 
 const handleSapMessages = (cdsReq, req, res) => {
-  if (!cdsReq.messages || !cdsReq.messages.length) return
+  if (res.headersSent || !cdsReq.messages || !cdsReq.messages.length) return
   const msgs = getSapMessages(cdsReq.messages, req)
   if (msgs) res.setHeader('sap-messages', msgs)
 }
 
+const isStream = query => {
+  const { _propertyAccess, target } = query
+  if (!_propertyAccess) return
+
+  const element = target.elements[_propertyAccess]
+  return element._type === 'cds.LargeBinary' && element['@Core.MediaType']
+}
+
+const isRedirect = query => {
+  const { _propertyAccess, target } = query
+  if (!_propertyAccess) return
+
+  const element = target.elements[_propertyAccess]
+  return element._type === 'cds.String' && element['@Core.MediaType'] && element['@Core.IsURL']
+}
+
+const _addKeysDeep = (keys, keysCollector, ignoreManagedBackLinks) => {
+  for (const keyName in keys) {
+    const key = keys[keyName]
+    const foreignKey = key._foreignKey4
+    if (key.isAssociation || foreignKey === 'up_' || key['@cds.api.ignore'] === true) continue
+
+    if (ignoreManagedBackLinks && foreignKey) {
+      const navigationElement = keys[foreignKey]
+      if (!navigationElement.on && navigationElement._isBacklink) {
+        // skip navigation elements that are backlinks
+        continue
+      }
+    }
+
+    if ('elements' in key) {
+      _addKeysDeep(key.elements, keysCollector)
+      continue
+    }
+
+    keysCollector.push(keyName)
+  }
+}
+
+function keysOf(entity, ignoreManagedBackLinks) {
+  const keysCollector = []
+  if (!entity || !entity.keys) return keysCollector
+
+  _addKeysDeep(entity.keys, keysCollector, ignoreManagedBackLinks)
+  return keysCollector
+}
+
+// case: single key without name, e.g., Foo(1)
+function addRefToWhereIfNecessary(where, entity) {
+  if (!where || where.length !== 1) return 0
+
+  const isView = !!entity.params
+  const keys = isView ? Object.keys(entity.params) : keysOf(entity)
+
+  if (keys.length !== 1) return 0
+  where.unshift(...[{ ref: [keys[0]] }, '='])
+  return 1
+}
+
+function getBoundary(req) {
+  return req.headers['content-type']?.match(/boundary=([\d\w'()+_,\-./:=?]{1,70})/i)?.[1]
+}
+
 module.exports = {
   cds2edm,
   getSafeNumber,
@@ -313,7 +380,12 @@ module.exports = {
   skipToken,
   calculateLocationHeader,
   handleSapMessages,
-  getKeysAndParamsFromPath: _path.getKeysAndParamsFromPath,
   getPreferReturnHeader,
-  validateIfNoneMatch: _etag.validateIfNoneMatch
+  isStream,
+  isRedirect,
+  keysOf,
+  addRefToWhereIfNecessary,
+  validateIfNoneMatch: _etag.validateIfNoneMatch,
+  extractIfNoneMatch: _etag.extractIfNoneMatch,
+  getBoundary
 }

package/libx/odata/utils/metadata.js

@@ -0,0 +1,161 @@
+const { where2obj } = require('../../_runtime/common/utils/cqn')
+
+const _isNavToDraftAdmin = path => path.length > 1 && path[path.length - 1] === 'DraftAdministrativeData'
+
+const _lastValidRef = ref => {
+  for (let i = ref.length - 1; i >= 0; i--) {
+    if (ref[i] in { DraftAdministrativeData: 1, SiblingEntity: 1 }) continue
+    return ref[i]
+  }
+}
+
+const _odataContext = (query, options) => {
+  const { result, isCollection, edmName } = options
+
+  let path = '$metadata'
+  if (query._target.kind === 'service') {
+    return path
+  }
+
+  const {
+    _target: { _isSingleton: isSingleton },
+    _propertyAccess: propertyAccess
+  } = query
+
+  path += '#'
+
+  // REVISIT: subselect is treated as empty array
+  const ref =
+    query.SELECT?.from?.ref ?? query.UPDATE?.entity?.ref ?? query.INSERT?.into?.ref ?? query.DELETE?.from?.ref ?? []
+
+  const isNavToDraftAdmin = _isNavToDraftAdmin(ref)
+
+  if (ref.length > 1) {
+    // prepend for relative path
+    path = '../'.repeat(ref.length - 1) + path
+  }
+  const lastRef = ref.at(-1)
+  let entityName = isNavToDraftAdmin ? ref[0].id ?? ref[0] : query._target.name ?? edmName
+  const serviceName = query._target._service?.name
+
+  if (query._target._isContained) {
+    let cur = query._target
+    let refIndex = ref.length - 1
+
+    entityName = lastRef.id ?? lastRef
+
+    while (cur._isContained) {
+      cur = cur.elements.up_._target
+      refIndex--
+      const curName = ref[refIndex].id ?? ref[refIndex]
+      const where = ref[refIndex].where
+
+      if (where) {
+        let keys
+        if (where.length > 3) {
+          // multiple keys should contain key name
+          const _keys = where2obj(where)
+          keys = Object.keys(_keys).map(k => {
+            return k + '=' + _keys[k]
+          })
+        } else {
+          // single keys can just contain value
+          keys = [where.at(-1).val]
+        }
+        entityName = curName + '(' + keys.join(',') + ')' + '/' + entityName
+      } else {
+        // REVISIT: is this correct?
+        entityName = curName + '/' + entityName
+      }
+    }
+  }
+
+  if (serviceName) {
+    entityName = entityName.replace(serviceName + '.', '').replace(/\./g, '_')
+  }
+
+  path += entityName
+
+  if (propertyAccess) {
+    path = '../' + path
+
+    const lastValidRef = _lastValidRef(ref)
+    if (lastValidRef.where) {
+      let keys
+      const isSibling = lastRef === 'SiblingEntity'
+      if (lastValidRef.where.length > 3) {
+        // multiple keys should contain key name
+        const _keys = where2obj(lastValidRef.where)
+        keys = Object.keys(_keys).map(k => {
+          if (k === 'IsActiveEntity' && isSibling) return k + '=' + !_keys[k]
+          return k + '=' + _keys[k]
+        })
+      } else {
+        // single keys can just contain value
+        keys = [lastValidRef.where.at(-1).val]
+      }
+
+      path += '(' + keys.join(',') + ')'
+    } else if (!isSingleton) {
+      // use keys from result if not in query
+      const _keys = Object.keys(query._target.keys)
+      let keyString
+      if (_keys.length === 1) {
+        keyString = result[_keys[0]]
+      } else {
+        keyString = _keys.map(k => k.name + '=' + result[k.name]).join(',')
+      }
+      path += '(' + keyString + ')'
+    }
+
+    if (isNavToDraftAdmin) {
+      path += '/' + lastRef
+    }
+
+    path += '/' + propertyAccess
+  } else if (isNavToDraftAdmin) {
+    const lastValidRef = _lastValidRef(ref)
+    if (lastValidRef.where) {
+      let keys
+      const isSibling = lastRef === 'SiblingEntity'
+      if (lastValidRef.where.length > 3) {
+        // multiple keys should contain key name
+        const _keys = where2obj(lastValidRef.where)
+        keys = Object.keys(_keys).map(k => {
+          if (k === 'IsActiveEntity' && isSibling) return k + '=' + !_keys[k]
+          return k + '=' + _keys[k]
+        })
+      } else {
+        // single keys can just contain value
+        keys = [lastValidRef.where.at(-1).val]
+      }
+
+      path += '(' + keys.join(',') + ')'
+    }
+    path += '/' + lastRef
+  }
+
+  if ((!isCollection && !isSingleton && !propertyAccess) || (isNavToDraftAdmin && !propertyAccess)) {
+    path += '/$entity'
+  }
+
+  return path
+}
+
+/**
+ * TODO
+ *
+ * @param {*} query
+ * @param {*} [options]
+ * @param {*} [options.result]
+ * @param {*} [options.isCollection]
+ * @param {*} [options.edmName]
+ * @returns
+ */
+module.exports = function getODataMetadata(query, options = {}) {
+  if (!query._target) return
+
+  const context = _odataContext(query, options)
+
+  return { context }
+}

package/libx/odata/utils/postProcess.js

@@ -0,0 +1,89 @@
+const cds = require('../../_runtime/cds')
+
+const getTemplate = require('../../_runtime/common/utils/template')
+const templateProcessor = require('../../_runtime/common/utils/templateProcessor')
+
+const _getParent = (model, name) => {
+  const target = model.definitions[name]
+
+  if (target && target.elements) {
+    for (const elementName in target.elements) {
+      const element = target.elements[elementName]
+      if (element._anchor && element._anchor._isContained) return element._anchor
+    }
+  }
+
+  return null
+}
+
+const _addEtags = (row, key) => {
+  if (!row[key]) return
+  row.$etag = row[key].startsWith('W/') ? row[key] : `W/"${row[key]}"`
+}
+
+const _processorFn = () => elementInfo => {
+  const { row, plain } = elementInfo
+  if (typeof row !== 'object') return
+  for (const category of plain.categories) {
+    const { row, key } = elementInfo
+    switch (category) {
+      case '@odata.etag':
+        _addEtags(row, key)
+        break
+      case '@cds.api.ignore':
+        delete row[key]
+        break
+      case 'binary':
+        if (Buffer.isBuffer(row[key])) {
+          // if the result object gets serialize to json, the buffer shall become a base64 string
+          row[key].toJSON = function () {
+            return this.toString('base64')
+          }
+        }
+        break
+      case 'array':
+        row[key] ??= []
+        break
+      // no default
+    }
+  }
+}
+
+const _pick = element => {
+  const categories = []
+  if (element['@odata.etag']) categories.push('@odata.etag')
+  if (element['@cds.api.ignore']) categories.push('@cds.api.ignore')
+  if (element._type === 'cds.Binary') categories.push('binary')
+  if (element.items) categories.push('array')
+  if (categories.length) return { categories }
+}
+
+module.exports = function postProcess(target, service, result, isMinimal) {
+  if (!result) return
+
+  let { model } = service
+  if (service.isExtensible) model = cds.context?.model || model
+
+  if (!model.definitions[target.name]) {
+    if (model.definitions[target.items?.type]) target = target.items
+    else return
+  }
+
+  const cacheKey = isMinimal ? 'postProcessMinimal' : 'postProcess'
+  const parent = _getParent(model, target.name)
+  const options = { pick: _pick, ignore: isMinimal ? el => el.isAssociation : undefined }
+  const template = getTemplate(cacheKey, service, target, options, parent)
+
+  if (template.elements.size === 0) return
+
+  // normalize result to rows
+  result = result.value != null && Object.keys(result).filter(k => !k.match(/^\W/)).length === 1 ? result.value : result
+
+  if (typeof result === 'object' && result != null) {
+    const rows = Array.isArray(result) ? result : [result]
+
+    // process each row
+    const processFn = _processorFn()
+    for (const row of rows) templateProcessor({ processFn, row, template })
+  }
+}

package/libx/odata/utils/readAfterWrite.js

@@ -1,23 +1,140 @@
 const cds = require('../../_runtime/cds')
-const { Request } = cds
-
-const readAfterWrite = async (req, srv, query) => {
-  // gracefully set location and no body if no read auth or not readable capability
-  let result
-  try {
-    const _req = new Request({ query, event: 'READ', _: req._, params: req.params })
-    result = await srv.dispatch(_req)
-    // NEW/PATCH must not include DraftAdministrativeData_DraftUUID for plain v4 usage, however required for odata-v2
-    if (result && req.target._isDraftEnabled && req.headers?.['x-cds-odata-version'] !== 'v2') {
-      delete result.DraftAdministrativeData_DraftUUID
+const { SELECT } = cds.ql
+
+const { DRAFT_COLUMNS_MAP } = require('../../_runtime/common/constants/draft')
+
+const _keysOf = (row, target) => {
+  const keyElements = Object.values(target.keys || {}).filter(v => !v.virtual)
+  // > singleton
+  if (!keyElements.length) return
+  const keys = {}
+  for (const key of keyElements) {
+    if (key._isAssociationStrict) continue
+    if (row[key.name] === undefined) continue // key is not in data, so ignore it
+    keys[key.name] = key.elements ? { val: JSON.stringify(row[key.name]) } : row[key.name]
+  }
+  return keys
+}
+
+const _getSimpleSelectCQN = (target, data, subject) => {
+  let cqn
+
+  const keys = _keysOf(data, target)
+  if (subject?.ref.length > 1) {
+    cqn = SELECT.one(subject)
+    if (keys) cqn.where(keys)
+  } else if (!keys) {
+    //> singleton
+    cqn = SELECT.one(target)
+  } else {
+    cqn = SELECT.one(target, keys)
+  }
+
+  if (target.query && target.query.SELECT && target.query.SELECT.orderBy) {
+    cqn.SELECT.orderBy = target.query.SELECT.orderBy
+  }
+
+  return cqn
+}
+
+const _mergeExpandCQNs = cqns => {
+  const cols = cqns[0].SELECT.columns
+  for (const cqn of cqns.slice(1)) {
+    for (const col of cqn.SELECT.columns) {
+      if (!col.expand) continue
+      const idx = cols.findIndex(ele => {
+        if (!col.ref) return
+        if (ele.ref) return ele.ref[0] === col.ref[0]
+        if (ele.as) return ele.as === col.ref[0]
+      })
+      if (idx === -1) {
+        cols.push(col)
+      } else {
+        const colExists = cols[idx]
+        if (colExists.as && colExists.val === null) {
+          cols[idx] = col
+          continue
+        }
+        if (col.as && col.val === null) continue
+        const mergedExpandCQN = _mergeExpandCQNs([
+          { SELECT: { columns: colExists.expand } },
+          { SELECT: { columns: col.expand } }
+        ])
+        colExists.expand = mergedExpandCQN.SELECT.columns
+      }
     }
-  } catch (e) {
-    // read was not possible because of access restrictions => ignore
-    if (!(Number(e.code) in { 401: 1, 403: 1, 404: 1, 405: 1 })) throw e
-    result = null
   }
+  return cqns[0]
+}
 
-  return result
+const _getExpandColumn = (data, element) => {
+  const key = element.name
+  if (!(key in data)) return
+  data = data[key]
+  if ((Array.isArray(data) && data.length === 0) || data == null) {
+    // performance tweak, keep in mind it is only for compositions
+    return { val: null, as: key }
+  }
+  const cqn = Array.isArray(data)
+    ? _mergeExpandCQNs(data.map(data => _getSelect({ target: element._target, data }, true)))
+    : _getSelect({ target: element._target, data }, true)
+  return { ref: [key], expand: cqn.SELECT.columns }
 }
 
-module.exports = readAfterWrite
+const _getColumns = (target, data, prefix = []) => {
+  const columns = []
+  for (const each in target.elements) {
+    if (target.elements[each]['@cds.api.ignore']) continue
+    if (each in DRAFT_COLUMNS_MAP) continue
+    if (!cds.env.features.stream_compat && target.elements[each].type === 'cds.LargeBinary') continue
+    const element = target.elements[each]
+    if (element.elements && data[each]) {
+      prefix.push(element.name)
+      columns.push(..._getColumns(element, data[each], prefix))
+      prefix.pop()
+    } else if (element.isComposition && !prefix.length) {
+      const col = _getExpandColumn(data, element, prefix)
+      if (col) columns.push(col)
+    } else if (!element.isAssociation) {
+      columns.push({ ref: [...prefix, each] })
+    }
+  }
+  return columns
+}
+
+/*
+ * recursively builds a select cqn (depth determined by req.data)
+ */
+const _getSelect = (cdsReq, deep = false) => {
+  const { target, data, subject } = cdsReq
+  const cqn = _getSimpleSelectCQN(target, data, subject)
+  if (deep) cqn.columns(..._getColumns(target, data))
+  return cqn
+}
+
+module.exports = (adapter, middleware) => {
+  const { service } = adapter
+
+  const _getQuery =
+    middleware === 'create'
+      ? cdsReq => _getSelect(cdsReq, cdsReq.event === 'CREATE')
+      : cdsReq => SELECT.one(cdsReq.subject)
+
+  return async function readAfterWrite(cdsReq) {
+    try {
+      const query = _getQuery(cdsReq)
+      const result = await service.dispatch(adapter.request4({ query, params: cdsReq.params }))
+
+      // REVISIT: really needed? -> disable and run odata v2 tests
+      // NEW/PATCH must not include DraftAdministrativeData_DraftUUID for plain v4 usage, however required for odata-v2
+      if (result && cdsReq.target._isDraftEnabled && cdsReq.headers?.['x-cds-odata-version'] !== 'v2') {
+        delete result.DraftAdministrativeData_DraftUUID
+      }
+
+      return result
+    } catch (e) {
+      // if read was not possible because of access restrictions then ignore else throw
+      if (!(Number(e.code) in { 401: 1, 403: 1, 404: 1, 405: 1 })) throw e
+    }
+  }
+}