@sap/cds 8.7.2 → 8.8.1

package/libx/odata/parse/afterburner.js

@@ -411,9 +411,11 @@ function _processSegments(from, model, namespace, cqn, protocol) {
             ref[i].args = current['@open']
               ? Object.assign({}, from._params)
               : Object.keys(from._params).reduce((acc, cur) => {
-                  if (current.params && cur in current.params) acc[cur] = from._params[cur]
+                  const param = cur.startsWith('@') ? cur.slice(1) : cur
+                  if (current.params && param in current.params) acc[param] = from._params[cur]
                   return acc
                 }, {})
+            ref[i].args = _getDataFromParams(ref[i].args, current) //resolve parameter if Object or Array
             _resolveImplicitFunctionParameters(ref[i].args)
           }
         }
@@ -803,6 +805,24 @@ module.exports = (cqn, model, namespace, protocol) => {
   // one?
   if (one) cqn.SELECT.one = true
 
+  // hierarchy requests, quick check to avoid unnecessary traversing
+  // REVISIT: Should be done via annotation on backlink, would make lookup easier
+  if (target?.elements?.LimitedDescendantCount) {
+    let uplinkName
+    for (const key in target) {
+      if (key.match(/@Aggregation\.RecursiveHierarchy#.*\.ParentNavigationProperty/)) {
+        // Qualifiers are bad for lookups
+        uplinkName = target[key]['=']
+        break
+      }
+    }
+    const setRecurseRef = SELECT => {
+      if (SELECT.from.SELECT) setRecurseRef(SELECT.from.SELECT)
+      if (SELECT.recurse) SELECT.recurse.ref[0] = uplinkName
+    }
+    if (uplinkName) setRecurseRef(cqn.SELECT)
+  }
+
   // REVISIT: better
   // set target (csn definition) for later retrieval
   cqn.__target = current.parent?.kind === 'entity' ? `${current.parent.name}:$:${current.name}` : current.name

package/libx/odata/parse/grammar.peggy

@@ -203,9 +203,71 @@
       ) {
         cqn.from = { SELECT: { ...cqn } }
       }
-      if (apply.topLevels) cqn.__topLevels = apply.topLevels
-      if (apply.ancestors) cqn.__ancestors = apply.ancestors
-      if (apply.descendants) cqn.__descendants = apply.descendants
+
+      const _toplevels = cqn => {
+        cqn.recurse = {
+          ref: ['parent'],
+          
+        }
+        if (apply.topLevels.levels) {
+          cqn.recurse.where = [{ ref: ['DistanceFromRoot'] }, '<=', { val: apply.topLevels.levels }]
+        }
+        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 } )
+          }
+        }
+      }
+      const _descendants = cqn => {
+        return _ancestors(cqn, apply.descendants, 1)
+      }
+      const _ancestors = (cqn, info = apply.ancestors, direction = -1) => {
+        if (info.nodes) {
+          for (const node of info.nodes) {
+            if (node.filter) cqn.where = node.filter // should we accept $filter?
+            else if (node.search) cqn.search = node.search
+          }
+        }
+        const startVal = { val: info.keepStart ? 0 : direction * 1 }
+        const endVal = info.distance && { val: direction * info.distance }
+        const where = endVal ?
+          startVal.val === endVal.val ?
+            [{ ref: ['Distance'] }, '=', startVal ] :
+            [{ ref: ['Distance'] }, 'between', startVal, 'and', endVal] :
+          [{ ref: ['Distance'] }, direction < 0 ? '<=' : '>=', startVal ]
+        cqn.recurse = {
+          ref: ['parent'],
+          where 
+        }
+      }
+
+      if (apply.ancestors && apply.topLevels) {
+        const inner = {
+          SELECT: {
+            from: cqn.from,
+          }
+        }
+        _ancestors(inner.SELECT)
+        cqn.from = inner
+        _toplevels(cqn)
+      } else if (apply.ancestors && apply.descendants) {
+        const inner = {
+          SELECT: {
+            from: cqn.from
+          }
+        }
+        _ancestors(inner.SELECT)
+        cqn.from = inner
+        _descendants(cqn)
+      } else if (apply.topLevels) {
+        _toplevels(cqn)
+      } else if (apply.ancestors) {
+        _ancestors(apply)
+      } else if (apply.descendants) {
+        _descendants(cqn)
+      }
       if (apply.where) cqn.where = apply.where
       if (apply.search) cqn.search = apply.search
       if (apply.groupBy) {
@@ -262,17 +324,41 @@
       return elements
     }
 
+    const _custom = (k, v) =>  {
+        // normalize value
+      if (v === 'null') v = null
+      else if (v === 'true') v = true
+      else if (v === 'false') v = false
+      // set value in structure
+      // REVISIT: SELECT.from._params is a temporary hack
+      const params = SELECT.from._params ??= {}
+      let t = params
+      let x = k.match(/^(\w+)\[(.*)\]$/)
+      while (x) {
+        if (!(x[1] in t)) t[x[1]] = x[2] === '' ? [] : {}
+        t = t[x[1]]
+        k = x[2]
+        x = k.match(/^(\w+)\[(.*)\]$/)
+      }
+      if (Array.isArray(t)) t.push(v)
+      else t[k] = v
+    }
+
     const _replaceAliasedInWhere = (where, alias, value, isFromWhere = false) =>  {
+      let isAliased = false
       where?.forEach(element => {
         if (element.val === alias) {
           // TODO check if we want to store replaced aliases/values for req.data in actions/functions in CQN 
           element.val = 'list' in value ? value.list.map(ele => ele.val) : value.val
+          isAliased = true
         } else if (element.list === alias) {
           element.list = value.list
+          isAliased = true
         } else if (element.func) {
           element.args.forEach((arg, i) => {
             if (arg.val === alias) {
               arg.val = value.val
+              isAliased = true
             } else if (arg.func) {
               _replaceAliasedInWhere(arg.args, alias, value, isFromWhere)
             }
@@ -281,14 +367,17 @@
           _replaceAliased(element.SELECT, alias, value, isFromWhere)
         }
       });
+      return isAliased
     }
     const _replaceAliased = (select, alias, value, isFromWhere = false) =>  {
+      let isAliased = false
       const {where, from} = select
-      _replaceAliasedInWhere(where, alias, value);
+      isAliased =_replaceAliasedInWhere(where, alias, value);
 
       from?.ref?.forEach(element => {
-        _replaceAliasedInWhere(element.where, alias, value, true);
+        isAliased = _replaceAliasedInWhere(element.where, alias, value, true);
       })
+      return isAliased
     }
   }
 
@@ -404,7 +493,7 @@
     temporal /
     format /
     custom /
-    aliasedParamEqualsVal /
+    aliasedParamEqualsValOrPrefixParam /
     deltaToken
   // @OData spec for $expand:
   // "Allowed system query options are $filter, $select, $orderby, $skip, $top, $count, $search, $expand and 
@@ -646,29 +735,21 @@
 
   aliasedParamVal = val / jsonObject / jsonArray / "[" list:innerListParam "]" { return { list } }
 
-  custom = k:$([a-zA-Z0-9-_.~!\[\]]+) "="? v:$([^&]*)? {
-    // normalize value
-    if (v === 'null') v = null
-    else if (v === 'true') v = true
-    else if (v === 'false') v = false
-    // set value in structure
-    // REVISIT: SELECT.from._params is a temporary hack
-    const params = SELECT.from._params ??= {}
-    let t = params
-    let x = k.match(/^(\w+)\[(.*)\]$/)
-    while (x) {
-      if (!(x[1] in t)) t[x[1]] = x[2] === '' ? [] : {}
-      t = t[x[1]]
-      k = x[2]
-      x = k.match(/^(\w+)\[(.*)\]$/)
-    }
-    if (Array.isArray(t)) t.push(v)
-    else t[k] = v
+  custom = k:$([[a-zA-Z0-9-_.~!\[\]]+) "="? v:$([^&]*)? {
+    _custom(k, v)
   }
 
   aliasedParam "an aliased parameter (@param)" = "@" i:identifier { return "@" + i }
-  aliasedParamEqualsVal = alias:aliasedParam "=" !aliasedParam value:aliasedParamVal {
-    _replaceAliased(SELECT, alias, value);
+  aliasedParamEqualsValOrPrefixParam = alias:aliasedParam "=" !aliasedParam value:aliasedParamVal {
+    const isAliased =  _replaceAliased(SELECT, alias, value);
+    if (!isAliased) { // custom parameters with "@" prefix (not aliased)
+      if (value.val) {
+        value = value.val
+      } else if (value.list && Array.isArray(value.list)) {
+        value = value.list.map(obj => obj.val)
+      }
+      _custom(alias, value) 
+    }
   }
 
   format = "$format=" f:$([^&]*) {
@@ -947,6 +1028,7 @@
             hierarchy: h,
             id: e,
             nodes: t,
+            distance: d,
             keepStart: k?.keepStart || false
         }
     }

package/libx/odata/parse/multipartToJson.js

@@ -116,28 +116,35 @@ const _parseStream = async function* (body, boundary) {
         .toString()
         .replace(/^--(.*)$/gm, (_, g) => `HEAD /${g} HTTP/1.1${g.slice(-2) === '--' ? CRLF : ''}`)
         // correct content-length for non-HEAD requests is inserted below
-        .replace(/content-length: \d+\r\n/gim, '')
+        .replace(/content-length: \d+\r\n/gim, '') // if content-length is given it should be taken
         .replace(/ \$/g, ' /$')
 
       // HACKS!!!
       // ensure URLs start with slashes
       changed = changed.replaceAll(/\r\n(GET|PUT|POST|PATCH|DELETE) (\w)/g, `\r\n$1 /$2`)
       // add content-length headers
-      let lastIndex = 0
-      changed = changed.replaceAll(/(\r\n){2,}(.+)[\r\n]+HEAD/g, (match, _, p1, index, original) => {
-        const part = original.substring(lastIndex, index)
-        lastIndex = index
-        return part.match(/(PUT|POST|PATCH)\s\//g) && !part.match(/content-length/i) && !p1.startsWith('HEAD /')
-          ? `${CRLF}content-length: ${Buffer.byteLength(p1)}${match}`
-          : match
-      })
+      changed = changed
+        .split(CRLF + CRLF)
+        .map((line, i, arr) => {
+          if (/^(PUT|POST|PATCH) /.test(line) && !/content-length/i.test(line)) {
+            const body = arr[i + 1].split('\r\nHEAD')[0]
+            if (body) return `${line}${CRLF}content-length: ${Buffer.byteLength(body)}`
+          }
+          return line
+        })
+        .join(CRLF + CRLF)
       // remove strange "Group ID" appendix
       changed = changed.split(`${CRLF}Group ID`)[0] + CRLF
 
       let ret = parser.execute(Buffer.from(changed))
 
       if (typeof ret !== 'number') {
-        if (ret.message === 'Parse Error') {
+        if (ret.code === 'HPE_HEADER_OVERFLOW') {
+          // same error conversion as node http server
+          ret.status = 431
+          ret.code = '431'
+          ret.message = 'Request Header Fields Too Large'
+        } else if (ret.message === 'Parse Error') {
           ret.statusCode = 400
           ret.message = `Error while parsing batch body at position ${ret.bytesParsed}: ${ret.reason}`
         }