@sap/cds 5.6.4 → 5.7.4

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,94 +39,101 @@
       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 _setLimitOffset = val => {
+      if (SELECT.limit && SELECT.limit.offset && SELECT.limit.offset.val) {
+        val += SELECT.limit.offset.val
+      }
+      (SELECT.limit || (SELECT.limit={})).offset = {val}
     }
 
-    const _compareRefs = col => exp => col === exp ||
-      (col.as && exp.as && col.as === exp.as) ||
-      (col.ref && exp.ref && col.ref.join('') === exp.ref.join(''))
-
-    const _getMergedPath = (head, filter, segment) => {
-      if (!head) head = ''
-      if (filter) {
-        head += filter.reduce((acc, cur) => {
-          for (const c of cur) {
-            if (typeof c === 'string') acc += c
-            else acc += c.val ? typeof c.val === 'string' ? `'${c.val}'` : c.val : c.ref[0]
-          }
-          return acc
-        }, '')
-        filter = undefined
+    const _removeLambdaPrefix = (prefix, elements) => {
+      for (const e of elements) {
+        // remove the prefix identifier
+        if (e.ref && e.ref[0] === prefix) e.ref.shift()
+        if (e.func) _removeLambdaPrefix(prefix, e.args)
       }
-      head += segment
-      return [head, filter, segment]
+
+      return elements
     }
   }
 
@@ -145,11 +149,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)
@@ -157,24 +169,26 @@
         }
         delete SELECT.expand
       }
-      SELECT = correctAggAwayColumns(SELECT)
-
+      if (SELECT.count && SELECT.apply) SELECT.__countAggregated = true
+      _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)? segment:(segment)? tail:( '/' p:path {return p} )? {
-      // OData vs. REST style
-      if (segment) [head, filter, segment] = _getMergedPath(head, filter, segment)
+    / 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
@@ -188,7 +202,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
@@ -197,19 +211,23 @@
 //
 // ---------- Query Options ------------
 
-  QueryOption = ExpandOption
+  QueryOption = ExpandOption /
+    "$skiptoken="   o skiptoken /
+    "$apply="       (o{
+      SELECT.apply = {}
+    }) apply /
+    custom
+  // @OData spec for $expand:
+  // "Allowed system query options are $filter, $select, $orderby, $skip, $top, $count, $search, and $expand."
   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 /
-    "$skiptoken="   o skip /
-    "$search="      o search /
-    "$count="       o count /
-    "$apply="       o apply /
-    custom
+    "$search="      o s:search {if (s) SELECT.search = s} /
+    "$count="       o count
 
 
   select
@@ -252,22 +270,32 @@
       })
     )? // --- end of nested query options
     ( COMMA expand )?
+    ("/$count" {
+      const err = new Error("EXPAND_COUNT_UNSUPPORTED");
+      err.statusCode=501;
+      throw err;
+    })?
 
   top
     = val:integer {
       (SELECT.limit || (SELECT.limit={})).rows = {val}
     }
 
+  skiptoken
+    = val:integer? skiptoken:skiptokenChars? {
+      // REVISIT ignore non-numeric $skiptoken as not supported by CQN
+      if (skiptoken) return
+      _setLimitOffset(val)
+    }
+
   skip
     = val:integer {
-      if (SELECT.limit && SELECT.limit.offset && SELECT.limit.offset.val) {
-        val += SELECT.limit.offset.val
-      }
-      (SELECT.limit || (SELECT.limit={})).offset = {val}
+      _setLimitOffset(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]:[]} )(
@@ -281,7 +309,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})}
@@ -326,18 +354,14 @@
     p:( n:NOT? { return n ? [n] : [] } )(
       OPEN xpr:inner_lambda CLOSE { p.push('(', ...xpr, ')') }
       / comp:comparison { p.push(...comp) }
+      / func:function { p.push(func) }
       / lambda:lambda { p.push(...lambda)}
     )
     ( ao:(AND/OR) more:inner_lambda { p.push(ao, ...more) } )*
     { return p }
 
   lambda_clause = prefix:identifier ":" inner:inner_lambda {
-    for (const e of inner) {
-      // remove the prefix identifier
-      if (e.ref && e.ref[0] === prefix) e.ref.shift()
-    }
-
-    return inner
+    return _removeLambdaPrefix(prefix, inner)
   }
 
   any = "any" OPEN p:lambda_clause? CLOSE { return p }
@@ -374,7 +398,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})*
@@ -388,7 +422,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}}
 
@@ -401,14 +435,16 @@
     { return { list: any.replace(/"/g,'').split(',').map(ele => ({ val: ele })) } }
 
   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)")
-      return { func, args:[a,...more] }
+    = func:$[a-zA-Z]+ OPEN a:operand more:( COMMA o:operand {return o} )* CLOSE {
+      if (strict && !(func.toLowerCase() in strict.functions)) {
+        throw Object.assign(new Error(`"${func}" is an unknown function in OData URL spec (strict mode)`), { statusCode: 400 })
+      }
+      return { func: func.toLowerCase(), args:[a,...more] }
     }
 
   boolish "a boolean function"
-    = func:("contains"/"endswith"/"startswith") OPEN a:operand COMMA b:operand CLOSE
-    { return { func, args:[a,b] }}
+    = func:("contains"i/"endswith"i/"startswith"i) OPEN a:operand COMMA b:operand CLOSE
+    { return { func: func.toLowerCase(), args:[a,b] }}
 
   NOT = o "NOT"i _ {return 'not'}
   AND = _ "AND"i _ {return 'and'}
@@ -424,7 +460,6 @@
       "aggregate" aggregateTrafo /
       "groupby" groupbyTrafo /
       "filter" filterTrafo /
-      countTrafo /
 
       // REVISIT: All transformations below need improvment
       // and should supported by CAP
@@ -432,57 +467,77 @@
       "search" searchTrafo /
       "concat" concatTrafo /
       "compute" computeTrafo /
-      "bottompercent" commonFuncTrafo /
-      "bottomsum" commonFuncTrafo /
-      "toppercent" commonFuncTrafo /
-      "topsum" commonFuncTrafo /
+      func:("topcount"i/"bottomcount"i/"topsum"i/"bottomsum"i/"toppercent"i/"bottompercent"i) args:commonFuncTrafo {
+        const SUPPORTED_APPLY_TRANSFORMATIONS = {
+          "topcount": true,
+          "bottomcount": true,
+          "topsum": false,
+          "bottomsum": false,
+          "toppercent": false,
+          "bottompercent": false
+        }
+        func = func.toLowerCase()
+        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
-    = _ "with" _ func:$[a-z]+ { return func; }
+    = _ "with" _ func:$[a-zA-Z]+ { return func.toLowerCase(); }
   aggregateFrom
     = _ "from" _ ref aggregateWith aggregateFrom? // needs CAP support
   asAlias
     = _ "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
@@ -493,14 +548,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"
 
@@ -537,10 +600,16 @@
     = !bool !guid s:$([_a-zA-Z][_a-zA-Z0-9"."]*) {return s}
 
   guid
-    = val:$([0-9a-zA-Z]+ "-" ([0-9a-zA-Z]+ "-"?)+) {return {val}}
+    = $(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
-    = s:$([a-zA-Z0-9-"."_~!$&'()*+,;=:@]+)
+    = val:$([a-zA-Z0-9-"."_~!$&'()*+,;=:@]+){return {val}}
+
+  skiptokenChars
+    = $([a-zA-Z0-9-"."_~!$'()*+,;=:@"/""?"]+)
 
 //
 // ---------- Punctuation ----------

package/libx/odata/index.js

@@ -1,11 +1,12 @@
 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 getError = require('../_runtime/common/error')
 
 const strict = {
   functions: {
@@ -30,6 +31,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
  */
@@ -49,16 +62,12 @@ 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) {
+      if (err.message === 'EXPAND_COUNT_UNSUPPORTED') {
+        throw getError(err.statusCode || 400, err.message)
       }
+
+      // TODO adjust this to behave like above
       err.message = 'Parsing URL failed with error: ' + err.message
       err.statusCode = err.statusCode || 400
       throw err
@@ -66,8 +75,7 @@ module.exports = {
 
     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!!!