@cap-js/db-service 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 1.0.1 - 2023-07-03
+
+### Fixed
+
+- Paths addressing a column of the query via `$self.<column>` in `group by` / `order by`, `having` or `where`
+  are now correctly substituted.
+- Mapping for OData `average` function to ANSI SQL compliant `avg` function.
+
+
 ## Version 1.0.0 - 2023-06-23
 
 - Initial Release

package/lib/cql-functions.js

@@ -3,6 +3,7 @@ const StandardFunctions = {
 
   // String and Collection Functions
   // length     : (x) => `length(${x})`,
+  average: x => `avg(${x})`,
   search: function (ref, arg) {
     if (!('val' in arg)) throw `SQLite only supports single value arguments for $search`
     const refs = ref.list || [ref],

package/lib/cqn4sql.js

@@ -301,15 +301,24 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    */
   function getTransformedColumns(columns) {
     const transformedColumns = []
-
     for (let i = 0; i < columns.length; i++) {
       const col = columns[i]
 
       if (col.expand) {
+        if (col.ref?.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
+          const dollarSelfReplacement = calculateDollarSelfColumn(col)
+          transformedColumns.push(...getTransformedColumns([dollarSelfReplacement]))
+          continue
+        }
         handleExpand(col)
       } else if (col.inline) {
         handleInline(col)
       } else if (col.ref) {
+        if (col.ref.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
+          const dollarSelfReplacement = calculateDollarSelfColumn(col)
+          transformedColumns.push(...getTransformedColumns([dollarSelfReplacement]))
+          continue
+        }
         handleRef(col)
       } else if (col === '*') {
         handleWildcard(columns)
@@ -391,7 +400,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       if (replaceWith === -1) transformedColumns.push(transformedColumn)
       else transformedColumns.splice(replaceWith, 1, transformedColumn)
 
-      Object.defineProperty(transformedColumn, 'element', { value: originalQuery.elements[col.as] })
+      setElementOnColumns(transformedColumn, originalQuery.elements[col.as])
     }
 
     function getTransformedColumn(col) {
@@ -424,6 +433,64 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
   }
 
+  /**
+   * This function resolves a `ref` starting with a `$self`.
+   * Such a path targets another element of the query by it's implicit, or explicit alias.
+   *
+   * A `$self` reference may also target another `$self` path. In this case, this function
+   * recursively resolves the tail of the `$self` references (`$selfPath.ref.slice(2)`) onto it's
+   * new base.
+   *
+   * @param {object} col with a ref like `[ '$self', <target column>, <optional further path navigation> ]`
+   * @param {boolean} omitAlias if we replace a $self reference in an aggregation or a token stream, we must not add an "as" to the result
+   */
+  function calculateDollarSelfColumn(col, omitAlias = false) {
+    const dummyColumn = buildDummyColumnForDollarSelf({ ...col }, col.$refLinks)
+
+    return dummyColumn
+
+    function buildDummyColumnForDollarSelf(dollarSelfColumn, $refLinks) {
+      const { ref, as } = dollarSelfColumn
+      const stepToFind = ref[1]
+      let referencedColumn = inferred.SELECT.columns.find(
+        otherColumn =>
+          otherColumn !== dollarSelfColumn &&
+          (otherColumn.as
+            ? stepToFind === otherColumn.as
+            : stepToFind === otherColumn.ref?.[otherColumn.ref.length - 1]),
+      )
+      if (referencedColumn.ref?.[0] === '$self') {
+        referencedColumn = buildDummyColumnForDollarSelf({ ...referencedColumn }, referencedColumn.$refLinks)
+      }
+
+      if (referencedColumn.ref) {
+        dollarSelfColumn.ref = [...referencedColumn.ref, ...dollarSelfColumn.ref.slice(2)]
+        Object.defineProperties(dollarSelfColumn, {
+          flatName: {
+            value: dollarSelfColumn.ref.join('_'),
+          },
+          isJoinRelevant: {
+            value: referencedColumn.isJoinRelevant,
+          },
+          $refLinks: {
+            value: [...referencedColumn.$refLinks, ...$refLinks.slice(2)],
+          },
+        })
+      } else {
+        // target column is `val` or `xpr`, destructure and throw away the ref with the $self
+        // eslint-disable-next-line no-unused-vars
+        const { xpr, val, ref, as: _as, ...rest } = referencedColumn
+        if (xpr) rest.xpr = xpr
+        else rest.val = val
+        dollarSelfColumn = { ...rest } // reassign dummyColumn without 'ref'
+        if (!omitAlias) dollarSelfColumn.as = as
+      }
+      return dollarSelfColumn.ref?.[0] === '$self'
+        ? buildDummyColumnForDollarSelf({ ...dollarSelfColumn }, $refLinks)
+        : dollarSelfColumn
+    }
+  }
+
   /**
    * Calculates the columns for a nested projection on a structure.
    *
@@ -622,7 +689,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (isLocalized(inferred.target)) subquery.SELECT.localized = true
     const expanded = transformSubquery(subquery)
     const correlated = _correlate({ ...expanded, as: columnAlias }, outerAlias)
-    Object.defineProperty(correlated, 'elements', { value: subquery.elements })
+    Object.defineProperty(correlated, 'elements', { value: subquery.elements, writable: true })
     return correlated
 
     function _correlate(subq, outer) {
@@ -671,6 +738,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         res.push({ ...col })
       } else if (col.ref) {
         if (col.$refLinks.some(link => link.definition._target?.['@cds.persistence.skip'] === true)) continue
+        if (col.ref.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
+          const dollarSelfReplacement = calculateDollarSelfColumn(col)
+          res.push(...getTransformedOrderByGroupBy([dollarSelfReplacement], inOrderBy))
+          continue
+        }
         const { target } = col.$refLinks[0]
         const tableAlias = target.SELECT ? null : getQuerySourceName(col) // do not prepend TA if orderBy column addresses element of query
         const leaf = col.$refLinks[col.$refLinks.length - 1].definition
@@ -903,8 +975,9 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           if (columnAlias) flatColumn = { ref: [fkBaseName], as: `${columnAlias}_${fk.ref.join('_')}` }
           else flatColumn = { ref: [fkBaseName] }
           if (tableAlias) flatColumn.ref.unshift(tableAlias)
-          Object.defineProperty(flatColumn, 'element', { value: fkElement })
-          Object.defineProperty(flatColumn, '_csnPath', { value: csnPath })
+
+          setElementOnColumns(flatColumn, fkElement)
+          Object.defineProperty(flatColumn, '_csnPath', { value: csnPath, writable: true })
           flatColumns.push(flatColumn)
         }
       })
@@ -934,8 +1007,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
     if (column.sort) flatRef.sort = column.sort
     if (columnAlias) flatRef.as = columnAlias
-    Object.defineProperty(flatRef, 'element', { value: element })
-    Object.defineProperty(flatRef, '_csnPath', { value: csnPath })
+    setElementOnColumns(flatRef, element)
+    Object.defineProperty(flatRef, '_csnPath', { value: csnPath, writable: true })
     return [flatRef]
 
     function getReplacement(from) {
@@ -962,11 +1035,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    * @returns {object[]} - The transformed token stream.
    */
   function getTransformedTokenStream(tokenStream, $baseLink = null) {
-    const transformedWhere = []
+    const transformedTokenStream = []
     for (let i = 0; i < tokenStream.length; i++) {
       const token = tokenStream[i]
       if (token === 'exists') {
-        transformedWhere.push(token)
+        transformedTokenStream.push(token)
         const whereExistsSubSelects = []
         const { ref, $refLinks } = tokenStream[i + 1]
         if (!ref) continue
@@ -1008,7 +1081,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         }
 
         const whereExists = { SELECT: whereExistsSubqueries(whereExistsSubSelects) }
-        transformedWhere[i + 1] = whereExists
+        transformedTokenStream[i + 1] = whereExists
         // skip newly created subquery from being iterated
         i += 1
       } else if (token.list) {
@@ -1021,14 +1094,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
             typeof precedingTwoTokens[1] === 'string' ? precedingTwoTokens[1].toLowerCase() : ''
 
           if (firstPrecedingToken === 'not') {
-            transformedWhere.splice(i - 2, 2, 'is', 'not', 'null')
+            transformedTokenStream.splice(i - 2, 2, 'is', 'not', 'null')
           } else if (secondPrecedingToken === 'in') {
-            transformedWhere.splice(i - 1, 1, '=', { val: null })
+            transformedTokenStream.splice(i - 1, 1, '=', { val: null })
           } else {
-            transformedWhere.push({ list: [] })
+            transformedTokenStream.push({ list: [] })
           }
         } else {
-          transformedWhere.push({ list: getTransformedTokenStream(token.list) })
+          transformedTokenStream.push({ list: getTransformedTokenStream(token.list) })
         }
       } else if (tokenStream.length === 1 && token.val && $baseLink) {
         // infix filter - OData variant w/o mentioning key --> flatten out and compare each leaf to token.val
@@ -1046,12 +1119,12 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           throw new Error('Filters can only be applied to managed associations which result in a single foreign key')
         flatKeys.forEach(c => keyValComparisons.push([...[c, '=', token]]))
         keyValComparisons.forEach((kv, j) =>
-          transformedWhere.push(...kv) && keyValComparisons[j + 1] ? transformedWhere.push('and') : null,
+          transformedTokenStream.push(...kv) && keyValComparisons[j + 1] ? transformedTokenStream.push('and') : null,
         )
       } else if (token.ref && token.param) {
-        transformedWhere.push({ ...token })
+        transformedTokenStream.push({ ...token })
       } else if (pseudos.elements[token.ref?.[0]]) {
-        transformedWhere.push({ ...token })
+        transformedTokenStream.push({ ...token })
       } else {
         // expand `struct = null | struct2`
         const { definition } = token.$refLinks?.[token.$refLinks.length - 1] || {}
@@ -1075,7 +1148,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
               cds.error(`The operator "${next}" is not supported for structure comparison`)
             const newTokens = expandComparison(token, ops, rhs)
             const needXpr = Boolean(tokenStream[i - 1] || tokenStream[indexRhs + 1])
-            transformedWhere.push(...(needXpr ? [asXpr(newTokens)] : newTokens))
+            transformedTokenStream.push(...(needXpr ? [asXpr(newTokens)] : newTokens))
             i = indexRhs // jump to next relevant index
           }
         } else {
@@ -1084,6 +1157,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
           let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive! //
           if (token.ref) {
+            if (token.ref.length > 1 && token.ref[0] === '$self' && !token.$refLinks[0].definition.kind) {
+              const dollarSelfReplacement = [calculateDollarSelfColumn(token, true)]
+              transformedTokenStream.push(...getTransformedTokenStream(dollarSelfReplacement))
+              continue
+            }
             const tableAlias = getQuerySourceName(token, $baseLink)
             if (!$baseLink && token.isJoinRelevant) {
               result.ref = [tableAlias, getFullName(token.$refLinks[token.$refLinks.length - 1].definition)]
@@ -1106,11 +1184,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
             })
           }
 
-          transformedWhere.push(result)
+          transformedTokenStream.push(result)
         }
       }
     }
-    return transformedWhere
+    return transformedTokenStream
   }
 
   /**
@@ -1797,7 +1875,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
 
     function getCombinedElementAlias(node) {
-      return getLastStringSegment(inferred.$combinedElements[node.ref[0].id || node.ref[0]][0].index)
+      return getLastStringSegment(inferred.$combinedElements[node.ref[0].id || node.ref[0]]?.[0].index)
     }
   }
 }
@@ -1842,5 +1920,18 @@ function getLastStringSegment(str) {
   return index != -1 ? str.substring(index + 1) : str
 }
 
+/**
+ * Assigns the given `element` as non-enumerable property 'element' onto `col`.
+ *
+ * @param {object} col
+ * @param {csn.Element} element
+ */
+function setElementOnColumns(col, element) {
+  Object.defineProperty(col, 'element', {
+    value: element,
+    writable: true,
+  })
+}
+
 const idOnly = ref => ref.id || ref
 const is_regexp = x => x?.constructor?.name === 'RegExp' // NOTE: x instanceof RegExp doesn't work in repl

package/lib/infer/index.js

@@ -275,7 +275,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       inferElementsFromWildCard(aliases)
     } else {
       let wildcardSelect = false
-      const refs = []
+      const dollarSelfRefs = []
       columns.forEach(col => {
         if (col === '*') {
           wildcardSelect = true
@@ -294,24 +294,24 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           }
           setElementOnColumns(col, queryElements[as])
         } else if (col.ref) {
-          refs.push(col)
+          const firstStepIsTableAlias =
+            (col.ref.length > 1 && col.ref[0] in sources) ||
+            // nested projection on table alias
+            (col.ref.length === 1 && col.ref[0] in sources && col.inline)
+          const firstStepIsSelf =
+            !firstStepIsTableAlias && col.ref.length > 1 && ['$self', '$projection'].includes(col.ref[0])
+          // we must handle $self references after the query elements have been calculated
+          if (firstStepIsSelf) dollarSelfRefs.push(col)
+          else handleRef(col)
         } else if (col.expand) {
           inferQueryElement(col)
         } else {
           throw cds.error`Not supported: ${JSON.stringify(col)}`
         }
       })
-      refs.forEach(col => {
-        inferQueryElement(col)
-        const { definition } = col.$refLinks[col.$refLinks.length - 1]
-        if (col.cast)
-          // final type overwritten -> element not visible anymore
-          setElementOnColumns(col, getElementForCast(col))
-        else if ((col.ref.length === 1) & (col.ref[0] === '$user'))
-          // shortcut to $user.id
-          setElementOnColumns(col, queryElements[col.as || '$user'])
-        else setElementOnColumns(col, definition)
-      })
+
+      if (dollarSelfRefs.length) inferDollarSelfRefs(dollarSelfRefs)
+
       if (wildcardSelect) inferElementsFromWildCard(aliases)
     }
     if (orderBy) {
@@ -359,6 +359,54 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
     return queryElements
 
+    /**
+     * Processes references starting with `$self`, which are intended to target other query elements.
+     * These `$self` paths must be handled after processing the "regular" columns since they are dependent on other query elements.
+     *
+     * This function checks for `$self` references that may target other `$self` columns, and delays their processing.
+     * `$self` references not targeting other `$self` references are handled by the generic `handleRef` function immediately.
+     *
+     * @param {array} dollarSelfColumns - An array of column objects containing `$self` references.
+     */
+    function inferDollarSelfRefs(dollarSelfColumns) {
+      do {
+        const unprocessedColumns = []
+
+        for (const currentDollarSelfColumn of dollarSelfColumns) {
+          const { ref } = currentDollarSelfColumn
+          const stepToFind = ref[1]
+
+          const referencesOtherDollarSelfColumn = dollarSelfColumns.find(
+            otherDollarSelfCol =>
+              otherDollarSelfCol !== currentDollarSelfColumn &&
+              (otherDollarSelfCol.as
+                ? stepToFind === otherDollarSelfCol.as
+                : stepToFind === otherDollarSelfCol.ref?.[otherDollarSelfCol.ref.length - 1]),
+          )
+
+          if (referencesOtherDollarSelfColumn) {
+            unprocessedColumns.push(currentDollarSelfColumn)
+          } else {
+            handleRef(currentDollarSelfColumn)
+          }
+        }
+
+        dollarSelfColumns = unprocessedColumns
+      } while (dollarSelfColumns.length > 0)
+    }
+
+    function handleRef(col) {
+      inferQueryElement(col)
+      const { definition } = col.$refLinks[col.$refLinks.length - 1]
+      if (col.cast)
+        // final type overwritten -> element not visible anymore
+        setElementOnColumns(col, getElementForCast(col))
+      else if ((col.ref.length === 1) & (col.ref[0] === '$user'))
+        // shortcut to $user.id
+        setElementOnColumns(col, queryElements[col.as || '$user'])
+      else setElementOnColumns(col, definition)
+    }
+
     /**
      * This function is responsible for inferring a query element based on a provided column.
      * It initializes and attaches a non-enumerable `$refLinks` property to the column,
@@ -477,7 +525,17 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         } else {
           const { definition } = column.$refLinks[i - 1]
           const elements = definition.elements || definition._target?.elements
-          if (elements && id in elements) {
+          const element = elements?.[id]
+
+          if (firstStepIsSelf && element?.isAssociation) {
+            throw cds.error(
+              `Paths starting with “$self” must not contain steps of type “cds.Association”: ref: [ ${column.ref.map(
+                idOnly,
+              )} ]`,
+            )
+          }
+
+          if (element) {
             const $refLink = { definition: elements[id], target: column.$refLinks[i - 1].target }
             column.$refLinks.push($refLink)
           } else if (firstStepIsSelf) {
@@ -504,7 +562,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             : null
           if (foreignKeyAlias) nameSegments.push(foreignKeyAlias)
           else if (skipAliasedFkSegmentsOfNameStack[0] === id) skipAliasedFkSegmentsOfNameStack.shift()
-          else nameSegments.push(id)
+          else {
+            nameSegments.push(firstStepIsSelf && i === 1 ? element.__proto__.name : id)
+          }
         }
 
         if (step.where) {
@@ -586,7 +646,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       }
       const virtual = (column.$refLinks[column.$refLinks.length - 1].definition.virtual || !isPersisted) && !inExpr
       // check if we need to merge the column `ref` into the join tree of the query
-      if (!inExists && !virtual && isColumnJoinRelevant(column)) {
+      if (!inExists && !virtual && isColumnJoinRelevant(column, firstStepIsSelf)) {
         Object.defineProperty(column, 'isJoinRelevant', { value: true })
         joinTree.mergeColumn(column)
       }
@@ -760,7 +820,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
       if (!assoc) return false
       if (fkAccess) return false
-      else return true
+      return true
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "CDS base database service",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [