@sap/cds 8.9.4 → 9.0.3

package/libx/odata/parse/grammar.peggy

@@ -60,59 +60,139 @@
         // If none of the above conditions are met, return the input string as is
         return inputString
       }
+
     const skipToken = options.skipToken
+    
     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(''))
+
     const _remapFunc = columns => c => {
       if (Array.isArray(c)) return c.map(_remapFunc(columns))
       const fnObj = c.ref && columns.find(col => 'func' in col && col.as && 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)
+        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: []
-          }
+        if (exp)  _expand((exp.expand ??= []), col)
+        else {
+          const exp = { ref: [assoc], expand: [] }
           _expand(exp.expand, col)
           columns.push(exp)
         }
       }
     }
-    const _handleApply = (cqn, apply, onlyColumnsFromExpand = false) => {
-      let newCqn = _convertApply({ from: cqn.from }, apply, onlyColumnsFromExpand)
+
+    const _mergeColumnTrees = descendents => {
+      const descendentExpandsByRef = descendents.reduce((expandsByRef, column) => {
+        if (typeof column === 'string') {
+          expandsByRef[column] ??= []
+          return expandsByRef
+        }
+        if (!column.ref) return expandsByRef
+        const firstRef = column.ref[0]
+        expandsByRef[firstRef] ??= []
+        expandsByRef[firstRef].push(...(column.expand ?? []))
+        return expandsByRef
+      }, {})
+
+      const mergedExpands = []
+      for (const descendentRef in descendentExpandsByRef) {
+        if (descendentRef === '*') {
+          mergedExpands.push(descendentRef)
+          continue
+        }
+        const mergedColumn = { ref: [descendentRef] }
+        if (descendentExpandsByRef[descendentRef].length)
+          mergedColumn.expand = _mergeColumnTrees(descendentExpandsByRef[descendentRef])
+        mergedExpands.push(mergedColumn)
+      }
+
+      return mergedExpands
+    }
+
+    const _mergeColumnForests = (newColumns, topColumns) => {
+      // Skip if not selection / expand
+      if (!topColumns.length) return
+
+      const topColumnsByRef = topColumns.reduce((groups, column) => {
+        if (!column.ref) return groups
+        const firstRef = column.ref[0]
+        groups[firstRef] ??= []
+        groups[firstRef].push(...(column.expand ?? []))
+        return groups
+      }, {})
+
+      // Compile New Columns Forest Information
+      const selectedNewColumnsByRef = {}
+      const unselectedNewColumnsIdxs = []
+      for (const newColumnIndex in newColumns) {
+        const newColumn = newColumns[newColumnIndex]
+        const newColumnRef = newColumn.ref?.[0]
+        if (Object.keys(topColumnsByRef).includes(newColumnRef))
+          selectedNewColumnsByRef[newColumnRef] = newColumn
+        else if (!newColumn.func) unselectedNewColumnsIdxs.push(newColumnIndex)
+      }
+
+      // Skip if there is no overlap
+      if (!Object.keys(selectedNewColumnsByRef).length) return
+
+      // Remove unselected New Columns
+      for (const unselectedNewColumnIdx of unselectedNewColumnsIdxs) {
+        newColumns.splice(unselectedNewColumnIdx, 1)
+      }
+
+      // Add Top Columns to New Columns
+      for (const topColumnRef in topColumnsByRef) {
+        const newColumn = selectedNewColumnsByRef[topColumnRef]
+        if (!newColumn) continue
+        if (!topColumnsByRef[topColumnRef].length) continue
+        if (newColumn.expand) _mergeColumnForests(newColumn.expand, topColumnsByRef[topColumnRef])
+        else newColumn.expand = _mergeColumnTrees(topColumnsByRef[topColumnRef])
+      }
+    }
+
+    const _handleApply = (cqn, apply) => {
+      let newCqn = _convertApply({ from: cqn.from }, apply)
+      
       if (Array.isArray(newCqn)) {
         for (let i = 0; i < newCqn.length; i++) {
-          newCqn[i] = _addNormalQueryOptions(newCqn[i], cqn, onlyColumnsFromExpand)
+          newCqn[i] = _addNormalQueryOptions(newCqn[i], cqn)
         }
-      } else newCqn = _addNormalQueryOptions(newCqn, cqn, onlyColumnsFromExpand)
+      } else {
+        newCqn = _addNormalQueryOptions(newCqn, cqn)
+      }
+
       return newCqn
     }
-    const _addNormalQueryOptions = (cqn, topCqn, onlyColumnsFromExpand) => {
+
+    const _addNormalQueryOptions = (cqn, topCqn) => {
       if (!topCqn) return cqn
       if (topCqn.apply) delete topCqn.apply
+
       let newCqn = {}
       if (
         (topCqn.columns && topCqn.columns[0].as === '$count') ||
@@ -123,75 +203,69 @@
       ) {
         newCqn.from = cqn
       } else newCqn = cqn.SELECT
+
+
+      // Collect & Select Aggregated Columns
+      const aggregatedColumns = newCqn.columns && newCqn.columns.length
+        ? newCqn.columns.filter(col => col && typeof col === 'object' && 'func' in col)
+        : []
+      newCqn.columns = aggregatedColumns.length ? aggregatedColumns : []
+
+      if (newCqn.groupBy && newCqn.groupBy.length) {
+        // Expand & Select Columns from GroupBy
+
+        const groupByColumns = newCqn.groupBy.reduce((expandedGroupByColumns, column) => {
+            if (column.ref && column.ref.length > 1) {
+              const columnToExpand = { ref: [...column.ref] }
+              if (column.expand && column.expand.length) columnToExpand.expand = [...column.expand]
+              if (column.as) columnToExpand.as = column.as
+              _expand(expandedGroupByColumns, columnToExpand, true)
+            } else expandedGroupByColumns.push({ ...column })
+            return expandedGroupByColumns
+          }, [])
+
+          newCqn.columns ??= []
+          newCqn.columns.push(...groupByColumns)
+      }
+
       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 = [
-        ...((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
-        if (cqn.where && cqn.groupBy) {
-          cqn.having = cqn.where
-            .map(_remapFunc(cqn.columns))
-            .map(_replaceNullRef(cqn.groupBy))
-          delete cqn.where
+          const mergedColumns = []
+
+          // Add aggregation columns 
+          if (newCqn.columns.length) mergedColumns.push(...newCqn.columns)
+
+          // Use columns from parsed CQN if there's no grouping
+          if (!newCqn.groupBy || !newCqn.groupBy.length) {   
+            for (const column of topCqn.columns) 
+              if (!mergedColumns.some(_compareRefs(column))) mergedColumns.push(column)
+          } else {
+            _mergeColumnForests(mergedColumns, topCqn.columns)
+          }
+
+          newCqn.columns = mergedColumns
+
+        } else if (queryOption !== 'from') {
+          newCqn[queryOption] = topCqn[queryOption]
         }
-        // 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 (newCqn.groupBy && newCqn.where) {
+        // Replace Where by Having, to be evaluated after GroupBy
+
+        newCqn.having = newCqn.where
+          .map(_remapFunc(newCqn.columns))
+          .map(_replaceNullRef(newCqn.groupBy))
+        delete newCqn.where
+      }
+
+      if (!newCqn.columns.length) delete newCqn.columns
+      return { SELECT: newCqn }
     }
-    const _convertApply = (cqn, apply, onlyColumnsFromExpand) => {
+
+    const _convertApply = (cqn, apply) => {
       if (!apply) return
+
       if (cqn.apply) delete cqn.apply
       if (apply.identity && cqn.from.SELECT) cqn = cqn.from.SELECT
       if (
@@ -205,46 +279,72 @@
       }
 
       const _toplevels = cqn => {
-        cqn.recurse = {
-          ref: ['parent'],
-          
-        }
+        cqn.recurse = { ref: ['parent'] }
+
+        const _level0 = []
+        const _rest = []
         if (apply.topLevels.levels) {
-          cqn.recurse.where = [{ ref: ['DistanceFromRoot'] }, '<=', { val: apply.topLevels.levels - 1 }]
+          _rest.push([{ ref: ['DistanceFromRoot'] }, '<=', { val: apply.topLevels.levels - 1 }])
+        } else {
+          _rest.push([{ ref: ['DistanceFromRoot'] }, '>=', { val: 0 }])
         }
+
         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 })
-            if (Number.isInteger(expandLevel.levels)) {
-              cqn.recurse.where.push('and', { ref: ['Distance'] })
-              if (expandLevel.levels === 1) cqn.recurse.where.push('=', { val: 1 })
-              else cqn.recurse.where.push('between', { val: 1 }, 'and', { val: expandLevel.levels } )
+            if (expandLevel.levels === 0) {
+              _level0.push([{ func: 'DistanceTo', args: [{ val: expandLevel.nodeID }, { val: null }] }])
+            } else {
+              _rest.push([{ func: 'DistanceTo', args: [{ val: expandLevel.nodeID }, { val: expandLevel.levels }]  }])
             }
           }
         }
+        const _restSimp = _rest[0][1] === '>=' && _rest[0][2].val === 0 ?
+          _rest.length === 1 ? [] : [_rest[0]] : _rest
+        const _restCombined = _restSimp.flatMap((r, i) => i < _restSimp.length - 1 ? [...r, 'or'] : r)
+        if (_level0.length) {
+            const _level0Combined = _level0.flatMap((l, i) => ['and', 'not', ...l])
+            if (_restSimp.length > 1) {
+              cqn.recurse.where = [{ xpr: _restCombined }].concat(_level0Combined)
+            } else if (_restSimp.length === 1 && _restSimp[0][1] === '>=' && _restSimp[0][2].val === 0) {
+              cqn.recurse.where = _level0Combined.slice(1)
+            } else {
+              cqn.recurse.where = _restCombined.concat(_level0Combined)
+            }
+        } else {
+          if (_restCombined.length) cqn.recurse.where = _restCombined
+        }
       }
-      const _descendants = cqn => {
+
+      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?
+            if (node.filter && direction === -1) cqn.where = node.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 
+        cqn.recurse = { ref: ['parent'] }
+        if (direction === 1) {
+          const _throw = () => {
+            const err = new Error("For descendants, only the following filter is supported: `<ID> eq <val>`")
+            err.statusCode = 400
+            throw err
+          }
+          if (info.nodes?.length !== 1 || !info.nodes[0].filter) _throw()
+          const rIdx = info.nodes[0].filter.findIndex(e => e.ref?.[0] === info.id)
+          if (!rIdx === -1) _throw()
+          const op = info.nodes[0].filter[rIdx + 1]
+          const val = info.nodes[0].filter[rIdx + 2]?.val
+          // ignore additional filters (like `IsActiveEntity`?)
+          if (op !== '=' || !val) _throw()
+
+          const endVal = info.distance && direction * info.distance
+          const distance = Number.isInteger(endVal) ? endVal : null
+          const where = [{ func: 'DistanceTo', args: [{ val }, { val: distance }] }]
+          cqn.recurse.where = where
         }
       }
 
@@ -257,7 +357,6 @@
         _ancestors(cqn)
         const extra = {...cqn}
         _descendants(extra)
-        cqn.where = extra.where
         cqn.recurse = extra.recurse
       } else if (apply.topLevels) {
         _toplevels(cqn)
@@ -266,44 +365,51 @@
       } else if (apply.descendants) {
         _descendants(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.groupBy)
+        cqn.groupBy = apply.groupBy.reduce((groupBy, column) => {
+          if (!groupBy.some(_compareRefs(column))) groupBy.push(column)
+          return groupBy
+        }, [])
+
+      if (apply.aggregate && apply.aggregate.length) cqn.columns = [...(cqn.columns || []), ...apply.aggregate]
+      if (cqn.groupBy && cqn.groupBy.length) cqn.columns = [...(cqn.columns || []), ...cqn.groupBy]
+
       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 } 
+          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 }
     }
+
     // Second parameter needed, to assure that order is correct
     const _setOrderBy = (appendObj, first = false) => {
       SELECT.orderBy = SELECT.orderBy
@@ -312,6 +418,7 @@
           : [...SELECT.orderBy, appendObj]
         : [appendObj]
     }
+
     const _removeLambdaPrefix = (prefix, elements) => {
       for (const e of elements) {
         // remove the prefix identifier