@sap/cds 8.5.1 → 8.6.1

package/libx/odata/utils/metadata.js

@@ -11,6 +11,8 @@ const _lastValidRef = ref => {
   }
 }
 
+const _toBinaryKeyValue = value => `binary'${value.toString('base64')}'`
+
 const _odataContext = (query, options) => {
   let path = '$metadata'
   if (query._target.kind === 'service') return path
@@ -36,113 +38,105 @@ const _odataContext = (query, options) => {
   else if (cds2edm[query._target.type]) edmName = cds2edm[query._target.type]
   else edmName = query._target.name
 
-  if (isCollection && query._target.kind === 'type') edmName = `Collection(${edmName})`
+  const isType = query._target.kind === 'type'
+  if (isCollection && isType) edmName = `Collection(${edmName})`
 
   const serviceName = query._target._service?.name
-  if (serviceName) edmName = edmName.replace(serviceName + '.', '').replace(/\./g, '_')
+  if (serviceName && !isType) edmName = edmName.replace(serviceName + '.', '').replace(/\./g, '_')
 
-  if (ref.length > 1) {
-    // prepend for relative path
-    path = '../'.repeat(ref.length - 1) + path
-  }
+  // prepend "../" parent segments for relative path
+  if (ref.length > 1) path = '../'.repeat(ref.length - 1) + path
 
   path += edmName
 
   const lastRef = ref.at(-1)
 
-  if (propertyAccess) {
-    path = '../' + path
+  if (propertyAccess || isNavToDraftAdmin) {
+    if (propertyAccess) path = '../' + path
+
+    const keyValuePairs = []
 
     const lastValidRef = _lastValidRef(ref)
+    const isSibling = lastRef === 'SiblingEntity'
+    let _keyValuePairs
     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(',') + ')'
+      _keyValuePairs = Object.entries(where2obj(lastValidRef.where))
     } 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 + ')'
+      _keyValuePairs = Object.entries(query._target.keys)
+        .filter(([, v]) => !v._isBacklink)
+        .map(([k]) => [k, result[k]])
     }
 
-    if (isNavToDraftAdmin) {
-      path += '/' + lastRef
+    if (Array.isArray(_keyValuePairs)) {
+      _keyValuePairs.forEach(([k, _v]) => {
+        const v = (() => {
+          if (k === 'IsActiveEntity' && isSibling) return !_v
+          if (Buffer.isBuffer(_v)) return _toBinaryKeyValue(_v)
+          return _v
+        })()
+        if (v !== undefined) keyValuePairs.push([k, v])
+      })
     }
 
-    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(',') + ')'
+    if (keyValuePairs.length) {
+      let keyString
+      // single keys just contain the value
+      if (keyValuePairs.length === 1) keyString = String(keyValuePairs[0][1])
+      // multiple keys should contain key value pairs
+      else keyString = keyValuePairs.map(([k, v]) => `${k}=${v}`).join(',')
+      path += '(' + keyString + ')'
     }
-    path += '/' + lastRef
+
+    if (isNavToDraftAdmin) path += '/' + lastRef
+    if (propertyAccess) path += '/' + propertyAccess
   }
 
   if (cds.env.odata.context_with_columns && query.SELECT && !isSingleton && !propertyAccess) {
-    const { columns } = query.SELECT
-    let containments = []
+    const _calculateStringFromColumn = column => {
+      if (column === '*') return
 
-    function processColumns(column) {
       const refName = column.ref?.[0]
-      if (!refName) return ''
 
       if (column.expand) {
         // Process nested expands recursively
-        const expandSelects = column.expand.map(exp => processColumns(exp)).filter(Boolean)
-        return `${refName}(${expandSelects.join(',')})`
-      } else if (column.xpr) {
-        // Handle xpr cases
-        const xprRefName = column.xpr.find(item => item.ref?.[0])?.ref?.[0]
-        return xprRefName || ''
-      } else if (refName !== '*') {
-        return refName
+        const expands = _calculateColumnsString(column.expand)
+        return `${refName}${expands ? expands : '()'}`
+      } else if (column.func) {
+        return column.as
       }
+
+      return refName
     }
 
-    columns.forEach(column => {
-      const result = processColumns(column)
-      if (result) {
-        containments.push(result)
-      }
-    })
-    if (containments.length) path += `(${containments.join(',')})`
-  }
+    const _calculateColumnsString = columns => {
+      const selects = []
+      const expands = []
+      columns.forEach(column => {
+        if (column.expand) expands.push(column)
+        else selects.push(column)
+      })
 
-  if ((!isCollection && !isSingleton && !propertyAccess) || (isNavToDraftAdmin && !propertyAccess)) {
-    path += '/$entity'
+      const columnStrings = []
+
+      // First process selects, then expands
+      selects.concat(expands).forEach(column => {
+        const stringFromColumn = _calculateStringFromColumn(column)
+        if (stringFromColumn) columnStrings.push(stringFromColumn)
+      })
+
+      if (columnStrings.length) return `(${columnStrings.join(',')})`
+    }
+
+    const columns = query.SELECT.columns || query.SELECT.from?.SELECT?.columns
+    if (columns) {
+      const columnsString = _calculateColumnsString(columns)
+      if (columnsString) path += columnsString
+    }
   }
 
+  if (!isCollection && !isSingleton && !propertyAccess && !isType) path += '/$entity'
+
   return path
 }
 

package/libx/odata/utils/postProcess.js

@@ -1,11 +1,14 @@
+const cds = require('../../../lib')
+
 const getTemplate = require('../../_runtime/common/utils/template')
 const { toBase64url } = require('../../_runtime/common/utils/binary')
 
 const _addEtags = (row, key) => {
   if (!row[key]) return
-  row.$etag = row[key].startsWith('W/') ? row[key] : `W/"${row[key]}"`
+  // if provided as js date, take the iso string
+  const value = row[key] instanceof Date ? row[key].toISOString() : row[key]
+  row.$etag = value.startsWith?.('W/') ? value : `W/"${value}"`
 }
-
 const _processorFn = elementInfo => {
   const { row, plain } = elementInfo
   if (typeof row !== 'object') return
@@ -29,7 +32,10 @@ const _processorFn = elementInfo => {
         }
         break
       case 'array':
-        row[key] ??= []
+        if (row[key] === null) row[key] = []
+        break
+      case '@cleanup':
+        if (key !== 'DraftAdministrativeData_DraftUUID') delete row[key]
         break
       // no default
     }
@@ -42,6 +48,21 @@ const _pick = element => {
   if (element['@cds.api.ignore'] && !element.isAssociation) categories.push('@cds.api.ignore')
   if (element._type === 'cds.Binary') categories.push('binary')
   if (element.items) categories.push('array')
+
+  // in case of containment managed composition (& assoc backlinks) keys are not exposed and have to be removed from the result
+  if (cds.env.effective.odata.containment) {
+    const _isContainedOrBackLink = element =>
+      element &&
+      element.isAssociation &&
+      element.keys &&
+      (element._isContained || (element._anchor && element._anchor._isContained))
+
+    const assocName = element._foreignKey4
+    const assoc = assocName && element.parent.elements[assocName]
+
+    if (_isContainedOrBackLink(assoc)) categories.push('@cleanup')
+  }
+
   if (categories.length) return { categories }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "8.5.1",
+  "version": "8.6.1",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [

package/server.js

@@ -46,7 +46,7 @@ module.exports = async function cds_server (options) {
   if (o.index)     app.get ('/',o.index)                //> if none in ./app
 
   // load and prepare models
-  const csn = await cds.load(o.from||'*',o) .then (cds.minify)
+  const csn = await cds.load(o.from||'*',o)
   cds.edmxs = cds.compile.to.edmx.files (csn)
   cds.model = cds.compile.for.nodejs (csn)
 

package/lib/ql/parse.js

@@ -1,36 +0,0 @@
-// please keep all comments!
-
-const cds = require('../index')
-module.exports = {
-  column:(x) => _simple(x) /* || _parse('column',x) */ || cds.parse.column(x),
-  expr:(x) => _simple(x) /* || _parse('expr',x) */ || cds.parse.expr(x),
-  CQL: (..._) => cds.parse.CQL (..._),
-  CXL: (..._) => cds.parse.CXL (..._),
-  cql: (..._) => cds.parse.cql (..._),
-  path: (..._) => cds.parse.path (..._),
-}
-
-const _simple = (x) => {
-  if (typeof x !== 'string') return {val:x}
-  const t = /^\s*([\w.'?]+)(?:\s*([!?\\/:=\-+<~>]+|like)\s*([\w.'?]+))?\s*$/.exec(x); if (!t) return
-  const [,lhs,op,rhs] = t
-  return op ? {xpr:[_rv(lhs),op,_rv(rhs)]} : _rv(lhs)
-}
-
-const _rv = (x) => {
-  if (x[0] === '?')  return { param: true, ref: x }
-  if (x[0] === "'")  return { val: x.slice(1,-1).replace(/''/g, "'") }
-  if (x === 'null')  return { val: null }
-  if (x === 'true')  return { val: true }
-  if (x === 'false') return { val: false }
-  if (!isNaN(x))     return { val: Number(x) }
-  else               return { ref: x.split('.') }
-}
-
-// const _parse = (startRule,x) => {
-//   try {
-//     return parser.parse(x,{startRule})
-//     // } catch (e) { e.message += ' in: \n' + x;  throw e }
-//   }  catch {/* ignored */}
-// }
-// const parser = require('./parser')