@sap/cds 5.5.5 → 5.6.0

package/libx/odata/odata2cqn/afterburner.js

@@ -0,0 +1,170 @@
+const cds = require('../../_runtime/cds')
+
+const { where2obj } = require('../../_runtime/common/utils/cqn')
+const { findCsnTargetFor } = require('../../_runtime/common/utils/csn')
+
+function _keysOf(entity) {
+  return entity && entity.keys
+    ? Object.keys(entity.keys).filter(
+        k => entity.elements[k].type !== 'cds.Association' && entity.elements[k]['@odata.foreignKey4'] !== 'up_'
+      )
+    : []
+}
+
+function _getDefinition(definition, name) {
+  return (
+    (definition.definitions && definition.definitions[name]) ||
+    (definition.elements && definition.elements[name]) ||
+    (definition.actions && definition.actions[name]) ||
+    definition[name]
+  )
+}
+
+function _resolveAliasInWhere(where, entity) {
+  if (!entity._alias2ref) return
+  for (let i = 0; i < where.length; i++) {
+    if (!where[i].ref || where[i].ref.length > 1 || entity.keys[where[i].ref[0]]) continue
+    where[i].ref = entity._alias2ref[where[i].ref[0]] || where[i].ref
+  }
+}
+
+// case: single key without name, e.g., Foo(1)
+function _addRefToWhereIfNecessary(where, entity) {
+  if (!where || where.length !== 1) return 0
+  const keys = _keysOf(entity)
+  if (keys.length !== 1) return 0
+  where.unshift(...[{ ref: [keys[0]] }, '='])
+  return 1
+}
+
+function _processSegments(cqn, model) {
+  const { ref } = cqn.SELECT.from
+
+  let current = model
+  let path
+  let keys = null
+  let keyCount = 0
+  let incompleteKeys
+  let one
+  for (let i = 0; i < ref.length; i++) {
+    const seg = ref[i].id || ref[i]
+    const params = ref[i].where && where2obj(ref[i].where)
+
+    if (incompleteKeys) {
+      // > key
+      keys = keys || _keysOf(current)
+      const key = keys[keyCount++]
+      one = true
+      const element = current.elements[key]
+      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 })
+      ref[i] = null
+      ref[i - keyCount] = base
+      incompleteKeys = keyCount < keys.length
+    } else {
+      // > entity or property (incl. nested) or navigation or action or function
+      keys = null
+      keyCount = 0
+      one = false
+
+      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, '.'))
+      // REVISIT: 404 or 400?
+      if (!current) cds.error(`Invalid resource path "${path}"`, { code: 404 })
+
+      if (current.kind === 'entity') {
+        // > entity
+        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)
+          _resolveAliasInWhere(ref[i].where, current)
+        }
+      } else if ({ action: 1, function: 1 }[current.kind]) {
+        // > action or function
+        if (i !== ref.length - 1) {
+          const msg = `${i ? 'Unbound' : 'Bound'} ${current.kind} are only supported as the last path segment.`
+          throw Object.assign(new Error(msg), { statusCode: 501 })
+        }
+        ref[i] = { operation: current.name }
+        if (params) ref[i].args = params
+        if (current.returns && current.returns.type) one = true
+      } else if (current.isAssociation) {
+        // > navigation
+        one = !!(current.is2one || ref[i].where)
+        incompleteKeys = one || i === ref.length - 1 ? false : true
+        current = model.definitions[current.target]
+        if (ref[i].where) {
+          keyCount += _addRefToWhereIfNecessary(ref[i].where, current)
+          _resolveAliasInWhere(ref[i].where, current)
+        }
+      } else if (current._isStructured) {
+        // > nested property
+        one = true
+        current = current.elements
+      } else {
+        // > property
+        one = true
+      }
+    }
+  }
+
+  if (incompleteKeys) {
+    // > last segment not fully qualified
+    throw Object.assign(
+      new Error(
+        `Entity "${current.name}" has ${_keysOf(current).length} keys. Only ${keyCount} ${
+          keyCount === 1 ? 'was' : 'were'
+        } provided.`
+      ),
+      { status: 400 }
+    )
+  }
+
+  // remove all nulled refs
+  cqn.SELECT.from.ref = ref.filter(r => r)
+
+  // one?
+  if (one) cqn.SELECT.one = true
+
+  // REVISIT: better
+  // set target (csn definition) for later retrieval
+  cqn.__target = current
+}
+
+function _4service(service) {
+  const { namespace, model } = service
+
+  return cqn => {
+    const { ref } = cqn.SELECT.from
+
+    // REVISIT: shouldn't be necessary
+    /*
+     * make first path segment fully qualified
+     */
+    const root = findCsnTargetFor(ref[0].id || ref[0], model, namespace)
+    // REVISIT: 404 or 400?
+    if (!root) cds.error(`Invalid resource path "${namespace}.${ref[0].id || ref[0]}"`, { code: 404 })
+    if (ref[0].id) ref[0].id = root.name
+    else ref[0] = root.name
+
+    /*
+     * key vs. path segments (/Books/1/author/books/2/...) and more
+     */
+    _processSegments(cqn, model)
+
+    return cqn
+  }
+}
+
+const cache = new WeakMap()
+
+module.exports = {
+  for: service => {
+    if (!cache.has(service)) cache.set(service, _4service(service))
+    return cache.get(service)
+  }
+}

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

@@ -24,12 +24,16 @@
  * Books?$select=ID,title&$expand=author($select=name)&$filter=stock gt 1&$orderby=title
  */
 
+//
 // ---------- JavaScript Helpers -------------
   {
-  	const $ = Object.assign
+    const exception = (message, code = 400) => {
+      error(JSON.stringify({ code, message }))
+    }
+    const $ = Object.assign
     const { strict, minimal } = options
-    const stack=[]
-    let SELECT
+    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
@@ -38,71 +42,17 @@
       return Number.isSafeInteger(n) ? n : str
     }
 
-    // check whether we have any
-    // - $select
-    // - aggregate(... as someProp)
-    const hasNOTAny$select = (columns) => {
-      return columns.filter(cur => cur.ref ? !cur.expand : cur.as).length === 0;
-    }
-
-    const adaptColumns = (SELECT) => {
-      const columns = SELECT.columns
-      if (!columns) return SELECT
-
- 	    // when $select and $expand was NOT defined
-      if (!hasNOTAny$select(columns)) {
-        const columnsMap = new Map()
-
-        columns.forEach(column => {
-
-            if (column === '*') {
-              columnsMap.set(column, column)
-              return
-            }
-
-            if (!column.ref) {
-              columnsMap.set(column.as, column)
-              return
-            }
-
-            const columnRefName = column.ref.join('/')
-
-            if (!columnsMap.has(columnRefName) || column.expand) {
-              columnsMap.set(columnRefName, column)
-            }
-        })
-
-        if (columnsMap.size > 0) {
-          SELECT.columns = Array.from(columnsMap.values())
-        }
-
-        return SELECT
-      }
-
-      if (columns.length === 1 && columns[0] === '*') {
-        delete SELECT.columns
-        return SELECT
-      }
-
-      // in case when have $expand but have NOT $select
-      if (!columns.includes('*'))  {
-        SELECT.columns.unshift('*')
-      }
-
-	    return SELECT
-	  }
-
     // NOTe: mutation of the object property, it's NOT a pure function
     const correctAggAwayWhere = (where, colNames) => {
-    	const changedWhere = [...where];
+      const changedWhere = [...where];
 
       for (const item of changedWhere) {
-      	if (item.xpr) {
-        	item.xpr = correctAggAwayWhere(item.xpr, colNames)
+        if (item.xpr) {
+          item.xpr = correctAggAwayWhere(item.xpr, colNames)
         }
 
         if (item.args) {
-        	item.args = correctAggAwayWhere(item.args, colNames)
+          item.args = correctAggAwayWhere(item.args, colNames)
         }
 
         // $filter ohne $apply -> input set = entity -> kein null setzen
@@ -112,7 +62,7 @@
 
         // TODO fix this for $apply
         if(item.ref && !colNames.includes(item.ref.join(''))) {
-        	// item.ref = null;
+          // item.ref = null;
         }
         // REVISIT: { val:null } for should be also implemented
       }
@@ -126,7 +76,7 @@
       const columns = SELECT.columns || [];
       const aggregates = columns.filter((cur) => cur.as);
 
-	    let fromAggregate = [];
+      let fromAggregate = [];
       let fromGroupBy = [];
 
       // handle $apply=aggregate(... as someProp)&$select=someProp,?...
@@ -138,28 +88,33 @@
 
       // handle $apply=groupby((someProp,?...))&$select=?...
       if (groupBy) {
-        const allowedNames = groupBy.map(({ ref }) => ref.join(''));
+        const allowedNames = groupBy.map(({ ref }) => ref && ref.join(''));
         const allowedColumns = columns.filter((cur) =>
-         	cur.ref && allowedNames.includes(cur.ref.join(''))
+           cur.ref && allowedNames.includes(cur.ref.join(''))
         );
         fromGroupBy = allowedColumns.length === 0 ? [...groupBy] : allowedColumns;
       }
 
       const newColumns = fromAggregate.length !== 0 || fromGroupBy.length !== 0
-      	? [...fromGroupBy, ...fromAggregate]
+        ? [...fromGroupBy, ...fromAggregate]
         : SELECT.columns;
 
-      let result = { ...SELECT, columns: newColumns }
+      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);
+        // 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) }
-	    }
+      }
 
       return result;
     }
+
+    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 ---------------
@@ -167,42 +122,49 @@
   ODataRelativeURI // Note: case-sensitive!
     = '/'? (p:path { SELECT = p })
     ( o"?"o QueryOption ( o'&'o QueryOption )* )? o {
-      if (SELECT.columns) {
+      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)? 
+        // REVISIT: don't ignore query options but throw bad request (as okra did)?
+        SELECT.columns = [{ args: [{ val: 1 }], as: '$count', func: 'count' }]
         delete SELECT.expand
         delete SELECT.limit
         delete SELECT.orderBy
         return { SELECT }
       }
       if (SELECT.expand) {
-        SELECT.columns = SELECT.expand
+        // Books?$expand=author w/o $select=author
+        if (!SELECT.columns) SELECT.columns = ['*']
+        for (const exp of SELECT.expand) {
+          const idx = SELECT.columns.findIndex(_compareRefs(exp))
+          if (idx > -1) SELECT.columns.splice(idx, 1)
+          SELECT.columns.push(exp)
+        }
         delete SELECT.expand
       }
-
       SELECT = correctAggAwayColumns(SELECT)
-      SELECT = adaptColumns(SELECT)
-
-      // REVISIT: shouldn't be necessary
-      if (!SELECT.columns) delete SELECT.columns
 
       return { SELECT }
     }
 
   path
-    = "$count" {return {columns:[{args: ["*"], as: "$count", func: "count"}]}}
+    = "$count" {count = true}
     / rv:$("$ref"/"$value") {return !TECHNICAL_OPTS.includes(rv) && {from: {ref: [rv]}}}
-    / head:(identifier/val) filter:(OPEN args CLOSE)? tail:( '/' p:path {return p} )? {
+    / head:(identifier/val) filter:(OPEN CLOSE/OPEN args CLOSE)? tail:( '/' p:path {return p} )? {
       // minimal: val also as path segment
-      const ref = [ filter ? { id:head, where:filter[1] } : (minimal ? `${head.val || head}` : head) ]
-       if (tail && tail.from) {
-      	const more = tail.from.ref, [{val}] = more
-      	if (val) ref[ref.length-1] = { id:ref[ref.length-1], where:[more.shift()] }
-      	ref.push (...more)
+      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 )
+      ]
+      if (tail && tail.from) {
+        const more = tail.from.ref
+        if (Object.prototype.hasOwnProperty.call(more[0], 'val')) ref[ref.length-1] = { id:ref[ref.length-1], where:[more.shift()] }
+        ref.push (...more)
       }
- 
       const res = {from: {ref}}
-      if (tail) res.columns = tail.columns
+      if (tail && tail.columns) res.columns = tail.columns
       return res
     }
 
@@ -214,45 +176,57 @@
       return args
     }
 
- //
+//
 // ---------- Query Options ------------
 
   QueryOption = ExpandOption
   ExpandOption =
-    "$select="  		o select ( COMMA select )* /
-    "$expand="  		o expand ( COMMA expand )* /
-    "$filter="  		o filter /
-    "$orderby=" 		o orderby ( COMMA orderby )* /
-    "$top="     		o top /
-    "$skip="    		o skip /
-    "$search=" 			o search /
-    "$count=" 			o count /
+    "$select="      o select ( COMMA select )* /
+    "$expand="      o expand ( COMMA expand )* /
+    "$filter="      o filter /
+    "$orderby="     o orderby ( COMMA orderby )* /
+    "$top="         o top /
+    "$skip="        o skip /
+    "$search="      o search /
+    "$count="       o count /
     "$apply="       o apply /
     custom
 
 
   select
-    = col:(
-        ref /
-        ('*' { return '*' })
-      ) {
-      SELECT.expand = SELECT.expand || []
-      SELECT.expand.push(col)
+    = col:('*'/ref) {
+      SELECT.columns = Array.isArray(SELECT.columns) ? SELECT.columns : []
+      if (!SELECT.columns.find(_compareRefs(col))) SELECT.columns.push(col)
       return col
     }
 
   expand =
-    ( c:select { c.expand='*' } )
+    (
+      c:('*'/ref) {
+        const col = c === '*' ? {} : c
+        col.expand = '*'
+        if (!Array.isArray(SELECT.expand)) SELECT.expand = []
+        if (!SELECT.expand.find(_compareRefs(col))) SELECT.expand.push(col)
+        return col
+      }
+    )
     ( // --- nested query options, if any
       (OPEN {
         stack.push (SELECT)
-        SELECT = SELECT.expand[SELECT.expand.length - 1]
-        SELECT.expand = ['*'] // by default expand everything
+        SELECT = SELECT.expand[SELECT.expand.length-1]
+        SELECT.expand = '*' // by default expand everything
       })(
-      expandOption:ExpandOption ( o";"o ExpandOption)*
+      expandOptions:( o ";"? o ExpandOption)*
       {
-          // if there is a $select remove the '*' which is by default element[0]
-          if (expandOption[0] === '$select=') SELECT.expand.shift();
+        if (SELECT.columns) {
+          if (SELECT.expand === '*') SELECT.expand = []
+          for (const col of SELECT.columns) {
+            if (!SELECT.expand.find(_compareRefs(col))) SELECT.expand.push(col)
+          }
+          delete SELECT.columns
+        } else {
+          if (Array.isArray(SELECT.expand) && SELECT.expand.indexOf('*') === -1) SELECT.expand.unshift('*')
+        }
       }
       )(CLOSE {
         SELECT = stack.pop()
@@ -272,7 +246,7 @@
 
   search
     = p:search_clause {SELECT.search = p}
-  
+
   search_clause
     = p:( n:NOT? {return n?[n]:[]} )(
       OPEN xpr:search_clause CLOSE {p.push({xpr})}
@@ -292,6 +266,7 @@
       / comp:comparison {p.push(...comp)}
       / lambda:lambda {p.push(...lambda)}
       / func:boolish {p.push(func)}
+      / val:bool {p.push({val})}
     )( ao:(AND/OR) more:where_clause {p.push(ao,...more)} )*
     {return p}
 
@@ -351,7 +326,7 @@
     = ref:(function/ref) sort:( _ s:$("asc"/"desc") {return s})? {
         const appendObj = $(ref, sort && {sort});
         SELECT.orderBy = SELECT.orderBy ?
-        	[...SELECT.orderBy, appendObj] :
+          [...SELECT.orderBy, appendObj] :
           [appendObj]
     }
 
@@ -390,13 +365,13 @@
     }
 
   val
-  	= val:(bool / date) {return {val}}
+    = val:(bool / date) {return {val}}
     / guid
     / val:number {return typeof val === 'number' ? {val} : { val, literal:'number' }}
     / val:string {return {val}}
 
   jsonObject = val:$("{" (jsonObject / [^}])* "}") {return {val}}
-  
+
   jsonArray = val:$("[" o "]" / "[" o "{" (jsonArray / [^\]])* "]") {return {val}}
 
   list
@@ -405,7 +380,7 @@
 
   function "a function call"
     = func:$[a-z]+ OPEN a:operand more:( COMMA o:operand {return o} )* CLOSE {
-      if (strict && !(func in strict.functions)) error("'"+ func +"' is an unknown function in OData URL spec (strict mode)")
+      if (strict && !(func in strict.functions)) exception("'"+ func +"' is an unknown function in OData URL spec (strict mode)")
       return { func, args:[a,...more] }
     }
 
@@ -419,7 +394,7 @@
   OR  = _  "OR"i _ {return 'or'}
 
 
- //
+//
 // ---------- Transformations ------------
 
   applyTrafo
@@ -448,7 +423,11 @@
   aggregateItem
     = res:("$count" alias:asAlias { return { func: 'count', args: ['*'], as: alias } }
            / aggregateExpr
-          ) { (SELECT.expand || (SELECT.expand = [])).push(res) }
+          ) {
+            SELECT.columns = Array.isArray(SELECT.columns) ? SELECT.columns : []
+            if (!SELECT.columns.find(_compareRefs(res))) SELECT.columns.push(res)
+            return res
+          }
   aggregateExpr
     = path:(
         ref
@@ -470,8 +449,8 @@
   groupByElem
     = val:(rollupSpec / ref)
     { (SELECT.groupBy || (SELECT.groupBy = [])).push(val) }
-  rollupSpec // neeed CAP support
-    = "rollup" OPEN o ('$all' / ref) (o COMMA ref)+ o CLOSE
+  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
 
@@ -504,7 +483,7 @@
   identityTrafo = "identity"
 
 
- //
+//
 // ---------- Literals -----------
 
   bool = b:("true" / "false") { return b === 'true'}
@@ -518,7 +497,7 @@
     {return s.replace(/\\\\/g,"\\").replace(/\\"/g,'"')}
 
   word
-    = s:$([+"-"a-zA-Z0-9"."]+)
+    = s:$([a-zA-Z0-9.+-]+)
 
   date
     = s:$( [0-9]+"-"[0-9][0-9]"-"[0-9][0-9] // date
@@ -538,9 +517,9 @@
     = !bool !guid s:$([_a-zA-Z][_a-zA-Z0-9"."]*) {return s}
 
   guid = val:$([0-9a-zA-Z]+ "-" ([0-9a-zA-Z]+ "-"?)+)
-  	{return {val}}
+    {return {val}}
 
- //
+//
 // ---------- Punctuation ----------
 
   COLON = o":"o
@@ -549,11 +528,11 @@
   OPEN  = o"("o
   CLOSE = o")"
 
- //
+//
 // ---------- Whitespaces -----------
 
   o "optional whitespaces" = $[ \t\n]*
   _ "mandatory whitespaces" = $[ \t\n]+
 
- //
+//
 // ------------------------------------

package/libx/odata/odata2cqn/index.js

@@ -0,0 +1,3 @@
+const parser = require('./parser')
+
+module.exports = parser.parse