@sap/cds 5.9.8 → 6.0.1

package/libx/_runtime/types/api.js

@@ -3,6 +3,7 @@
 /**
  * @typedef {object} ColumnRef
  * @property {Array<string>} ref
+ * @property {function} func
  */
 
 /**
@@ -17,7 +18,7 @@
  * @property {*} value
  * @property {Array} errors
  * @property {string} [key]
- * @property {string[]} [pathSegments]
+ * @property {pathSegment[]} [pathSegments]
  * @property {string} event
  */
 
@@ -49,7 +50,7 @@
  * @typedef {object} TemplateProcessorPathOptions
  * @property {object} [extraKeys]
  * @property {function} [rowKeysGenerator]
- * @property {pathSegment[]} [path=[]] - Path segments to relate the error message.
+ * @property {string[]} [segments=[]] - Path segments to relate the error message.
  * @property {boolean} [includeKeyValues=false] Indicates whether the key values are included in the path segments
  * The path segments are used to build the error target (a relative resource path)
  */
@@ -64,20 +65,14 @@
  */
 
 /**
- * @typedef {object} templateProcessorProcessFnArgs
+ * @typedef {object} templateElementInfo
  * @property {object} row
  * @property {string} key
  * @property {object} element
  * @property {boolean} plain
+ * @property {entity} target
  * @property {boolean} isRoot
- * @property {Array<pathSegment>} [path]
- */
-
-/**
- * @typedef {object} pathSegment
- * @property {string} key
- * @property {number} idx
- * @property {string} url
+ * @property {Array<String>} [pathSegments]
  */
 
 // Search
@@ -113,4 +108,21 @@
  * @property {import('../db/Service')} [service]
  */
 
+// Assert targets map
+
+/**
+ * @typedef {object} assertTargetMap
+ * @property {Map<string, targetMaps>} targets
+ * @property {targetMaps[]} allTargets
+ */
+
+/**
+ * @typedef {object} targetMaps
+ * @property {string} key
+ * @property {entity} entity
+ * @property {object} keys
+ * @property {object} foreignKey
+ * @property {templateElementInfo} assocInfo
+ */
+
 module.exports = {}

package/libx/common/utils/ucsn.js

@@ -61,32 +61,38 @@ const _processor = ({ row, key, plain: { category }, element }) => {
   }
 }
 
-const _cleanup = (row, definition, cleanupNull) => {
+const _cleanup = (row, definition, cleanupNull, cleanupStruct, prefix = []) => {
   if (!row || !definition) return
   const elements = definition.elements || definition.params
   for (const key of Object.keys(row)) {
-    const element = elements[key]
+    if (definition['@open']) continue
+    const element = elements[key] || (cleanupStruct && elements[`${prefix.join('_')}_${key}`])
     if (!element) {
-      if (!definition['@open']) delete row[key]
+      if (cleanupStruct && typeof row[key] === 'object' && !Array.isArray(row[key])) {
+        _cleanup( row[key], definition, cleanupNull, cleanupStruct, [...prefix, key])
+      } else {
+        delete row[key]
+      }
       continue
     }
     if (!row[key]) continue
     if (element.isAssociation) {
       if (element.is2many) {
         for (const r of row[key]) {
-          _cleanup(r, element._target, cleanupNull)
+          _cleanup(r, element._target, cleanupNull, cleanupStruct, [])
         }
       } else {
-        _cleanup(row[key], element._target, cleanupNull)
+        _cleanup(row[key], element._target, cleanupNull, cleanupStruct, [])
       }
     } else if (element.elements) {
-      _cleanup(row[key], element, cleanupNull)
+      _cleanup(row[key], element, cleanupNull, cleanupStruct, prefix)
+      if (!Object.keys(row).length) delete row[key]
       if (cleanupNull && Object.values(row[key]).every(v => v == null)) row[key] = null
     }
   }
 }
 
-function convertStructured(service, definition, data, { cleanupNull = false } = {}) {
+function convertStructured(service, definition, data, { cleanupNull = false, cleanupStruct = false } = {}) {
   if (!definition) return
   // REVISIT check `structs` mode only for now as uCSN is not yet available
   const flatAccess = cds.env.features.compat_flat_access
@@ -95,11 +101,11 @@ function convertStructured(service, definition, data, { cleanupNull = false } =
   if (template && template.elements.size) {
     for (let i = 0; i < arrayData.length; i++) {
       const row = proxifyIfFlattened(definition, arrayData[i])
-      templateProcessor({ processFn: _processor, row, template, pathOptions: { path: [] } })
+      templateProcessor({ processFn: _processor, row, template })
     }
   }
   for (const row of arrayData) {
-    _cleanup(row, definition, cleanupNull)
+    _cleanup(row, definition, cleanupNull, cleanupStruct)
   }
 }
 

package/libx/odata/afterburner.js

@@ -1,6 +1,6 @@
 const cds = require('../_runtime/cds')
 
-const { where2obj } = require('../_runtime/common/utils/cqn')
+const { where2obj, resolveFromSelect } = require('../_runtime/common/utils/cqn')
 const { findCsnTargetFor } = require('../_runtime/common/utils/csn')
 
 const _addKeysDeep = (keys, keysCollector, ignoreManagedBacklinks) => {
@@ -52,14 +52,38 @@ function _resolveAliasInParams(params, entity) {
   }
 }
 
-function _resolveAliasInWhere(where, entity) {
-  if (!entity._alias2ref) return
-  for (const w of where) {
-    if (!w.ref || w.ref.length > 1 || entity.keys[w.ref[0]]) continue
-    w.ref = entity._alias2ref[w.ref[0]] || w.ref
+function _resolveAliasesInRef(ref, target) {
+  if (ref.length === 1) {
+    if (target.keys[ref[0]]) return ref
+    if (target._alias2ref && target._alias2ref[ref[0]]) return [...target._alias2ref[ref[0]]]
+  }
+  for (const seg of ref) {
+    target = target.elements[seg.id || seg]
+    if (!target) return ref
+    if (target.isAssociation) {
+      target = target._target
+      if (seg.where) _resolveAliasesInXpr(seg.where, target)
+    }
+  }
+  return ref
+}
+
+function _resolveAliasesInXpr(xpr, target) {
+  if (!target || !xpr) return
+  for (const el of xpr) {
+    if (el.xpr) _resolveAliasesInXpr(el.xpr, target)
+    if (el.args) _resolveAliasesInXpr(el.args, target)
+    if (el.ref) el.ref = _resolveAliasesInRef(el.ref, target)
   }
 }
 
+function _resolveAliasesInNavigation(cqn, target) {
+  if (!target || !cqn) return
+  if (cqn.SELECT.from.SELECT) _resolveAliasesInNavigation(cqn.SELECT.from, target)
+  if (cqn.SELECT.where) _resolveAliasesInXpr(cqn.SELECT.where, target)
+  if (cqn.SELECT.having) _resolveAliasesInXpr(cqn.SELECT.having, target)
+}
+
 function _addDefaultParams(ref, view) {
   const params = view.params
   const defaults = params && Object.values(params).filter(p => p.default)
@@ -87,9 +111,8 @@ function addRefToWhereIfNecessary(where, entity) {
   return 1
 }
 
-function _processSegments(cqn, model, namespace) {
-  const from = _resolveFrom(cqn.SELECT.from)
-  const ref = from.ref
+function _processSegments(from, model, namespace) {
+  const { ref } = from
 
   let current = model
   let path
@@ -97,13 +120,14 @@ function _processSegments(cqn, model, namespace) {
   let keyCount = 0
   let incompleteKeys
   let one
+  let target
   for (let i = 0; i < ref.length; i++) {
     const seg = ref[i].id || ref[i]
     let params = ref[i].where && where2obj(ref[i].where)
 
     if (incompleteKeys) {
       // > key
-      keys = keys || _keysOf(current, !cds.env.features.rest_new_adapter && !cds.env.features.rest_new_parser) // if odata skip backlinks as key as they are used from structure
+      keys = keys || _keysOf(current, cds.env.features.odata_new_parser) // if odata, skip backlinks as key as they are used from structure
       let key = keys[keyCount++]
       one = true
       const element = current.elements[key]
@@ -118,7 +142,9 @@ function _processSegments(cqn, model, namespace) {
           .join(',')})`
         base.where.push({ ref: [key] }, '=', { val })
       } else {
-        base.where.push({ ref: [key] }, '=', { val: element._type === 'cds.Integer' ? Number(seg) : seg })
+        const val =
+          element._type === 'cds.Integer' ? Number(seg) : element._type === 'cds.Boolean' ? seg === 'true' : seg
+        base.where.push({ ref: [key] }, '=', { val })
       }
       ref[i] = null
       ref[i - keyCount] = base
@@ -137,9 +163,10 @@ function _processSegments(cqn, model, namespace) {
 
       if (current.params && current.kind === 'entity') {
         // > View with params
+        target = current
         if (ref[i].where) {
           keyCount += addRefToWhereIfNecessary(ref[i].where, current)
-          _resolveAliasInWhere(ref[i].where, current)
+          _resolveAliasesInXpr(ref[i].where, current)
           _resolveAliasInParams(params, current)
         }
 
@@ -149,10 +176,12 @@ function _processSegments(cqn, model, namespace) {
         _checkAllKeysProvided(params, current)
 
         ref[i].args = {}
-        for (let j = 0; j < ref[i].where.length; j++) {
-          const w = ref[i].where[j]
-          if (w === 'and' || !w.ref) continue
-          ref[i].args[w.ref[0]] = ref[i].where[j + 2]
+
+        const where = ref[i].where
+        for (let j = 0; j < where.length; j++) {
+          const whereElement = where[j]
+          if (whereElement === 'and' || !whereElement.ref) continue
+          ref[i].args[whereElement.ref[0]] = where[j + 2]
           j += 2
         }
         ref[i].where = undefined
@@ -163,11 +192,12 @@ function _processSegments(cqn, model, namespace) {
         ref[++i] = null
       } else if (current.kind === 'entity') {
         // > entity
+        target = current
         one = !!(ref[i].where || current._isSingleton)
         incompleteKeys = ref[i].where ? false : i === ref.length - 1 || one ? false : true
         if (ref[i].where) {
           keyCount += addRefToWhereIfNecessary(ref[i].where, current)
-          _resolveAliasInWhere(ref[i].where, current)
+          _resolveAliasesInXpr(ref[i].where, current)
           _resolveAliasInParams(params, current)
           // in case of Foo(1), params will be {} (before addRefToWhereIfNecessary was called)
           if (!Object.keys(params).length) params = where2obj(ref[i].where)
@@ -187,14 +217,14 @@ function _processSegments(cqn, model, namespace) {
         one = !!(current.is2one || ref[i].where)
         incompleteKeys = one || i === ref.length - 1 ? false : true
         current = model.definitions[current.target]
+        target = current
         if (ref[i].where) {
           keyCount += addRefToWhereIfNecessary(ref[i].where, current)
-          _resolveAliasInWhere(ref[i].where, current)
+          _resolveAliasesInXpr(ref[i].where, current)
         }
       } else if (current._isStructured) {
         // > nested property
         one = true
-        current = current.elements
       } else {
         // > property
         one = true
@@ -217,15 +247,42 @@ function _processSegments(cqn, model, namespace) {
   // remove all nulled refs
   from.ref = ref.filter(r => r)
 
-  // one?
-  if (one) cqn.SELECT.one = true
-
-  // REVISIT: better
-  // set target (csn definition) for later retrieval
-  cqn.__target = current
+  return { one, current, target }
 }
 
-const _resolveFrom = from => (from.SELECT ? _resolveFrom(from.SELECT.from) : from)
+const AGGREGATION_DEFAULT = '@Aggregation.default'
+
+function _processColumns(cqn, target) {
+  if (cqn.SELECT.from.SELECT) _processColumns(cqn.SELECT.from, target)
+
+  const columns = cqn.SELECT.columns
+
+  if (!Array.isArray(columns)) return
+
+  let aggrProp, aggrElem
+  for (let i = 0; i < columns.length; i++) {
+    if (
+      columns[i].func === null &&
+      columns[i].args &&
+      columns[i].args.length &&
+      columns[i].args[0].ref &&
+      columns[i].args[0].ref.length
+    ) {
+      // REVISIT: also support aggregate(Sales/Amount)?
+      aggrProp = columns[i].args[0].ref[0]
+      aggrElem = target.elements[aggrProp]
+      if (
+        aggrElem &&
+        target[`@Aggregation.CustomAggregate#${aggrProp}`] &&
+        aggrElem[AGGREGATION_DEFAULT] &&
+        aggrElem[AGGREGATION_DEFAULT]['#']
+      ) {
+        columns[i].func = aggrElem[AGGREGATION_DEFAULT]['#'].toLowerCase()
+        columns[i].as = columns[i].as || aggrProp
+      } else throw new Error(`Default aggregation for property '${aggrProp}' not found.`)
+    }
+  }
+}
 
 const _checkAllKeysProvided = (params, entity) => {
   let keysOfEntity
@@ -267,13 +324,21 @@ function _4service(service) {
   const { namespace, model } = service
 
   return cqn => {
-    const { ref } = _resolveFrom(cqn.SELECT.from)
+    const from = resolveFromSelect(cqn)
+    const { ref } = from
 
     // REVISIT: shouldn't be necessary
+    //Second findCsnTargetFor is required for concat query, where the root is already identified with the first query and subsequent queries already have correct root
     /*
      * make first path segment fully qualified
      */
-    const root = findCsnTargetFor(ref[0].id || ref[0], model, namespace)
+    const root =
+      findCsnTargetFor(ref[0].id || ref[0], model, namespace) ||
+      findCsnTargetFor(
+        ref[0].id?.split('.')[ref[0].id?.split('.').length - 1] || ref[0].split('.')[ref[0].split('.').length - 1],
+        model,
+        namespace
+      )
     // REVISIT: 404 or 400?
     if (!root) cds.error(`Invalid resource path "${namespace}.${ref[0].id || ref[0]}"`, { code: 404 })
     if (ref[0].id) ref[0].id = root.name
@@ -282,7 +347,22 @@ function _4service(service) {
     /*
      * key vs. path segments (/Books/1/author/books/2/...) and more
      */
-    _processSegments(cqn, model, namespace)
+    const { one, current, target } = _processSegments(from, model, namespace)
+
+    // one?
+    if (one) cqn.SELECT.one = true
+
+    // REVISIT: better
+    // set target (csn definition) for later retrieval
+    cqn.__target = current
+
+    // target <=> endpoint entity, all navigation refs must be resolvable accordingly
+    if (cds.env.effective.odata.structs) _resolveAliasesInNavigation(cqn, target)
+
+    /*
+     * add default aggregation function (and alias)
+     */
+    _processColumns(cqn, cqn.__target)
 
     return cqn
   }

package/libx/odata/cqn2odata.js

@@ -95,8 +95,8 @@ function _args(args) {
 
 const _in = (column, /* in */ collection, target, kind, isLambda) => {
   const ref = _format(column, null, target, kind, isLambda)
-  // { val: [ 1, 2, 3 ] } or { list: [ { val: 1}, { val: 2}, { val: 3} ] }
-  const values = collection.val || collection.list
+  // { list: [ { val: 1}, { val: 2}, { val: 3} ] }
+  const values = collection.list
   if (values && values.length) {
     // REVISIT: what about OData `in` operator?
     const expressions = values.map(value => `${ref}%20eq%20${_format(value, ref, target, kind, isLambda)}`)
@@ -117,7 +117,7 @@ const _odataV2Func = (func, args) => {
 const _format = (cur, element, target, kind, isLambda) => {
   if (typeof cur !== 'object') return encodeURIComponent(formatVal(cur, element, target, kind))
   if (hasValidProps(cur, 'ref'))
-    return encodeURIComponent(isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref.join('/'))
+    return encodeURIComponent(isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref[0].id || cur.ref.join('/'))
   if (hasValidProps(cur, 'val')) return encodeURIComponent(formatVal(cur.val, element, target, kind))
   if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda)})`
   // REVISIT: How to detect the types for all functions?
@@ -196,9 +196,24 @@ const _keysOfWhere = (where, kind, target) => {
     return `/${keys}`
   }
 
+  if (where.length === 3) {
+    const [left, op, right] = where
+    if (op === '=' && (('val' in left && right.ref) || (left.ref && 'val' in right))) {
+      if ('val' in left) return `(${formatVal(left.val, right.ref.join('/'), target, kind)})`
+      return `(${formatVal(right.val, left.ref.join('/'), target, kind)})`
+    }
+  }
+
   const res = []
   for (const cur of where) {
     if (hasValidProps(cur, 'ref')) {
+      if (target && target._alias2ref) {
+        const alias = target._alias2ref.__2alias[cur.ref.join('/')]
+        if (alias) {
+          res.push(_format({ ref: [alias] }))
+          continue
+        }
+      }
       res.push(_format(cur))
     } else if (hasValidProps(cur, 'val')) {
       // find previous ref
@@ -228,6 +243,24 @@ function _getQueryTarget(entity, propOrEntity, model) {
   }
 }
 
+const _params = (args, kind, target) => {
+  if (!args) {
+    throw new Error(`Incorrect call to a view with parameter "${target.name}"`)
+  }
+  const params = Object.keys(args)
+  if (params.length !== Object.keys(target.params).length) {
+    throw new Error('KEY_EXPECTED')
+  }
+  if (params.length === 1) {
+    return `(${formatVal(args[params[0]].val, params[0], target, kind)})`
+  }
+  const _params = []
+  for (const p of params) {
+    _params.push(`${_format({ ref: [p] })}=${formatVal(args[p].val, p, target, kind)}`)
+  }
+  return `(${_params.join(',')})`
+}
+
 function _from(from, kind, model) {
   if (typeof from === 'string') {
     return { url: _entityUrl(from), queryTarget: model && model.definitions[from] }
@@ -245,6 +278,11 @@ function _from(from, kind, model) {
       queryTarget = model && _getQueryTarget(queryTarget, id, model)
       const keys = _keysOfWhere(where, kind, queryTarget)
       path.push(`${id}${keys}`)
+    } else if (hasValidProps(curRef, 'id') && 'args' in curRef) {
+      const { args, id } = curRef
+      queryTarget = model && _getQueryTarget(queryTarget, id, model)
+      const params = _params(args, kind, queryTarget)
+      path.push(`${id}${params}`)
     } else if (typeof curRef === 'string') {
       queryTarget = model && _getQueryTarget(queryTarget, curRef, model)
       path.push(curRef)
@@ -288,7 +326,7 @@ const _parseColumns = columns => {
       let refName = _format(column)
       if (hasValidProps(column, 'expand')) {
         // REVISIT: incomplete, see test Foo?$expand=invoices($count=true;$expand=item($search="some"))
-        if (!columns.some(c => !c.expand)) select.push(refName)
+        if (!columns.some(c => !c.expand) && !column.ref[0].id) select.push(refName)
         const curOptions = getOptions(column).join(';')
         refName += curOptions ? `(${curOptions})` : ''
         expand.push(refName)
@@ -429,7 +467,8 @@ const parsers = {
   orderBy: (cqnPart, url, kind, target, isCount) => !isCount && $orderBy(cqnPart),
   count: (cqnPart, url, kind, target, isCount) => !isCount && $count(cqnPart, kind),
   limit: (cqnPart, url, kind, target, isCount) => !isCount && $limit(cqnPart),
-  one: (cqnPart, url, kind, target, isCount) => !isCount && $one(cqnPart, url, kind)
+  one: (cqnPart, url, kind, target, isCount) => !isCount && $one(cqnPart, url, kind),
+  ref: (cqnPart, url, kind, target, isCount) => cqnPart[0].where && $where(cqnPart[0].where, target, kind)
 }
 
 function getOptions(cqnPart, url, kind, target, isCount) {
@@ -484,7 +523,7 @@ const _copyData = data => {
   return copied
 }
 
-const _update = (cqn, kind, model) => {
+const _update = (cqn, kind, model, method) => {
   const UPDATE = getProp(cqn, 'UPDATE')
   const { url, queryTarget } = _from(getProp(UPDATE, 'entity'), kind, model)
   let keys = ''
@@ -498,7 +537,7 @@ const _update = (cqn, kind, model) => {
 
   // TODO: support for .set as well
   const body = _copyData(UPDATE.data)
-  return { method: 'PATCH', path: `${url}${keys}`, body }
+  return { method: method || 'PATCH', path: `${url}${keys}`, body }
 }
 
 const _delete = (cqn, kind, model) => {
@@ -517,10 +556,10 @@ const _delete = (cqn, kind, model) => {
   return { method: 'DELETE', path: `${url}${keys}` }
 }
 
-function cqn2odata(cqn, kind, model) {
+function cqn2odata(cqn, { kind, model, method }) {
   if (cqn.SELECT) return _select(cqn, kind, model)
   if (cqn.INSERT) return _insert(cqn, kind, model)
-  if (cqn.UPDATE) return _update(cqn, kind, model)
+  if (cqn.UPDATE) return _update(cqn, kind, model, method)
   if (cqn.DELETE) return _delete(cqn, kind, model)
 
   throw new Error('Unknown CQN object cannot be translated to URL: ' + JSON.stringify(cqn))