@sap/cds 8.8.3 → 8.9.1

package/libx/odata/parse/cqn2odata.js

@@ -74,7 +74,7 @@ function hasValidProps(obj, ...names) {
   return true
 }
 
-function _args(args, func) {
+function _args(args, func, navPrefix) {
   const res = []
 
   for (const cur of args) {
@@ -84,9 +84,9 @@ function _args(args, func) {
     }
 
     if (hasValidProps(cur, 'func', 'args')) {
-      res.push(`${cur.func}(${_args(cur.args, cur.func)})`)
+      res.push(`${cur.func}(${_args(cur.args, cur.func, navPrefix)})`)
     } else if (hasValidProps(cur, 'ref')) {
-      res.push(_format(cur))
+      res.push(_format(cur, null, null, null, null, null, navPrefix))
     } else if (hasValidProps(cur, 'val')) {
       res.push(_format(cur, null, null, null, null, func))
     }
@@ -95,38 +95,44 @@ function _args(args, func) {
   return res.join(',')
 }
 
-const _in = (column, /* in */ collection, target, kind, isLambda) => {
-  const ref = _format(column, null, target, kind, isLambda)
+const _in = (column, /* in */ collection, target, kind, isLambda, navPrefix) => {
+  const ref = _format(column, null, target, kind, isLambda, null, navPrefix)
   // { 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)}`)
+    const expressions = values.map(
+      value => `${ref}%20eq%20${_format(value, ref, target, kind, isLambda, null, navPrefix)}`
+    )
     return expressions.join('%20or%20')
   }
 }
 
-const _odataV2Func = (func, args) => {
+const _odataV2Func = (func, args, navPrefix) => {
   switch (func) {
     case 'contains':
       // this doesn't support the contains signature with two collections as args, introduced in odata v4.01
-      return `substringof(${_args([args[1], args[0]])})`
+      return `substringof(${_args([args[1], args[0]], null, navPrefix)})`
     default:
-      return `${func}(${_args(args, func)})`
+      return `${func}(${_args(args, func, navPrefix)})`
   }
 }
 
-const _format = (cur, elementName, target, kind, isLambda, func) => {
+const _format = (cur, elementName, target, kind, isLambda, func, navPrefix = []) => {
   if (typeof cur !== 'object') return encodeURIComponent(formatVal(cur, elementName, target, kind))
   if (hasValidProps(cur, 'ref'))
-    return encodeURIComponent(isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref[0].id || cur.ref.join('/'))
+    return encodeURIComponent(
+      isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref[0].id || [...navPrefix, ...cur.ref].join('/')
+    )
   if (hasValidProps(cur, 'val'))
     return encodeURIComponent(formatVal(cur.val, elementName, target, kind, func, cur.literal))
-  if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda)})`
+  if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda, navPrefix)})`
   // REVISIT: How to detect the types for all functions?
   if (hasValidProps(cur, 'func')) {
     if (cur.args?.length) {
-      return kind === 'odata-v2' ? _odataV2Func(cur.func, cur.args) : `${cur.func}(${_args(cur.args, cur.func)})`
+      return kind === 'odata-v2'
+        ? _odataV2Func(cur.func, cur.args, navPrefix)
+        : `${cur.func}(${_args(cur.args, cur.func)})`
     }
     return `${cur.func}()`
   }
@@ -138,7 +144,7 @@ const _isLambda = (cur, next) => {
   return last && hasValidProps(last, 'id')
 }
 
-function _xpr(expr, target, kind, isLambda) {
+function _xpr(expr, target, kind, isLambda, navPrefix = []) {
   const res = []
   const openBrackets = []
 
@@ -165,10 +171,10 @@ function _xpr(expr, target, kind, isLambda) {
         const between = [expr[i - 1], 'gt', expr[i + 1], 'and', expr[i - 1], 'lt', expr[i + 3]]
         // cleanup previous ref
         res.pop()
-        res.push(`(${_xpr(between, target, kind, isLambda)})`)
+        res.push(`(${_xpr(between, target, kind, isLambda, navPrefix)})`)
         i += 3
       } else if (cur === 'in') {
-        const inExpr = _in(expr[i - 1], expr[i + 1], target, kind, isLambda)
+        const inExpr = _in(expr[i - 1], expr[i + 1], target, kind, isLambda, navPrefix)
         // cleanup previous ref
         res.pop()
         // when sending a where clause with "col in []" we currently ignore the where clause
@@ -179,20 +185,33 @@ function _xpr(expr, target, kind, isLambda) {
       } else if (_isLambda(cur, expr[i + 1])) {
         const { where } = expr[i + 1].ref.at(-1)
         const nav = expr[i + 1].ref.map(ref => ref?.id ?? ref).join('/')
-        // odata-v2 does not support lambda expressions but successfactors allows filter like for to-one assocs
+
         if (kind === 'odata-v2') {
+          // odata-v2 does not support lambda expressions but successfactors allows filter like for to-one assocs
           cds.log('remote').info(`OData V2 does not support lambda expressions. Using path expression as best effort.`)
           isLambda = false
-          res.push(`${nav}%2F${_xpr(where, target, kind)}`)
-        } else if (!where) res.push(`${nav}/any()`)
-        else res.push(`${nav}/any(${LAMBDA_VARIABLE}:${_xpr(where, target, kind, true)})`)
+          res.push(_xpr(where, target, kind, isLambda, [...navPrefix, nav]))
+        } else if (!where) {
+          res.push(`${nav}/any()`)
+        } else {
+          res.push(`${nav}/any(${LAMBDA_VARIABLE}:${_xpr(where, target, kind, true, navPrefix)})`)
+        }
+
         i++
       } else {
         res.push(OPERATORS[cur] || cur.toLowerCase())
       }
     } else {
       const ref = expr[i - 2]
-      const formatted = _format(cur, ref?.ref && (ref.ref.length ? ref.ref : ref.ref[0]), target, kind, isLambda)
+      const formatted = _format(
+        cur,
+        ref?.ref && (ref.ref.length ? ref.ref : ref.ref[0]),
+        target,
+        kind,
+        isLambda,
+        null,
+        navPrefix
+      )
       if (formatted !== undefined) res.push(formatted)
     }
   }
@@ -393,6 +412,8 @@ function $orderBy(orderBy) {
   const res = []
 
   for (const cur of orderBy) {
+    if (cur.implicit) continue
+
     if (hasValidProps(cur, 'ref', 'sort')) {
       res.push(_format(cur) + '%20' + cur.sort)
       continue
@@ -412,7 +433,7 @@ function $orderBy(orderBy) {
     }
   }
 
-  return '$orderby=' + res.join(',')
+  if (res.length) return '$orderby=' + res.join(',')
 }
 
 function parseSearch(search) {

package/libx/odata/parse/grammar.peggy

@@ -210,13 +210,18 @@
           
         }
         if (apply.topLevels.levels) {
-          cqn.recurse.where = [{ ref: ['DistanceFromRoot'] }, '<=', { val: apply.topLevels.levels }]
+          cqn.recurse.where = [{ ref: ['DistanceFromRoot'] }, '<=', { val: apply.topLevels.levels - 1 }]
         }
         if (apply.topLevels.expandLevels) {
           if (!cqn.recurse.where) cqn.recurse.where = []
           for (const expandLevel of apply.topLevels.expandLevels) {
             if (cqn.recurse.where.length !== 0) cqn.recurse.where.push('or')
-            cqn.recurse.where.push({ ref: [apply.topLevels.nodeProperty] }, '=', { val: expandLevel.nodeID }, 'and', { ref: ['Distance'] }, 'between', { val: 0 }, 'and', { val: expandLevel.levels } )
+            cqn.recurse.where.push({ ref: [apply.topLevels.nodeProperty] }, '=', { val: expandLevel.nodeID })
+            if (Number.isInteger(expandLevel.levels)) {
+              cqn.recurse.where.push('and', { ref: ['Distance'] })
+              if (expandLevel.levels === 1) cqn.recurse.where.push('=', { val: 1 })
+              else cqn.recurse.where.push('between', { val: 1 }, 'and', { val: expandLevel.levels } )
+            }
           }
         }
       }
@@ -244,23 +249,16 @@
       }
 
       if (apply.ancestors && apply.topLevels) {
-        const inner = {
-          SELECT: {
-            from: cqn.from,
-          }
-        }
-        _ancestors(inner.SELECT)
-        cqn.from = inner
-        _toplevels(cqn)
+        _ancestors(cqn)
+        const extra = {...cqn}
+        _toplevels(extra)
+        cqn.recurse = extra.recurse
       } else if (apply.ancestors && apply.descendants) {
-        const inner = {
-          SELECT: {
-            from: cqn.from
-          }
-        }
-        _ancestors(inner.SELECT)
-        cqn.from = inner
-        _descendants(cqn)
+        _ancestors(cqn)
+        const extra = {...cqn}
+        _descendants(extra)
+        cqn.where = extra.where
+        cqn.recurse = extra.recurse
       } else if (apply.topLevels) {
         _toplevels(cqn)
       } else if (apply.ancestors) {
@@ -1019,7 +1017,11 @@
 
   expandItemProp
     = "\"NodeID\"" o ":" o s:doubleQuotedString{return { nodeID: s } } /
-      "\"Levels\"" o ":" o i:integer{return { levels: i } }
+      "\"Levels\"" o ":" o l:expandItemLevel{return { levels: l } }
+
+  expandItemLevel
+    = i:integer{ return i } /
+      null{ return null }
 
   ansDescTrafo
     = OPEN o "$root/" p:simplePath o COMMA o h:identifier o COMMA o e:identifier o COMMA? t:ansDescGetNodes? o COMMA? d:integer? o COMMA? k:ansDescKeepStart? CLOSE {