@sap/cds 5.9.8 → 6.0.3

package/libx/odata/grammar.pegjs

@@ -32,19 +32,21 @@
     const stack = []
     let SELECT, count
     const TECHNICAL_OPTS = ['$value'] // odata parts to be handled somewhere else
-
     // we keep that here to allow for usage in https://pegjs.org/online
-    const safeNumber = options.safeNumber || function (str) {
-      const n = Number(str)
-      return Number.isSafeInteger(n) ? n : str
-    }
-    const standardBase64 = options.standardBase64 || function (str) {
-      // convert url-safe to standard base64 (with padding, if necessary)
-      str = str.replace(/_/g, '/').replace(/-/g, '+')
-      return str.padEnd(str.length + str.length % 4, '=')
-    }
-
-    const _compareRefs = col => exp => col === exp ||
+    const safeNumber =
+      options.safeNumber ||
+      function (str) {
+        const n = Number(str)
+        return Number.isSafeInteger(n) ? n : str
+      }
+    const standardBase64 =
+      options.standardBase64 ||
+      function (str) {
+        // convert url-safe to standard base64 (with padding, if necessary)
+        return Buffer.from(str, 'base64').toString('base64')
+      }
+    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(''))
@@ -78,35 +80,80 @@
       }
     }
     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 } }
-      }
-      if (apply.where) {
-        if (cqn.where) cqn.from.SELECT.where = apply.where
-        else cqn.where = apply.where
-      }
-      if (apply.search) {
-        if (cqn.search) cqn.from.SELECT.search = apply.search
-        else cqn.search = apply.search
-      }
-      if (apply.groupBy) {
-        cqn.groupBy = []
-        for (const col of apply.groupBy) {
-          if (!cqn.groupBy.find(_compareRefs(col))) cqn.groupBy.push(col)
+      let newCqn = _convertApply({ from: cqn.from }, apply, onlyColumnsFromExpand)
+      if (Array.isArray(newCqn)) {
+        for (let i = 0; i < newCqn.length; i++) {
+          newCqn[i] = _addNormalQueryOptions(newCqn[i], cqn, onlyColumnsFromExpand)
         }
+      } else newCqn = _addNormalQueryOptions(newCqn, cqn, onlyColumnsFromExpand)
+
+      return newCqn
+    }
+    const _addNormalQueryOptions = (cqn, topCqn, onlyColumnsFromExpand) => {
+      if (!topCqn) return cqn
+      if (topCqn.apply) delete topCqn.apply
+      let newCqn = {}
+      if (
+        (topCqn.columns && topCqn.columns[0].as === '$count') ||
+        (cqn.SELECT.where && topCqn.where) ||
+        (cqn.SELECT.limit && topCqn.limit) ||
+        (cqn.SELECT.orderBy && topCqn.orderBy) ||
+        (cqn.SELECT.search && topCqn.search)
+      ) {
+        newCqn.from = cqn
+      } else newCqn = cqn.SELECT
+      for (const queryOption in topCqn) {
+        if (queryOption === 'columns') {
+          topCqn.columns = topCqn.columns.map(topCol => {
+            if (newCqn.columns)
+              return (
+                newCqn.columns.find(
+                  col =>
+                    (topCol.ref && topCol.ref[0] === col.as) ||
+                    (col.ref && topCol.ref && topCol.ref[0] === col.ref[0] && !topCol.expand)
+                ) || topCol
+              )
+            return topCol
+          })
+          if (newCqn.columns && newCqn.groupBy)
+            topCqn.columns.push(
+              ...(newCqn.columns.filter(
+                col =>
+                  onlyColumnsFromExpand &&
+                  newCqn.groupBy.find(group => col.ref && col.ref[0] === group.ref[0]) &&
+                  !topCqn.columns.some(
+                    topCol =>
+                      (topCol.ref && topCol.ref[0] === col.as) ||
+                      (topCol.ref && col.ref && topCol.ref[0] === col.ref[0]) ||
+                      (topCol.as && topCol.as === col.as)
+                  )
+              ) || [])
+            )
+          newCqn.columns = topCqn.columns
+        } else if (queryOption !== 'from') newCqn[queryOption] = topCqn[queryOption]
       }
-      const aggregatedColumns = [...(cqn.groupBy || []), ...(apply.aggregate || [])]
+      const aggregatedColumns = [
+        ...((newCqn.columns &&
+          newCqn.columns.filter(
+            col => newCqn.groupBy && newCqn.groupBy.find(group => col.ref && col.ref[0] === group.ref[0])
+          )) ||
+          []),
+        ...((newCqn.columns && newCqn.columns.filter(col => col && typeof col === 'object' && 'func' in col)) || [])
+      ]
+      _handleAggregatedColumns(newCqn, aggregatedColumns, onlyColumnsFromExpand)
+      return { SELECT: newCqn }
+    }
+    const _handleAggregatedColumns = (cqn, aggregatedColumns, onlyColumnsFromExpand) => {
       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
+        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) {
@@ -122,22 +169,72 @@
           return columns
         }, [])
       }
-      if (apply.apply) _handleApply(cqn.from.SELECT, apply.apply)
+    }
+    const _convertApply = (cqn, apply, onlyColumnsFromExpand) => {
+      if (!apply) return
+      if (cqn.apply) delete cqn.apply
+      if (apply.identity && cqn.from.SELECT) cqn = cqn.from.SELECT
+      if (
+        apply.apply ||
+        (apply.where && cqn.where) ||
+        (apply.search && cqn.search) ||
+        (apply.limit && cqn.limit) ||
+        (apply.orderBy && cqn.orderBy)
+      ) {
+        cqn.from = { SELECT: { ...cqn } }
+      }
+      if (apply.where) cqn.where = apply.where
+      if (apply.search) cqn.search = apply.search
+      if (apply.groupBy) {
+        cqn.groupBy = []
+        for (const col of apply.groupBy) {
+          if (!cqn.groupBy.find(_compareRefs(col))) cqn.groupBy.push(col)
+        }
+      }
+      if (apply.limit) cqn.limit = apply.limit
+      if (apply.orderBy) cqn.orderBy = apply.orderBy
+      const aggregatedColumns = [...(cqn.groupBy || []), ...(apply.aggregate || [])]
+      _handleAggregatedColumns(cqn, aggregatedColumns, onlyColumnsFromExpand)
+      
+      if (apply.apply && cqn.from) _convertApply(cqn.from.SELECT, apply.apply)
+      
+      if (apply.concat && Array.isArray(apply.concat)) {
+        const additionalQueries = []
+        for (let select of apply.concat) {
+          select.from =
+            Object.keys(cqn).length === 1
+              ? cqn.from
+              : { SELECT: cqn } 
+          const nextCqn = _convertApply(select, select.apply)
+          if (Array.isArray(nextCqn)) additionalQueries.push(...nextCqn)
+          else additionalQueries.push(nextCqn)
+        }
+        cqn = additionalQueries
+      }
+      
+      if (Array.isArray(cqn)) return cqn
+      return { SELECT: cqn }
     }
     const _setLimitOffset = val => {
       if (SELECT.limit && SELECT.limit.offset && SELECT.limit.offset.val) {
         val += SELECT.limit.offset.val
       }
-      (SELECT.limit || (SELECT.limit={})).offset = {val}
+      ;(SELECT.limit || (SELECT.limit = {})).offset = { val }
+    }
+    //Second parameter needed, to assure that order is correct
+    const _setOrderBy = (appendObj, first = false) => {
+      SELECT.orderBy = SELECT.orderBy
+        ? first
+          ? [appendObj, ...SELECT.orderBy]
+          : [...SELECT.orderBy, appendObj]
+        : [appendObj]
     }
-
     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)
       }
-
       return elements
     }
   }
@@ -146,7 +243,7 @@
 
   ODataRelativeURI // Note: case-sensitive!
     = '/'? (p:path { SELECT = p })
-    ( o"?"o QueryOption ( o'&'o QueryOption )* )? o {
+    ( o"?"o QueryOption ( o'&'o QueryOption )* )? o "?"? o {
       if (count) {
         // columns set because of $count: ignore $select, $expand, $top, $skip, $orderby
         // REVISIT: don't ignore query options but throw bad request (as okra did)?
@@ -154,10 +251,8 @@
         delete SELECT.expand
         delete SELECT.limit
         delete SELECT.orderBy
-        if (SELECT.apply) {
-          SELECT.apply = { apply: SELECT.apply }
-          _handleApply(SELECT, SELECT.apply)
-        }
+        if (SELECT.apply)
+          return _handleApply(SELECT, SELECT.apply)
         return { SELECT }
       }
       let onlyColumnsFromExpand
@@ -174,8 +269,10 @@
         }
         delete SELECT.expand
       }
-      if (SELECT.count && SELECT.apply) SELECT.__countAggregated = true
-      _handleApply(SELECT, SELECT.apply, onlyColumnsFromExpand)
+      if (SELECT.count && SELECT.apply) 
+        SELECT.__countAggregated = true
+      if(SELECT.apply)
+        return _handleApply(SELECT, SELECT.apply, onlyColumnsFromExpand)
       return { SELECT }
     }
 
@@ -192,7 +289,6 @@
         tail.from.ref.unshift('')
         return tail
       } 
-
       const [id, filter] = head
       // minimal: val also as path segment
       const ref = []
@@ -235,23 +331,22 @@
 //
 // ---------- Query Options ------------
 
-  QueryOption = ExpandOption /
+  QueryOption = option:ExpandOption { if(option && option.apply) SELECT.apply = option.apply} /
     "$skiptoken="   o skiptoken /
-    "$apply="       (o{
-      SELECT.apply = {}
-    }) apply /
+    format /
     custom
   // @OData spec for $expand:
-  // "Allowed system query options are $filter, $select, $orderby, $skip, $top, $count, $search, and $expand."
+  // "Allowed system query options are $filter, $select, $orderby, $skip, $top, $count, $search, $expand and $apply (http://docs.oasis-open.org/odata/odata-data-aggregation-ext/v4.0/cs02/odata-data-aggregation-ext-v4.0-cs02.html#_The_expand_Transformation)."
   ExpandOption =
     "$select="      o select ( COMMA select )* /
     "$expand="      o expand ( COMMA expand )* /
     "$filter="      o f:filter{SELECT.where = f} /
-    "$orderby="     o orderby ( COMMA orderby )* /
-    "$top="         o top /
-    "$skip="        o skip /
+    "$orderby="     o o:orderby ( COMMA o2:orderby{_setOrderBy(o2)} )* {_setOrderBy(o,true)} /
+    "$top="         o val:top{(SELECT.limit || (SELECT.limit={})).rows = {val}} /
+    "$skip="        o val:skip{_setLimitOffset(val)} /
     "$search="      o s:search {if (s) SELECT.search = s} /
-    "$count="       o count
+    "$count="       o count /
+    "$apply="       o trafos:transformations {return trafos}
 
 
   select
@@ -261,6 +356,7 @@
       return col
     }
 
+//REVISIT: per OData spec $apply should be also supported inside of $expand
   expand =
     (
       c:('*'/ref) {
@@ -277,8 +373,13 @@
         SELECT = SELECT.expand[SELECT.expand.length-1]
         SELECT.expand = '*' // by default expand everything
       })(
-      expandOptions:( o ";"? o ExpandOption)*
+      expandOptions:( o ";"? o option:ExpandOption{return option})*
       {
+      	if (expandOptions.find(option => option && option.apply !== undefined)) {
+        	const err = new Error("EXPAND_APPLY_UNSUPPORTED");
+      		err.statusCode=501;
+      		throw err;
+        }
         if (SELECT.columns) {
           if (SELECT.expand === '*') SELECT.expand = []
           for (const col of SELECT.columns) {
@@ -299,28 +400,19 @@
       err.statusCode=501;
       throw err;
     })?
-
   top
-    = val:integer {
-      (SELECT.limit || (SELECT.limit={})).rows = {val}
-    }
-
+    = val:integer {return val}
   skiptoken
     = val:integer? skiptoken:skiptokenChars? {
       // REVISIT ignore non-numeric $skiptoken as not supported by CQN
       if (skiptoken) return
       _setLimitOffset(val)
     }
-
   skip
-    = val:integer {
-      _setLimitOffset(val)
-    }
-
+    = val:integer {return val}
   search
     = p:search_clause {return p}
       / o // Do not add search property for space only
-
   search_clause
     = p:( n:NOT? {return n?[n]:[]} )(
       OPEN xpr:search_clause CLOSE {p.push({xpr})}
@@ -331,10 +423,8 @@
         )
     )( ao:(AND/OR/AND_SPACE) more:search_clause {p.push(ao,...more)} )*
     {return p}
-
   filter
     = p:where_clause { return p }
-
   where_clause = p:( n:NOT? {return n?[n]:[]} )(
       OPEN xpr:where_clause CLOSE {p.push({xpr})}
       / comp:comparison {p.push(...comp)}
@@ -349,7 +439,6 @@
       / val:bool {p.push({val})}
     )( ao:(AND/OR) more:where_clause {p.push(ao,...more)} )*
     {return p}
-
   lambda =
     nav:( n:identifier {return[n]} ) '/' ( n:identifier '/' {nav.push(n)} )*
     xpr:(
@@ -365,7 +454,6 @@
             xpr[k++] = each
           }
         }
-
         if (xpr.length < any.length) {
           id = nav.pop()
           return ['exists', { ref: [...nav, { id, where: xpr }] }]
@@ -379,7 +467,6 @@
       }
     )
     { return xpr }
-
   inner_lambda =
     p:( n:NOT? { return n ? [n] : [] } )(
       OPEN xpr:inner_lambda CLOSE { p.push('(', ...xpr, ')') }
@@ -389,48 +476,72 @@
     )
     ( ao:(AND/OR) more:inner_lambda { p.push(ao, ...more) } )*
     { return p }
-
   lambda_clause = prefix:identifier ":" inner:inner_lambda {
     return _removeLambdaPrefix(prefix, inner)
   }
-
   any = "any" OPEN p:lambda_clause? CLOSE { return p }
-
   all = "all" OPEN p:lambda_clause CLOSE { return p }
-
   orderby
     = ref:(lambda{const err = new Error("ORDERBY_LAMBDA_UNSUPPORTED");err.statusCode=501;throw err;}/function/ref) sort:( _ s:$("asc"/"desc") {return s})? {
         // TODO: Lambda support
         const appendObj = $(ref, sort && {sort});
-        SELECT.orderBy = SELECT.orderBy ?
-          [...SELECT.orderBy, appendObj] :
-          [appendObj]
+        return appendObj;
     }
-
   count
     = val:bool { if(val) SELECT.count = true }
+  transformations
+    = mainTransformation:trafo additionalTransformation:("/" t2:trafo {
+      return t2
+    })* {
+    	if(mainTransformation === undefined) return
+      additionalTransformation = (Array.isArray(additionalTransformation)) ? additionalTransformation : [additionalTransformation] 
+      //Loop through additionalTransformation
+      //Loop through each element, add it to current level, if element is already part of result, increase level
+      for(let trafos of additionalTransformation) {
+        for(const trafo in trafos) {
+          if (trafo === 'limit' && trafos.limit && mainTransformation.limit && mainTransformation.limit.offset && trafos.limit.rows)
+            mainTransformation.limit.rows = trafos.limit.rows
+          else if(
+          	mainTransformation[trafo] || 
+            (trafo === 'groupBy' && (mainTransformation.where || mainTransformation.search)) || 
+            (trafo === 'aggregate' && 'groupBy' in mainTransformation && !('groupBy' in trafos))
+          ) {
+            let _apply = mainTransformation
+            mainTransformation = { apply: _apply } 
+            if (trafo === 'limit' && trafos[trafo].offset && _apply.limit && _apply.limit.offset && _apply.limit.offset.val)
+              trafos[trafo].offset += _apply.limit.offset.val
+            
+            _apply = mainTransformation
+            _apply[trafo] = trafos[trafo]
+          } else {
+            mainTransformation[trafo] = trafos[trafo]
+          }
+        }
+      }
+      return {apply: mainTransformation}
+    }
 
-  apply
-    = applyTrafo ("/" applyTrafo)*
-
-  custom = [a-zA-Z] [a-zA-Z0-9-]* "=" [^&]*
+  custom
+    = [a-zA-Z0-9-_.~]+ "=" [^&]*
 
+  format = "$format=" f:$([^&]*) {
+    if (f.toLowerCase() !== "json") {
+      const err = new Error("ONLY_QUERY_PARAM_FORMAT_JSON_ALLOWED")
+      err.statusCode = 501
+      throw err;
+    }
+  }
 //
 // ---------- Expressions ------------
-
-
   comparison "a comparison"
     = a:operand _ o:$("eq"/"ne"/"lt"/"gt"/"le"/"ge") _ b:operand {
       const op = { eq:'=', ne:'!=', lt:'<', gt:'>', le:'<=', ge:'>=' }[o]||o
       return [ a, op, b ]
     }
-
   mathCalc
     = operand (_ ("add" / "sub" / "mul" / "div" / "mod") _ operand)*
-
   operand "an operand"
     = navigationCount / function / val / ref / jsonObject / jsonArray / list
-
   navigationCount "navigation with $count"
   = navigationPath:(head:identifier key:(OPEN keyArgs:args CLOSE {return keyArgs;})? '/' {
     if (key) {
@@ -440,26 +551,21 @@
     return head;
   })+ count: '$count'
     { return {func: 'count', as: '$count', args: [{ref: navigationPath}]} }
-
   ref "a reference"
     = head:identifier tail:( '/' n:identifier {return n})*
     {
       if (head === "null") {
         return { val: null }
       }
-
       return { ref:[ head, ...tail ] }
     }
-
   val
     = val:(bool / date) {return {val}}
     / val:guid {return {val}}
     / val:number {return typeof val === 'number' ? {val} : { val, literal:'number' }}
     / val:string {return {val}}
     / val:binary {return {val}}
-
   jsonObject = val:$("{" (jsonObject / [^}])* "}") {return {val}}
-
   jsonArray = val:$("[" o "]" / "[" o "{" (jsonArray / [^\]])* "]") {return {val}}
 
   list
@@ -486,19 +592,21 @@
 
 //
 // ---------- Transformations ------------
+// Odata spec: http://docs.oasis-open.org/odata/odata-data-aggregation-ext/v4.0/odata-data-aggregation-ext-v4.0.html
 
-  applyTrafo
+  trafo
     = (
-      "aggregate" aggregateTrafo /
-      "groupby" groupbyTrafo /
-      "filter" filterTrafo /
+      "aggregate" agg:aggregateTrafo{return agg} /
+      "groupby" group:groupbyTrafo{return group} /
+      "filter" filter:filterTrafo{return filter} /
 
       // REVISIT: All transformations below need improvment
-      // and should supported by CAP
-      "expand" expandTrafo /
-      "search" searchTrafo /
-      "concat" concatTrafo /
-      "compute" computeTrafo /
+      "search" search:searchTrafo{return search} /
+      "concat" con:concatTrafo{return con} / //Return con so that concat string is not returned
+      "compute" compute:computeTrafo{return compute} /
+      "top" top:topTrafo{return top} /
+      "skip" skip:skipTrafo{return skip} /
+      "orderby" order:orderbyTrafo{return order} /
       func:("topcount"i/"bottomcount"i/"topsum"i/"bottomsum"i/"toppercent"i/"bottompercent"i) args:commonFuncTrafo {
         const SUPPORTED_APPLY_TRANSFORMATIONS = {
           "topcount": true,
@@ -510,23 +618,18 @@
         }
         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 })
+          throw Object.assign(new Error(`Transformation "${func}" in $apply is not yet supported.`), { statusCode: 501 })
+        }        
+        return {aggregate: [{ func, args }]}
       } /
-      identityTrafo
+      identity: identityTrafo{return identity}
       // customFunction
     )
 
   aggregateTrafo
     = 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]
+      let response = {aggregate: [head,...tail]}
+      return response
     }
   aggregateItem
     = res:("$count" as:asAlias { return { func: 'count', args: [{ val: 1 }], as } }
@@ -537,7 +640,7 @@
         ref
      // / mathCalc - needs CAP support
       )
-      func:aggregateWith aggregateFrom? as:asAlias
+      func:aggregateWith? aggregateFrom? as:asAlias?
         { return { func, args: [ path ], as } }
       / identifier OPEN aggregateExpr CLOSE // needs CAP support
    // / customAggregate // needs CAP support
@@ -550,57 +653,57 @@
 
   groupbyTrafo
     = 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
+      
+      return { groupBy: [head, ...tail] }
+    }) trafos:(COMMA t:transformations {return t})? CLOSE {
+    	  let apply = {}
+        apply = (trafos) ? {groupBy: [head, ...tail], ...trafos.apply} : {groupBy: [head, ...tail]} 
+        return apply
+    }
   groupByElem
     = 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 (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
-  // and should supported by CAP
-  expandTrafo
-    = OPEN o ref o COMMA o
-      ( expandTrafo (o COMMA expandTrafo)*
-      / filterTrafo (o COMMA expandTrafo)*
-      ) o CLOSE
+  filterTrafo = OPEN o where:(where:filter{
+    return where
+  }) o CLOSE {
+  	return {where: where}
+  }
 
-  searchTrafo = OPEN o (search:search{
+  searchTrafo = OPEN o search:(search:search{
     if (!search) return
-    let _apply = SELECT.apply
-    if (_apply.search) {
-      SELECT.apply = { apply: _apply }
-      _apply = SELECT.apply
-    }
-    _apply.search = search
-  }) o CLOSE
+    return search
+  }) o CLOSE {
+    return {search: search}
+  }
 
-  concatTrafo = OPEN o apply (o COMMA o apply)+ o CLOSE
+  concatTrafo = OPEN o trafo1:transformations trafo2:(o COMMA o trafos:transformations{ return trafos })+ o CLOSE {
+    return {concat: [trafo1, ...trafo2]}
+  }
 
-  computeTrafo = OPEN o computeExpr (o COMMA o computeExpr)* o CLOSE
+  computeTrafo = OPEN o computeExpr (o COMMA o computeExpr)* o CLOSE //REVISIT: support compute - current implementation is deviating from odata
 
   computeExpr = where_clause asAlias
 
   commonFuncTrafo = OPEN o first:operand o COMMA o second:operand o CLOSE { return [first, second] }
 
-  identityTrafo = "identity"
+  identityTrafo = "identity" {return {identity: true }} //REVISIT: support identity
 
+  topTrafo
+    = OPEN o val:top o CLOSE {
+      return {limit: {rows: {val}}}
+    }
+
+  skipTrafo
+    = OPEN o val:skip o CLOSE {
+      return {limit: {offset: {val}}}
+    }
 
+  orderbyTrafo
+    = OPEN o o:orderby o2:( COMMA o2:orderby{return o2} )* o CLOSE {
+      return {orderBy: [o,...o2]}
+    }
 //
 // ---------- Literals -----------
 
@@ -621,7 +724,11 @@
     = s:$( [0-9]+"-"[0-9][0-9]"-"[0-9][0-9] // date
       ( "T"[0-9][0-9]":"[0-9][0-9](":"[0-9][0-9]("."[0-9]+)?)? // time
       ( "Z" / (("+" / "-")[0-9][0-9]":"[0-9][0-9]) )? // timezone (Z or +-hh:mm)
-    )?)
+    )?) {
+      if (s.split('-')[0].length > 4)
+        throw Object.assign(new Error(`The type 'Edm.DateTimeOffset' is not compatible with '${s}'`), { statusCode: 400 })
+      return s
+    }
 
   number
     = s:$( [+-]? [0-9]+ ("."[0-9]+)? ("e"[0-9]+)? ) { return safeNumber(s) }
@@ -663,4 +770,4 @@
   _ "mandatory whitespaces" = $[ \t\n]+
 
 //
-// ------------------------------------
+// ------------------------------------