@sap/cds 5.6.1 → 5.7.1

package/libx/odata/{odata2cqn/afterburner.js → afterburner.js}

@@ -1,7 +1,7 @@
-const cds = require('../../_runtime/cds')
+const cds = require('../_runtime/cds')
 
-const { where2obj } = require('../../_runtime/common/utils/cqn')
-const { findCsnTargetFor } = require('../../_runtime/common/utils/csn')
+const { where2obj } = require('../_runtime/common/utils/cqn')
+const { findCsnTargetFor } = require('../_runtime/common/utils/csn')
 
 function _keysOf(entity) {
   return entity && entity.keys
@@ -11,11 +11,11 @@ function _keysOf(entity) {
     : []
 }
 
-function _getDefinition(definition, name) {
+function _getDefinition(definition, name, namespace) {
   return (
     (definition.definitions && definition.definitions[name]) ||
     (definition.elements && definition.elements[name]) ||
-    (definition.actions && definition.actions[name]) ||
+    (definition.actions && (definition.actions[name] || definition.actions[name.replace(namespace + '.', '')])) ||
     definition[name]
   )
 }
@@ -29,7 +29,7 @@ function _resolveAliasInWhere(where, entity) {
 }
 
 // case: single key without name, e.g., Foo(1)
-function _addRefToWhereIfNecessary(where, entity) {
+function addRefToWhereIfNecessary(where, entity) {
   if (!where || where.length !== 1) return 0
   const keys = _keysOf(entity)
   if (keys.length !== 1) return 0
@@ -37,8 +37,9 @@ function _addRefToWhereIfNecessary(where, entity) {
   return 1
 }
 
-function _processSegments(cqn, model) {
-  const { ref } = cqn.SELECT.from
+function _processSegments(cqn, model, namespace) {
+  const from = _resolveFrom(cqn.SELECT.from)
+  const ref = from.ref
 
   let current = model
   let path
@@ -59,7 +60,15 @@ function _processSegments(cqn, model) {
       let base = ref[i - keyCount]
       if (!base.id) base = { id: base, where: [] }
       if (base.where.length) base.where.push('and')
-      base.where.push({ ref: [key] }, '=', { val: element.type === 'cds.Integer' ? Number(seg) : seg })
+      if (ref[i].id) {
+        // > fix case key value parsed to collection with filter
+        const val = `${ref[i].id}(${Object.keys(params)
+          .map(k => `${k}='${params[k]}'`)
+          .join(',')})`
+        base.where.push({ ref: [key] }, '=', { val })
+      } else {
+        base.where.push({ ref: [key] }, '=', { val: element.type === 'cds.Integer' ? Number(seg) : seg })
+      }
       ref[i] = null
       ref[i - keyCount] = base
       incompleteKeys = keyCount < keys.length
@@ -71,7 +80,7 @@ function _processSegments(cqn, model) {
 
       path = path ? path + `${path.match(/:/) ? '.' : ':'}${seg}` : seg
       // REVISIT: replace use case: <namespace>.<entity>_history is at <namespace>.<entity>.history
-      current = _getDefinition(current, seg) || _getDefinition(current, seg.replace(/_/g, '.'))
+      current = _getDefinition(current, seg, namespace) || _getDefinition(current, seg.replace(/_/g, '.'), namespace)
       // REVISIT: 404 or 400?
       if (!current) cds.error(`Invalid resource path "${path}"`, { code: 404 })
 
@@ -80,7 +89,7 @@ function _processSegments(cqn, model) {
         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)
+          keyCount += addRefToWhereIfNecessary(ref[i].where, current)
           _resolveAliasInWhere(ref[i].where, current)
         }
       } else if ({ action: 1, function: 1 }[current.kind]) {
@@ -98,7 +107,7 @@ function _processSegments(cqn, model) {
         incompleteKeys = one || i === ref.length - 1 ? false : true
         current = model.definitions[current.target]
         if (ref[i].where) {
-          keyCount += _addRefToWhereIfNecessary(ref[i].where, current)
+          keyCount += addRefToWhereIfNecessary(ref[i].where, current)
           _resolveAliasInWhere(ref[i].where, current)
         }
       } else if (current._isStructured) {
@@ -125,7 +134,7 @@ function _processSegments(cqn, model) {
   }
 
   // remove all nulled refs
-  cqn.SELECT.from.ref = ref.filter(r => r)
+  from.ref = ref.filter(r => r)
 
   // one?
   if (one) cqn.SELECT.one = true
@@ -135,11 +144,13 @@ function _processSegments(cqn, model) {
   cqn.__target = current
 }
 
+const _resolveFrom = from => (from.SELECT ? _resolveFrom(from.SELECT.from) : from)
+
 function _4service(service) {
   const { namespace, model } = service
 
   return cqn => {
-    const { ref } = cqn.SELECT.from
+    const { ref } = _resolveFrom(cqn.SELECT.from)
 
     // REVISIT: shouldn't be necessary
     /*
@@ -154,7 +165,7 @@ function _4service(service) {
     /*
      * key vs. path segments (/Books/1/author/books/2/...) and more
      */
-    _processSegments(cqn, model)
+    _processSegments(cqn, model, namespace)
 
     return cqn
   }
@@ -166,5 +177,6 @@ module.exports = {
   for: service => {
     if (!cache.has(service)) cache.set(service, _4service(service))
     return cache.get(service)
-  }
+  },
+  addRefToWhereIfNecessary
 }

package/libx/odata/{cqn2odata/index.js → cqn2odata.js}

@@ -1,4 +1,4 @@
-const { formatVal } = require('../utils')
+const { formatVal } = require('./utils')
 
 const OPERATORS = {
   '=': 'eq',

package/libx/odata/{odata2cqn/grammar.pegjs → grammar.pegjs}

@@ -27,9 +27,6 @@
 //
 // ---------- JavaScript Helpers -------------
   {
-    const exception = (message, code = 400) => {
-      error(JSON.stringify({ code, message }))
-    }
     const $ = Object.assign
     const { strict, minimal } = options
     const stack = []
@@ -42,79 +39,86 @@
       return Number.isSafeInteger(n) ? n : str
     }
 
-    // NOTe: mutation of the object property, it's NOT a pure function
-    const correctAggAwayWhere = (where, colNames) => {
-      const changedWhere = [...where];
-
-      for (const item of changedWhere) {
-        if (item.xpr) {
-          item.xpr = correctAggAwayWhere(item.xpr, colNames)
-        }
-
-        if (item.args) {
-          item.args = correctAggAwayWhere(item.args, colNames)
-        }
-
-        // $filter ohne $apply -> input set = entity -> kein null setzen
-        // $apply mit filter transformation -> wie oben
-        // $apply mit filter transformation + $filter -> filter in where, $filter in having
-        // $apply mit filter transformation + groupby/aggregate/select + $filter -> filter in where, $filter in having
-
-        // TODO fix this for $apply
-        if(item.ref && !colNames.includes(item.ref.join(''))) {
-          // item.ref = null;
+    const _compareRefs = col => exp => col === exp ||
+      (col.as && exp.as && col.as === exp.as) ||
+      (exp.as && col.ref && exp.as === col.ref[col.ref.length - 1]) ||
+      (col.ref && exp.ref && col.ref.join('') === exp.ref.join(''))
+    const _remapFunc = columns => c => {
+      if (Array.isArray(c)) return c.map(_remapFunc(columns))
+      const fnObj = c.ref && columns.find(col => col.as && col.func && col.as === c.ref[0])
+      if (fnObj) return fnObj
+      return c
+    }
+    const _replaceNullRef = groupBy => c => {
+      if (Array.isArray(c)) return c.map(_replaceNullRef(groupBy))
+      if (c.ref && !groupBy.find(_compareRefs(c))) return { val: null }
+      return c
+    }
+    const _expand = (columns, col) => {
+      if (col.ref.length === 1) {
+        if (!columns.find(_compareRefs(col))) columns.push(col)
+      } else {
+        const assoc = col.ref.shift()
+        const exp = columns.find(c => c.ref && c.ref[0] === assoc)
+        if (exp) {
+          _expand(exp.expand, col)
+        } else {
+          const exp = {
+            ref: [assoc],
+            expand: []
+          }
+          _expand(exp.expand, col)
+          columns.push(exp)
         }
-        // REVISIT: { val:null } for should be also implemented
       }
-
-      return changedWhere;
     }
-
-    const correctAggAwayColumns = (SELECT) => {
-      const groupBy = SELECT.groupBy;
-      const where = SELECT.where;
-      const columns = SELECT.columns || [];
-      const aggregates = columns.filter((cur) => cur.as);
-
-      let fromAggregate = [];
-      let fromGroupBy = [];
-
-      // handle $apply=aggregate(... as someProp)&$select=someProp,?...
-      if (aggregates.length !== 0) {
-        fromAggregate = columns.filter((cur) =>
-          cur.ref ? aggregates.includes(cur.ref.join('')) : true
-        );
+    const _handleApply = (cqn, apply, onlyColumnsFromExpand = false) => {
+      if (!apply) return
+      if (cqn.apply) delete cqn.apply
+      if (apply.apply || (apply.where && cqn.where) || (apply.search && cqn.search)) {
+        cqn.from = { SELECT: { from: cqn.from } }
       }
-
-      // handle $apply=groupby((someProp,?...))&$select=?...
-      if (groupBy) {
-        const allowedNames = groupBy.map(({ ref }) => ref && ref.join(''));
-        const allowedColumns = columns.filter((cur) =>
-           cur.ref && allowedNames.includes(cur.ref.join(''))
-        );
-        fromGroupBy = allowedColumns.length === 0 ? [...groupBy] : allowedColumns;
+      if (apply.where) {
+        if (cqn.where) cqn.from.SELECT.where = apply.where
+        else cqn.where = apply.where
       }
-
-      const newColumns = fromAggregate.length !== 0 || fromGroupBy.length !== 0
-        ? [...fromGroupBy, ...fromAggregate]
-        : SELECT.columns;
-
-      let result = { ...SELECT }
-      if (newColumns) result.columns = newColumns
-      let newWhere = [];
-
-      if (where && (groupBy || aggregates.length !== 0)) {
-        // changing { ref: null } for aggregated-away props
-        const colNames = columns.map((cur) => cur.ref && cur.ref.join('') || cur.as);
-        result = { ...result, where: correctAggAwayWhere(where, colNames) }
+      if (apply.search) {
+        if (cqn.search) cqn.from.SELECT.search = apply.search
+        else cqn.search = apply.search
       }
-
-      return result;
+      if (apply.groupBy) {
+        cqn.groupBy = []
+        for (const col of apply.groupBy) {
+          if (!cqn.groupBy.find(_compareRefs(col))) cqn.groupBy.push(col)
+        }
+      }
+      const aggregatedColumns = [...(cqn.groupBy || []), ...(apply.aggregate || [])]
+      if (aggregatedColumns.length) {
+        cqn.columns = cqn.columns && !onlyColumnsFromExpand
+          // using .reduce instead of .filter since columns order might be important
+          ? cqn.columns.reduce((columns, col) => {
+            const aggregatedColumn = aggregatedColumns.find(_compareRefs(col))
+            if (aggregatedColumn) columns.push(aggregatedColumn)
+            return columns
+          }, [])
+          : aggregatedColumns
+        if (cqn.where) {
+          cqn.where = cqn.where.map(_remapFunc(cqn.columns))
+          if (cqn.groupBy) {
+            cqn.having = cqn.where.map(_replaceNullRef(cqn.groupBy))
+            delete cqn.where
+          }
+        }
+        // expand navigation refs in aggregated columns
+        cqn.columns = cqn.columns.reduce((columns, col) => {
+          if (col.ref && col.ref.length > 1 && aggregatedColumns.find(_compareRefs(col))) {
+            _expand(columns, { ref: [...col.ref] })
+          } else columns.push(col)
+          return columns
+        }, [])
+      }
+      if (apply.apply) _handleApply(cqn.from.SELECT, apply.apply)
     }
-
-    const _compareRefs = col => exp => col === exp ||
-      (col.as && exp.as && col.as === exp.as) ||
-      (col.ref && exp.ref && col.ref.join('') === exp.ref.join(''))
   }
 
 // ---------- Entity Paths ---------------
@@ -129,11 +133,19 @@
         delete SELECT.expand
         delete SELECT.limit
         delete SELECT.orderBy
+        if (SELECT.apply) {
+          SELECT.apply = { apply: SELECT.apply }
+          _handleApply(SELECT, SELECT.apply)
+        }
         return { SELECT }
       }
+      let onlyColumnsFromExpand
       if (SELECT.expand) {
         // Books?$expand=author w/o $select=author
-        if (!SELECT.columns) SELECT.columns = ['*']
+        if (!SELECT.columns) {
+          SELECT.columns = ['*']
+          onlyColumnsFromExpand = true
+        }
         for (const exp of SELECT.expand) {
           const idx = SELECT.columns.findIndex(_compareRefs(exp))
           if (idx > -1) SELECT.columns.splice(idx, 1)
@@ -141,22 +153,25 @@
         }
         delete SELECT.expand
       }
-      SELECT = correctAggAwayColumns(SELECT)
-
+      _handleApply(SELECT, SELECT.apply, onlyColumnsFromExpand)
       return { SELECT }
     }
 
   path
     = "$count" {count = true}
     / rv:$("$ref"/"$value") {return !TECHNICAL_OPTS.includes(rv) && {from: {ref: [rv]}}}
-    / head:(identifier/val) filter:(OPEN CLOSE/OPEN args CLOSE)? tail:( '/' p:path {return p} )? {
+    / head:(
+      (identifier filter:(OPEN CLOSE/OPEN args CLOSE)? !segment) / val:(s:(!string val){return s[1]} / segment){return [val]}
+    ) tail:( '/' p:path {return p} )? {
+      const [id, filter] = head
       // minimal: val also as path segment
       const ref = [
         filter
           ? filter.length > 2
-            ? { id: head, where: filter[1].map(f => f.val && f.val.match && f.val.match(/^"(.*)"$/) ? { val: f.val.match(/^"(.*)"$/)[1] } : f) }
-            : { id: head, where: [] }
-          : ( minimal ? `${Object.prototype.hasOwnProperty.call(head, 'val') ? head.val : head}` : head )
+            ? { id, where: filter[1].map(f => f.val && f.val.match && f.val.match(/^"(.*)"$/) ? { val: f.val.match(/^"(.*)"$/)[1] } : f) }
+            : { id, where: [] }
+          // hasOwnProperty in case of '{val:0}' and so on
+          : ( minimal ? `${typeof id === 'object' && Object.prototype.hasOwnProperty.call(id, 'val') ? id.val : id}` : id )
       ]
       if (tail && tail.from) {
         const more = tail.from.ref
@@ -170,7 +185,7 @@
 
   args
     = val:val {return [val]}
-    / ref:ref o"="o val:(val/w:word{return {val: w}}) more:( COMMA args )? {
+    / ref:ref o"="o val:val more:( COMMA args )? {
       const args = [ ref, '=', val ]
       if (more) args.push ('and', ...more[1])
       return args
@@ -183,13 +198,16 @@
   ExpandOption =
     "$select="      o select ( COMMA select )* /
     "$expand="      o expand ( COMMA expand )* /
-    "$filter="      o filter /
+    "$filter="      o f:filter{SELECT.where = f} /
     "$orderby="     o orderby ( COMMA orderby )* /
     "$top="         o top /
     "$skip="        o skip /
-    "$search="      o search /
+    "$skiptoken="   o skip /
+    "$search="      o s:search {if (s) SELECT.search = s} /
     "$count="       o count /
-    "$apply="       o apply /
+    "$apply="       (o{
+      SELECT.apply = {}
+    }) apply /
     custom
 
 
@@ -241,11 +259,15 @@
 
   skip
     = val:integer {
+      if (SELECT.limit && SELECT.limit.offset && SELECT.limit.offset.val) {
+        val += SELECT.limit.offset.val
+      }
       (SELECT.limit || (SELECT.limit={})).offset = {val}
     }
 
   search
-    = p:search_clause {SELECT.search = p}
+    = p:search_clause {return p}
+      / o // Do not add search property for space only
 
   search_clause
     = p:( n:NOT? {return n?[n]:[]} )(
@@ -259,7 +281,7 @@
     {return p}
 
   filter
-    = p:where_clause {SELECT.where = p}
+    = p:where_clause { return p }
 
   where_clause = p:( n:NOT? {return n?[n]:[]} )(
       OPEN xpr:where_clause CLOSE {p.push({xpr})}
@@ -352,7 +374,17 @@
     = operand (_ ("add" / "sub" / "mul" / "div" / "mod") _ operand)*
 
   operand "an operand"
-    = function / ref / val / jsonObject / jsonArray / list
+    = navigationCount / function / ref / val / jsonObject / jsonArray / list
+
+  navigationCount "navigation with $count"
+  = navigationPath:(head:identifier key:(OPEN keyArgs:args CLOSE {return keyArgs;})? '/' {
+    if (key) {
+      // we have key in xpr
+      return {id: head, where: key}
+    }
+    return head;
+  })+ count: '$count'
+    { return {func: 'count', as: '$count', args: [{ref: navigationPath}]} }
 
   ref "a reference"
     = head:identifier tail:( '/' n:identifier {return n})*
@@ -366,7 +398,7 @@
 
   val
     = val:(bool / date) {return {val}}
-    / guid
+    / val:guid {return {val}}
     / val:number {return typeof val === 'number' ? {val} : { val, literal:'number' }}
     / val:string {return {val}}
 
@@ -380,7 +412,9 @@
 
   function "a function call"
     = func:$[a-z]+ OPEN a:operand more:( COMMA o:operand {return o} )* CLOSE {
-      if (strict && !(func in strict.functions)) exception("'"+ func +"' is an unknown function in OData URL spec (strict mode)")
+      if (strict && !(func in strict.functions)) {
+        throw Object.assign(new Error(`"${func}" is an unknown function in OData URL spec (strict mode)`), { statusCode: 400 })
+      }
       return { func, args:[a,...more] }
     }
 
@@ -402,7 +436,6 @@
       "aggregate" aggregateTrafo /
       "groupby" groupbyTrafo /
       "filter" filterTrafo /
-      countTrafo /
 
       // REVISIT: All transformations below need improvment
       // and should supported by CAP
@@ -410,31 +443,45 @@
       "search" searchTrafo /
       "concat" concatTrafo /
       "compute" computeTrafo /
-      "bottompercent" commonFuncTrafo /
-      "bottomsum" commonFuncTrafo /
-      "toppercent" commonFuncTrafo /
-      "topsum" commonFuncTrafo /
+      func:("topcount"/"bottomcount"/"topsum"/"bottomsum"/"toppercent"/"bottompercent") args:commonFuncTrafo {
+        const SUPPORTED_APPLY_TRANSFORMATIONS = {
+          "topcount": true,
+          "bottomcount": true,
+          "topsum": false,
+          "bottomsum": false,
+          "toppercent": false,
+          "bottompercent": false
+        }
+        if (!SUPPORTED_APPLY_TRANSFORMATIONS[func]) {
+          throw Object.assign(new Error(`Transformation "${func}" in $apply is not supported yet.`), { statusCode: 501 })
+        }
+        (SELECT.apply.aggregate || (SELECT.apply.aggregate = [])).push({ func, args })
+      } /
       identityTrafo
       // customFunction
     )
 
   aggregateTrafo
-     = OPEN o aggregateItem (o COMMA o aggregateItem)* o CLOSE
+    = OPEN o head:aggregateItem tail:(o COMMA o p:aggregateItem {return p})* o CLOSE {
+      let _apply = SELECT.apply
+      if (_apply.aggregate) {
+        SELECT.apply = { apply: _apply }
+        if (_apply.groupBy) SELECT.apply.groupBy = _apply.groupBy
+        _apply = SELECT.apply
+      }
+      _apply.aggregate = [head, ...tail]
+    }
   aggregateItem
-    = res:("$count" alias:asAlias { return { func: 'count', args: ['*'], as: alias } }
+    = res:("$count" as:asAlias { return { func: 'count', args: [{ val: 1 }], as } }
            / aggregateExpr
-          ) {
-            SELECT.columns = Array.isArray(SELECT.columns) ? SELECT.columns : []
-            if (!SELECT.columns.find(_compareRefs(res))) SELECT.columns.push(res)
-            return res
-          }
+          ) { return res }
   aggregateExpr
     = path:(
         ref
      // / mathCalc - needs CAP support
       )
-      func:aggregateWith aggregateFrom? alias:asAlias
-        { return { func, args: [ path ], as: alias } }
+      func:aggregateWith aggregateFrom? as:asAlias
+        { return { func, args: [ path ], as } }
       / identifier OPEN aggregateExpr CLOSE // needs CAP support
    // / customAggregate // needs CAP support
   aggregateWith
@@ -445,22 +492,27 @@
     = _ "as" _ alias:identifier { return alias; }
 
   groupbyTrafo
-    = OPEN o (OPEN groupByElem (COMMA o groupByElem)* CLOSE) (COMMA o apply)? o CLOSE
+    = OPEN OPEN head:groupByElem tail:(COMMA p:groupByElem {return p})* (CLOSE {
+      let _apply = SELECT.apply
+      if (_apply.groupBy || _apply.where || _apply.search) {
+        SELECT.apply = { apply: _apply }
+        _apply = SELECT.apply
+      }
+      _apply.groupBy = [head, ...tail]
+    }) (COMMA apply)? CLOSE
   groupByElem
-    = val:(rollupSpec / ref)
-    { (SELECT.groupBy || (SELECT.groupBy = [])).push(val) }
+    = c:(rollupSpec / ref) { return c }
   rollupSpec // TODO fix this + add CAP support
     = rollup:("rollup" OPEN o ('$all' / ref) (o COMMA ref)+ o CLOSE) {const err = new Error("Rollup in groupby is not supported yet.");err.statusCode=501;throw err;}
 
-  filterTrafo = OPEN o filter o CLOSE
-
-  countTrafo
-    = trafo:("topcount" / "bottomcount") OPEN o val:number o COMMA o ref:ref o CLOSE
-    {
-      const oredrObj = { ...ref, sort: trafo === 'topcount' ? 'desc' : 'asc' };
-      SELECT.orderBy = SELECT.orderBy ? [...SELECT.orderBy, oredrObj] : [oredrObj];
-      (SELECT.limit || (SELECT.limit={})).rows = {val};
+  filterTrafo = OPEN o (where:filter{
+    let _apply = SELECT.apply
+    if (_apply.where) {
+      SELECT.apply = { apply: _apply }
+      _apply = SELECT.apply
     }
+    _apply.where = where
+  }) o CLOSE
 
 
   // All transformations below need improvment
@@ -471,14 +523,22 @@
       / filterTrafo (o COMMA expandTrafo)*
       ) o CLOSE
 
-  searchTrafo = OPEN o search o CLOSE
+  searchTrafo = OPEN o (search:search{
+    if (!search) return
+    let _apply = SELECT.apply
+    if (_apply.search) {
+      SELECT.apply = { apply: _apply }
+      _apply = SELECT.apply
+    }
+    _apply.search = search
+  }) o CLOSE
 
   concatTrafo = OPEN o apply (o COMMA o apply)+ o CLOSE
 
   computeTrafo = OPEN o computeExpr (o COMMA o computeExpr)* o CLOSE
   computeExpr = where_clause asAlias
 
-  commonFuncTrafo = OPEN o operand o COMMA o operand o CLOSE
+  commonFuncTrafo = OPEN o first:operand o COMMA o second:operand o CLOSE { return [first, second] }
 
   identityTrafo = "identity"
 
@@ -506,18 +566,22 @@
     )?)
 
   number
-    = s:$( [+-]? [0-9]+ ("."[0-9]+)? ("e"[0-9]+)? )
-    {return safeNumber(s)}
+    = s:$( [+-]? [0-9]+ ("."[0-9]+)? ("e"[0-9]+)? ) {return safeNumber(s)}
 
   integer
-    = s:$( [+-]? [0-9]+ )
-    {return parseInt(s)}
+    = s:$( [+-]? [0-9]+ ) {return parseInt(s)}
 
   identifier
     = !bool !guid s:$([_a-zA-Z][_a-zA-Z0-9"."]*) {return s}
 
-  guid = val:$([0-9a-zA-Z]+ "-" ([0-9a-zA-Z]+ "-"?)+)
-    {return {val}}
+  guid
+    = $(hex16 hex16 "-"? hex16 "-"? hex16 "-"? hex16 "-"? hex16 hex16 hex16)
+
+  hex16
+    = $([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])
+
+  segment
+    = val:$([a-zA-Z0-9-"."_~!$&'()*+,;=:@]+){return {val}}
 
 //
 // ---------- Punctuation ----------

package/libx/odata/index.js

@@ -1,10 +1,10 @@
 const cds = require('../_runtime/cds')
 const { SELECT } = cds.ql
 
-const odata2cqn = require('./odata2cqn')
+const odata2cqn = require('./parser').parse
 const cqn2odata = require('./cqn2odata')
 
-const afterburner = require('./odata2cqn/afterburner')
+const afterburner = require('./afterburner')
 const { getSafeNumber: safeNumber } = require('./utils')
 
 const strict = {
@@ -30,6 +30,18 @@ const strict = {
   }
 }
 
+const _2query = cqn => {
+  if (cqn.SELECT.from.SELECT) cqn.SELECT.from = _2query(cqn.SELECT.from)
+  const query = cqn.SELECT.one ? SELECT.one(cqn.SELECT.from) : SELECT.from(cqn.SELECT.from)
+  for (const prop in cqn.SELECT) {
+    if (prop === 'from') continue
+    // explicitly use cds.ql to get '_includes_or__' magic for cqn.SELECT.where containing 'or'
+    if (prop === 'where' || prop === 'having') query[prop](cqn.SELECT[prop])
+    else query.SELECT[prop] = cqn.SELECT[prop]
+  }
+  return query
+}
+
 /*
  * cds.odata API
  */
@@ -39,6 +51,7 @@ module.exports = {
     if (url.url) url = url.url
     // REVISIT: for okra, remove when no longer needed
     else if (url.getIncomingRequest) url = url.getIncomingRequest().url
+
     url = decodeURIComponent(url)
 
     options = options === 'strict' ? { strict } : options.strict ? { ...options, strict } : options
@@ -48,25 +61,15 @@ module.exports = {
     let cqn
     try {
       cqn = odata2cqn(url, options)
-    } catch (e) {
-      // REVISIT: additional try in catch isn't nice -> find better way
-      // known gaps -> e.message is a stringified error -> use that
-      // unknown errors -> e is the error to keep
-      let err = e
-      try {
-        err = JSON.parse(e.message)
-      } catch {
-        /* nothing to do */
-      }
+    } catch (err) {
       err.message = 'Parsing URL failed with error: ' + err.message
       err.statusCode = err.statusCode || 400
       throw err
     }
 
-    if (typeof options.afterburner === 'function') cqn = options.afterburner(cqn)
+    if (options.afterburner) cqn = options.afterburner(cqn)
 
-    const query = cqn.SELECT.one ? SELECT.one(cqn.SELECT.from) : SELECT.from(cqn.SELECT.from)
-    Object.assign(query.SELECT, cqn.SELECT)
+    const query = _2query(cqn)
 
     // REVISIT: _target vs __target, i.e., pseudo csn vs actual csn
     // DO NOT USE __target outside of libx/rest!!!