@sap/cds 5.9.1 → 5.9.4

package/libx/_runtime/common/utils/cqn2cqn4sql.js

@@ -12,7 +12,6 @@ const { getEntityNameFromCQN } = require('./entityFromCqn')
 const getError = require('../../common/error')
 const { rewriteAsterisks } = require('./rewriteAsterisks')
 const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
-const { addToWhere } = require('../../common/utils/cqn')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { addRefToWhereIfNecessary } = require('../../../odata/afterburner')
 const { addAliasToExpression, PARENT_ALIAS, FOREIGN_ALIAS } = require('../../db/utils/generateAliases')
@@ -240,11 +239,14 @@ const _convertCountNavigation = (SELECT, target) => {
 }
 
 const _addTableName = (where, tableName) => {
-  return where.map(ref => {
-    if (ref.ref) {
-      ref.ref.unshift(tableName)
+  return where.map(whereEl => {
+    if (whereEl.xpr) {
+      return { xpr: _addTableName(whereEl.xpr, tableName) }
     }
-    return ref
+    if (whereEl.ref) {
+      whereEl.ref.unshift(tableName)
+    }
+    return whereEl
   })
 }
 
@@ -444,10 +446,7 @@ const convertWhereExists = (query, model, options, currentTarget) => {
     outerAlias = as || PARENT_ALIAS + lambdaIteration
     innerAlias = FOREIGN_ALIAS + lambdaIteration
   } else {
-    const element = currentTarget.elements[ref]
-    if (element && element.isAssociation) {
-      queryTarget = element._target
-    }
+    queryTarget = getEntityFromPath({ ref }, currentTarget)
   }
 
   if (where) {
@@ -501,8 +500,9 @@ const _convertNotEqual = (container, partName = 'where') => {
         }
       }
 
-      if (el && el.SELECT) {
-        _convertNotEqual(el.SELECT, partName)
+      if (el) {
+        if (el.SELECT) _convertNotEqual(el.SELECT, partName)
+        if (el.xpr) _convertNotEqual(el, 'xpr')
       }
     })
 
@@ -561,6 +561,10 @@ const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, target, model, alias, proc
   const queryTarget = model.definitions[ensureNoDraftsSuffix(target)]
 
   orderByOrWhereCQN.forEach((el, index) => {
+    if (el.xpr) {
+      _convertOrderByOrWhereCQN(el.xpr, target, model, alias, processFn)
+      return
+    }
     if (el.ref && _skip(queryTarget, el.ref, alias, model)) processFn(orderByOrWhereCQN, index)
   })
 }
@@ -602,86 +606,56 @@ const _convertRefWhereInExpand = columns => {
   }
 }
 
-const _flattenCQN = cqn => {
-  if (Array.isArray(cqn)) cqn.forEach(_flattenCQN)
-  else if (cqn) {
-    if (cqn.SELECT) _flattenCQN(cqn.SELECT)
-    if (cqn.from) _flattenCQN(cqn.from)
-    if (cqn.ref) _flattenCQN(cqn.ref)
-    if (cqn.SET) _flattenCQN(cqn.SET)
-    if (cqn.args) _flattenCQN(cqn.args)
-    if (cqn.columns) _flattenCQN(cqn.columns)
-    if (cqn.expand) _flattenCQN(cqn.expand)
-    if (cqn.where) _flattenXpr(cqn.where)
-    if (cqn.having) _flattenXpr(cqn.having)
-  }
-}
-
-const _flattenXpr = cqn => {
-  if (!Array.isArray(cqn)) {
-    if (cqn.xpr) cqn = cqn.xpr
-    return
-  }
-
-  let idx = cqn.findIndex(el => el.xpr)
-  while (idx > -1) {
-    cqn.splice(idx, 1, '(', ...cqn[idx].xpr, ')')
-    idx = cqn.findIndex(el => el.xpr)
-  }
-
-  cqn.forEach(_flattenCQN)
-}
-
-const _convertPathExpression = (SELECT, model, options = {}) => {
-  const prevAlias = SELECT.from.as
-  for (const whereEl of SELECT.where || []) {
-    if (typeof whereEl === 'object' && whereEl.SELECT) _convertPathExpression(whereEl.SELECT, model)
+const _convertPathExpression = (query, model, options = {}) => {
+  const prevAlias = query.SELECT.from.as
+  for (const whereEl of query.SELECT.where || []) {
+    if (typeof whereEl === 'object' && whereEl.SELECT) _convertPathExpression(whereEl, model)
   }
-  const conversion = convertPathExpressionToWhere(SELECT.from, model, options)
+  const conversion = convertPathExpressionToWhere(query.SELECT.from, model, options)
   if (!conversion) return
   const { target, alias, where, cardinality, columns, args } = conversion
 
   // REVISIT: It's not possible to just change the reference (i.e. SELECT.from.ref = [target])
   // as many parts of our code base still refer to SELECT.from (e.g. authorization)
   if (args) {
-    SELECT.from = { ref: [{ id: target, args }] }
+    query.SELECT.from = { ref: [{ id: target, args }] }
   } else {
-    SELECT.from = { ref: [target] }
+    query.SELECT.from = { ref: [target] }
   }
   if (alias) {
-    SELECT.from.as = alias
-    if (SELECT.where && alias !== prevAlias) {
-      SELECT.where = addAliasToExpression(SELECT.where, alias)
+    query.SELECT.from.as = alias
+    if (query.SELECT.where && alias !== prevAlias) {
+      query.SELECT.where = addAliasToExpression(query.SELECT.where, alias)
     }
   }
   if (columns) {
     // TODO: use streaming as outer property
-    if (options.isStreaming) SELECT.columns = columns
+    if (options.isStreaming) query.SELECT.columns = columns
     else {
-      if (!SELECT.columns) {
+      if (!query.SELECT.columns) {
         // Okra always wants to have the key values, remove once we relax this requirement
         if (model.definitions[target] && model.definitions[target].keys) {
-          SELECT.columns = Object.keys(model.definitions[target].keys)
+          query.SELECT.columns = Object.keys(model.definitions[target].keys)
             .filter(
               k =>
                 !model.definitions[target].keys[k].isAssociation &&
                 !columns.find(element => element.ref && element.ref[element.ref.length - 1] === k)
             )
             .map(k => ({ ref: [k] }))
-        } else SELECT.columns = []
+        } else query.SELECT.columns = []
       }
-      SELECT.columns.push(...columns)
+      query.SELECT.columns.push(...columns)
     }
   }
   if (cardinality && cardinality.max === 1) {
-    SELECT.one = true
+    query.SELECT.one = true
   }
   // TODO: REVISIT: We need to add alias to subselect in .where, .columns, .from, ... etc
   if (where) {
     if (options._4fiori) {
-      addToWhere({ SELECT }, where)
+      query.where(where)
     } else {
-      addToWhere({ SELECT }, removeIsActiveEntityRecursively(where))
+      query.where(removeIsActiveEntityRecursively(where))
     }
   }
 }
@@ -692,6 +666,9 @@ const _convertToOneEqNullInFilter = (query, target) => {
 
   for (let i = 0; i < query.where.length; i++) {
     const w = query.where[i]
+    if (w.xpr) {
+      _convertToOneEqNullInFilter({ where: w.xpr }, target)
+    }
     const w2 = query.where[i + 2]
     if (!w2 || !w.ref || w2.val !== null) {
       continue
@@ -730,9 +707,6 @@ const _convertSelect = (query, model, _options) => {
     query.SELECT.from = _convertSelect(query.SELECT.from, model, options)
   }
 
-  // REVISIT: a temporary workaround for xpr from new parser
-  if (cds.env.features.odata_new_parser) _flattenCQN(query)
-
   // lambda functions
   convertWhereExists(query.SELECT, model, options)
 
@@ -742,7 +716,7 @@ const _convertSelect = (query, model, _options) => {
     _convertNotEqual(query.SELECT, 'having')
   }
 
-  _convertPathExpression(query.SELECT, model, options)
+  _convertPathExpression(query, model, options)
   rewriteAsterisks(query, model, options)
   if (query.SELECT.where) {
     const entityName =

package/libx/_runtime/common/utils/foreignKeyPropagations.js

@@ -1,24 +1,44 @@
-const _getSubOns = element => {
-  // this only works for on conds with `and`, once we support `or` this needs to be adjusted
-  const newOn = element.on ? element.on.filter(e => e !== '(' && e !== ')') : []
-  const subOns = []
+const _normalizedRef = o => (o && o.ref && o.ref.length > 1 && o.ref[0] === '$self' ? { ref: o.ref.slice(1) } : o)
+
+const _sub = (newOn, subOns = []) => {
   let currArr = []
 
-  for (const onEl of newOn) {
-    if (currArr.length === 0) subOns.push(currArr)
+  for (let i = 0; i < newOn.length; i++) {
+    const onEl = newOn[i]
+
+    if (onEl === 'or') {
+      // abort condition for or
+      subOns.push([])
+      return subOns
+    }
+    if (onEl.xpr) {
+      _sub(onEl.xpr, subOns)
+      // after xpr there usually should be and/or
+      i++
+      continue
+    }
+    if (currArr.length === 0) {
+      subOns.push(currArr)
+    }
     if (onEl !== 'and') currArr.push(onEl)
     else {
       currArr = []
     }
   }
 
+  return subOns
+}
+
+const _getSubOns = element => {
+  const newOn = element.on || []
+  const subOns = _sub(newOn)
+
   for (const subOn of subOns) {
     // We don't support anything else than
     // A = B AND C = D AND ...
     if (subOn.length !== 3) return []
   }
-
-  return subOns
+  return subOns.map(subOn => subOn.map(ref => _normalizedRef(ref)))
 }
 
 const _parentFieldsFromSimpleOnCond = (element, subOn) => {

package/libx/_runtime/common/utils/path.js

@@ -17,14 +17,14 @@ const getPathFromRef = ref => {
 /*
  * returns the target entity for the given path
  */
-const getEntityFromPath = (path, model) => {
-  let current = { elements: model.definitions }
+const getEntityFromPath = (path, def) => {
+  let current = def.definitions ? { elements: def.definitions } : def
   path = typeof path === 'string' ? cds.parse.path(path) : path
   const segments = [...path.ref]
   while (segments.length) {
     const segment = segments.shift()
     current = current.elements[segment.id || segment]
-    if (current && current.target) current = model.definitions[current.target]
+    if (current && current.target) current = current._target
   }
   return current
 }

package/libx/_runtime/common/utils/require.js

@@ -3,6 +3,7 @@ module.exports = name => {
   try {
     return require(name)
   } catch (e) {
-    throw new Error(`Unable to require required package/file "${name}"`)
+    e.message = `Cannot find module '${name}'. Make sure to install it with 'npm i ${name}'\n` + e.message
+    throw e
   }
 }

package/libx/_runtime/common/utils/resolveView.js

@@ -243,6 +243,9 @@ const _newEntries = (entries = [], transition, service) =>
 
 const _newWhere = (where = [], transition, tableName, alias, isSubselect = false) => {
   const newWhere = where.map(whereElement => {
+    if (whereElement.xpr) {
+      return { xpr: _newWhere(whereElement.xpr, transition, tableName, alias, isSubselect) }
+    }
     const newWhereElement = { ...whereElement }
     if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
     if (whereElement.SELECT && whereElement.SELECT.where) {

package/libx/_runtime/common/utils/structured.js

@@ -47,7 +47,8 @@ const _flattenStructuredInExpand = (column, { _target: expandedEntity }) => {
   if (orderBy) {
     column.orderBy = orderBy
   }
-  column.where = flattenStructuredWhereHaving(column.where, expandedEntity)
+  const columnWhere = flattenStructuredWhereHaving(column.where, expandedEntity)
+  if (columnWhere) column.where = columnWhere
   column.expand = column.expand.filter(e => !e.ref || !toBeDeleted.includes(e.ref[e.ref.length - 1]))
   column.expand.push(...flattenedElements)
 }
@@ -205,6 +206,10 @@ const flattenStructuredWhereHaving = (filterArray, csnEntity, model) => {
 
   const newFilterArray = []
   for (let i = 0; i < filterArray.length; i++) {
+    if (filterArray[i].xpr) {
+      newFilterArray.push({ xpr: flattenStructuredWhereHaving(filterArray[i].xpr, csnEntity, model) })
+      continue
+    }
     if (filterArray[i + 1] in OPERATIONS_MAP) {
       const refElement = filterArray[i].ref ? filterArray[i] : filterArray[i + 2]
 

package/libx/_runtime/db/Service.js

@@ -38,6 +38,16 @@ class DatabaseService extends cds.Service {
     // REVISIT: how to generic handler registration?
   }
 
+  /** Database services don't support custom-defined operations */
+  operations() {
+    return []
+  }
+
+  /** Database services don't support custom-defined events */
+  events() {
+    return []
+  }
+
   /*
    * tx
    */

package/libx/_runtime/db/expand/expand-v2.js

@@ -79,16 +79,24 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth, o
   return previousResult
 }
 
+const _fkForOnCOnd = (onCond, requiredFks) => {
+  for (const ele of onCond) {
+    if (ele.xpr) {
+      _fkForOnCOnd(ele.xpr, requiredFks)
+    }
+
+    if (ele.ref && ele.ref[0] === 'parent') {
+      requiredFks.add(ele.ref.slice(1).join('_'))
+    }
+  }
+}
+
 const _foreignKeysOfTopLevelNavs = (entity, options) => {
   const requiredFks = new Set()
   for (const nav in entity._associations) {
     if (options.onlyCompositions && entity._associations[nav]._isAssociationEffective) continue
     const onCond = entity._relations[nav].join('child', 'parent')
-    for (const ele of onCond) {
-      if (ele.ref && ele.ref[0] === 'parent') {
-        requiredFks.add(ele.ref.slice(1).join('_'))
-      }
-    }
+    _fkForOnCOnd(onCond, requiredFks)
   }
   return [...requiredFks]
 }

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -395,6 +395,9 @@ class JoinCQNFromExpanded {
    */
   _adaptWhereSELECT(aliasedTable, where, tableAlias) {
     return where.map(element => {
+      if (element.xpr) {
+        return { xpr: this._adaptWhereSELECT(aliasedTable, element.xpr, tableAlias) }
+      }
       return this._elementAliasNeedsReplacement(element, aliasedTable)
         ? Object.assign({}, element, { ref: [tableAlias, element.ref[1]] })
         : element
@@ -870,13 +873,21 @@ class JoinCQNFromExpanded {
     const aliases = this._getAliases(subSelectColumns)
     const on = entity._relations[tableAlias === columns[0] ? columns.slice(1) : columns].join(tableAlias, parentAlias)
 
+    this._adjustAliases(on, aliases)
+
+    return on
+  }
+
+  _adjustAliases(on, aliases) {
     for (const element of on) {
+      if (element.xpr) {
+        this._adjustAliases(element.xpr, aliases)
+        continue
+      }
       if (element.ref && aliases[element.ref[0]] && aliases[element.ref[0]][element.ref[1]]) {
         element.ref[1] = aliases[element.ref[0]][element.ref[1]]
       }
     }
-
-    return on
   }
 
   _addJoinKeyColumnsToUnion(args, on, parentAlias) {
@@ -899,23 +910,27 @@ class JoinCQNFromExpanded {
   }
 
   _addColumns(columns, on, parentAlias, withAlias = false) {
-    const keyColumns = on
-      .filter(entry => {
-        return (
-          entry.ref &&
-          entry.ref[0] === parentAlias &&
-          !columns.some(column => column.ref && column.ref[column.ref.length - 1] === entry.ref[1])
+    for (const entry of on) {
+      if (entry.xpr) {
+        this._addColumns(columns, entry.xpr, parentAlias, withAlias)
+        continue
+      }
+      if (
+        entry.ref &&
+        entry.ref[0] === parentAlias &&
+        !columns.some(column => column.ref && column.ref[column.ref.length - 1] === entry.ref[1])
+      ) {
+        columns.push(
+          withAlias
+            ? { ref: [parentAlias, entry.ref[1]], as: `${parentAlias}_${entry.ref[1]}` }
+            : { ref: [entry.ref[1]] }
         )
-      })
-      .map(entry =>
-        withAlias ? { ref: [parentAlias, entry.ref[1]], as: `${parentAlias}_${entry.ref[1]}` } : { ref: [entry.ref[1]] }
-      )
-    if (keyColumns.length === 0) return
-    columns.push(...keyColumns)
+      }
+    }
   }
 
   /**
-   * Add an unique alias to each column, to avoid ambiguity.
+   * Add a unique alias to each column, to avoid ambiguity.
    * Add this information to the post process config.
    *
    * @param {object} column
@@ -1318,6 +1333,26 @@ class JoinCQNFromExpanded {
     return newObj
   }
 
+  _getFilterColumns(readToOneCQN, on, parentAlias) {
+    const columns = []
+    const outerColumns = []
+
+    for (const entry of on) {
+      if (entry.xpr) {
+        const { columns: cols, outerColumns: outerCols } = this._getFilterColumns(readToOneCQN, entry.xpr, parentAlias)
+        columns.push(...cols)
+        outerColumns.push(...outerCols)
+        continue
+      }
+      if (typeof entry === 'object' && entry.ref && entry.ref[0] === 'filterExpand') {
+        columns.push(this._getColumnObjectForFilterExpand(readToOneCQN, parentAlias, entry.ref[1]))
+        outerColumns.push({ ref: [entry.ref[1]] })
+      }
+    }
+
+    return { columns, outerColumns }
+  }
+
   /**
    * Reduce column list to column(s) needed to merge the result into one.
    *
@@ -1329,22 +1364,13 @@ class JoinCQNFromExpanded {
    * @private
    */
   _getFilterExpandCQN(readToOneCQN, on, parentAlias, keyObject) {
-    const columns = []
-
-    const outerColumns = []
-
-    for (const entry of on) {
-      if (typeof entry === 'object' && entry.ref && entry.ref[0] === 'filterExpand') {
-        columns.push(this._getColumnObjectForFilterExpand(readToOneCQN, parentAlias, entry.ref[1]))
-        outerColumns.push({ ref: [entry.ref[1]] })
-      }
-    }
-
     const keys = Object.keys(keyObject).filter(
       key =>
         key !== 'IsActiveEntity' && !keyObject[key].is2one && !keyObject[key].is2many && !keyObject[key]._isStructured
     )
 
+    const { columns, outerColumns } = this._getFilterColumns(readToOneCQN, on, parentAlias)
+
     for (const key of keys) {
       if (!columns.map(entry => entry.as).includes(key)) {
         columns.push(this._getColumnObjectForFilterExpand(readToOneCQN, parentAlias, key))
@@ -1455,6 +1481,10 @@ class JoinCQNFromExpanded {
     this._addColumNames(entity, parentAlias, columnNames)
 
     for (const entry of on) {
+      if (entry.xpr) {
+        columns.push(...this._getJoinColumnsFromOnAddToMapping(mapping, parentAlias, entry.xpr, entity))
+        continue
+      }
       if (typeof entry === 'object' && entry.ref && entry.ref[0] !== 'filterExpand') {
         const as = entry.ref.join('_')
         columns.push({

package/libx/_runtime/db/utils/generateAliases.js

@@ -20,6 +20,11 @@ const _redirectXpr = (xpr, aliasMap) => {
       return
     }
 
+    if (element.xpr) {
+      _redirectXpr(element.xpr, aliasMap)
+      return
+    }
+
     if (element.func) {
       _redirectXpr(element.args, aliasMap)
       return
@@ -98,6 +103,10 @@ const generateAliases = query => {
 
 const _addParentAlias = (where, alias) => {
   where.forEach(e => {
+    if (e.xpr) {
+      _addParentAlias(e.xpr, alias)
+      return
+    }
     if (e.ref && e.ref[0].match(PARENT_ALIAS_REGEX)) {
       e.ref[0] = alias
     }

package/libx/_runtime/extensibility/uiflex/handler/transformWRITE.js

@@ -21,6 +21,7 @@ const _processorFn = ({ row, key }) => {
 }
 
 function transformExtendedFieldsCREATE(req) {
+  if (!req.query) return // FIXME: the code below expects req.query to be defined
   if (!req.target) return
   if (!req.query.INSERT.entries) return // REVISIT: breaks at cds.deploy -> should anyways not kick in during cds.deploy