@cap-js/db-service 1.0.0 → 1.1.0

package/lib/cqn4sql.js

@@ -70,13 +70,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       // Transform the from clause: association path steps turn into `WHERE EXISTS` subqueries.
       // The already transformed `where` clause is then glued together with the resulting subqueries.
       const { transformedWhere, transformedFrom } = getTransformedFrom(from || entity, transformedProp.where)
+      const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
 
       if (inferred.SELECT) {
         transformedQuery = transformSelectQuery(queryProp, transformedFrom, transformedWhere, transformedQuery)
       } else {
         if (from) {
           transformedProp.from = transformedFrom
-        } else {
+        } else if (!queryNeedsJoins) {
           transformedProp.entity = transformedFrom
         }
 
@@ -94,7 +95,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         }
       }
 
-      if (inferred.joinTree && !inferred.joinTree.isInitial) {
+      if (queryNeedsJoins) {
         transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
       }
     }
@@ -119,7 +120,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (columns) {
       transformedQuery.SELECT.columns = getTransformedColumns(columns)
     } else {
-      transformedQuery.SELECT.columns = getColumnsForWildcard()
+      transformedQuery.SELECT.columns = getColumnsForWildcard(originalQuery.SELECT?.excluding)
     }
 
     // Like the WHERE clause, aliases from the SELECT list are not accessible for `group by`/`having` (in most DB's)
@@ -158,7 +159,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * @param {string} kind - The type of operation: "INSERT" or "UPSERT".
    *
-   * @returns {Object} - The transformed query with updated `into` clause.
+   * @returns {object} - The transformed query with updated `into` clause.
    */
   function transformQueryForInsertUpsert(kind) {
     const { as } = transformedQuery[kind].into
@@ -170,10 +171,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   /**
    * Transforms a stream query, replacing the `where` and `into` clauses after processing.
    *
-   * @param {Object} inferred - The inferred object containing the STREAM query.
-   * @param {Object} transformedQuery - The query object to be transformed.
+   * @param {object} inferred - The inferred object containing the STREAM query.
+   * @param {object} transformedQuery - The query object to be transformed.
    *
-   * @returns {Object} - The transformed query with updated STREAM clauses.
+   * @returns {object} - The transformed query with updated STREAM clauses.
    */
   function transformStreamQuery() {
     const { into, where } = inferred.STREAM
@@ -193,8 +194,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   /**
    * Transforms a search expression to a WHERE clause for a SELECT operation.
    *
-   * @param {Object} search - The search expression which shall be applied to the searchable columns on the query source.
-   * @param {Object} from - The FROM clause of the CQN statement.
+   * @param {object} search - The search expression which shall be applied to the searchable columns on the query source.
+   * @param {object} from - The FROM clause of the CQN statement.
    *
    * @returns {(Object|Array|undefined)} - If the target of the query contains searchable elements, the function returns an array that represents the WHERE clause.
    *     If the SELECT query already contains a WHERE clause, this array includes the existing clause and appends an AND condition with the new 'contains' clause.
@@ -293,6 +294,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
   }
 
+  function isCalculatedOnRead(def) {
+    return def?.value && !def.value.stored
+  }
+
   /**
    * Walks over a list of columns (ref's, xpr, subqueries, val), applies flattening on structured types and expands wildcards.
    *
@@ -301,15 +306,27 @@ 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 (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
+        const calcElement = resolveCalculatedElement(col)
+        transformedColumns.push(calcElement)
+      } else 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 +408,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 +441,88 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
   }
 
+  function resolveCalculatedElement(column, omitAlias = false, baseLink = null) {
+    let value
+
+    if (column.$refLinks) {
+      const { $refLinks } = column
+      value = $refLinks[$refLinks.length - 1].definition.value
+      baseLink = [...column.$refLinks].reverse().find(link => link.definition.isAssociation) || baseLink
+    } else {
+      value = column.value
+    }
+    const { ref, val, xpr, func } = value
+
+    let res
+    if (ref) {
+      res = getTransformedTokenStream([value], baseLink)[0]
+    } else if (xpr) {
+      res = { xpr: getTransformedTokenStream(value.xpr, baseLink) }
+    } else if (val) {
+      res = { val }
+    } else if (func) res = { args: getTransformedTokenStream(value.args), func: value.func }
+    if (!omitAlias) res.as = column.as || column.name || column.flatName
+    return res
+  }
+
+  /**
+   * 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.
    *
@@ -565,7 +664,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * @param {CSN.column} column - The column with the 'expand' property to be transformed into a subquery.
    *
-   * @returns {Object} Returns a subquery correlated with the enclosing query, with added properties `expand:true` and `one:true|false`.
+   * @returns {object} Returns a subquery correlated with the enclosing query, with added properties `expand:true` and `one:true|false`.
    */
   function expandColumn(column) {
     let outerAlias
@@ -622,7 +721,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) {
@@ -659,7 +758,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     const res = []
     for (let i = 0; i < columns.length; i++) {
       const col = columns[i]
-      if (col.isJoinRelevant) {
+      if (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
+        const calcElement = resolveCalculatedElement(col, true)
+        res.push(calcElement)
+      } else if (col.isJoinRelevant) {
         const tableAlias$refLink = getQuerySourceName(col)
         const transformedColumn = {
           ref: [tableAlias$refLink, getFullName(col.$refLinks[col.$refLinks.length - 1].definition)],
@@ -671,6 +773,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
@@ -754,6 +861,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       // for wildcard on subquery in from, just reference the elements
       if (tableAlias.SELECT && !element.elements && !element.target) {
         wildcardColumns.push(index ? { ref: [index, k] } : { ref: [k] })
+      } else if (isCalculatedOnRead(element)) {
+        wildcardColumns.push(resolveCalculatedElement(element))
       } else {
         const flatColumns = getFlatColumnsFor(element, { tableAlias: index }, [], { exclude, replace }, true)
         wildcardColumns.push(...flatColumns)
@@ -903,8 +1012,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 +1044,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 +1072,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 +1118,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 +1131,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 +1156,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 +1185,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 +1194,17 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
           let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive! //
           if (token.ref) {
+            const { definition } = token.$refLinks[token.$refLinks.length - 1]
+            if (isCalculatedOnRead(definition)) {
+              const calculatedElement = resolveCalculatedElement(token, true, $baseLink)
+              transformedTokenStream.push(calculatedElement)
+              continue
+            }
+            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 +1227,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
             })
           }
 
-          transformedWhere.push(result)
+          transformedTokenStream.push(result)
         }
       }
     }
-    return transformedWhere
+    return transformedTokenStream
   }
 
   /**
@@ -1394,11 +1515,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         each.ref[0] in { $self: true, $projection: true } ? getParentEntity(assoc) : target,
       ),
     )
-
-    function getParentEntity(element) {
-      if (element.kind === 'entity') return element
-      else return getParentEntity(element.parent)
-    }
   }
 
   /**
@@ -1797,7 +1913,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 +1958,23 @@ function getLastStringSegment(str) {
   return index != -1 ? str.substring(index + 1) : str
 }
 
+function getParentEntity(element) {
+  if (element.kind === 'entity') return element
+  else return getParentEntity(element.parent)
+}
+
+/**
+ * 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/deep-queries.js

@@ -4,6 +4,17 @@ const { _target_name4 } = require('./SQLService')
 
 const handledDeep = Symbol('handledDeep')
 
+/**
+ * @callback nextCallback
+ * @param {Error|undefined} error
+ * @returns {Promise<unknown>}
+ */
+
+/**
+ * @param {import('@sap/cds/apis/services').Request} req
+ * @param {nextCallback} next
+ * @returns {Promise<number>}
+ */
 async function onDeep(req, next) {
   const { query } = req
   // REVISIT: req.target does not match the query.INSERT target for path insert
@@ -136,11 +147,16 @@ const _calculateExpandColumns = (target, data, expandColumns = [], elementMap =
   }
 }
 
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ */
 const getExpandForDeep = (query, target) => {
   const from = query.DELETE?.from || query.UPDATE?.entity
   const data = query.UPDATE?.data || null
   const where = query.DELETE?.where || query.UPDATE?.where
 
+  /** @type {import("@sap/cds/apis/ql").SELECT<unknown>} */
   const cqn = SELECT.from(from)
   if (where) cqn.SELECT.where = where
 
@@ -150,6 +166,12 @@ const getExpandForDeep = (query, target) => {
   return cqn
 }
 
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {unknown[]} dbData
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ * @returns
+ */
 const getDeepQueries = (query, dbData, target) => {
   let queryData
   if (query.INSERT) {
@@ -174,6 +196,11 @@ const _hasManagedElements = target => {
   return Object.keys(target.elements).filter(elementName => target.elements[elementName]['@cds.on.update']).length > 0
 }
 
+/**
+ * @param {unknown[]} diff
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ * @returns {import('@sap/cds/apis/cqn').Query[]}
+ */
 const _getDeepQueries = (diff, target) => {
   const queries = []
 

package/lib/fill-in-keys.js

@@ -41,6 +41,16 @@ const generateUUIDandPropagateKeys = (target, data, event) => {
   }
 }
 
+/**
+ * @callback nextCallback
+ * @param {Error|undefined} error
+ * @returns {Promise<unknown>}
+ */
+
+/**
+ * @param {import('@sap/cds/apis/services').Request} req
+ * @param {nextCallback} next
+ */
 module.exports = async function fill_in_keys(req, next) {
   // REVISIT dummy handler until we have input processing
   if (!req.target || !this.model || req.target._unresolved) return next()

package/lib/infer/cqn.d.ts

@@ -0,0 +1,45 @@
+import * as cqn from '@sap/cds/apis/cqn'
+import * as csn from '@sap/cds/apis/csn'
+
+type linkedQuery = {
+  target: csn.Definition
+  elements: elements
+}
+export type SELECT = cqn.SELECT & linkedQuery
+export type INSERT = cqn.INSERT & linkedQuery
+export type UPSERT = cqn.UPSERT & linkedQuery
+export type UPDATE = cqn.UPDATE & linkedQuery
+export type STREAM = {
+  STREAM: { into: cqn.name | ref; data: ReadableStream<Buffer>; from: cqn.source; column?: ref; where: predicate }
+} & linkedQuery
+export type DELETE = cqn.DELETE & linkedQuery
+export type CREATE = cqn.CREATE & linkedQuery
+export type DROP = cqn.DROP & linkedQuery
+
+export type Query = SELECT | INSERT | UPSERT | UPDATE | DELETE | CREATE | DROP
+
+export type element = csn.Element & {
+  key?: boolean
+  virtual?: boolean
+  unique?: boolean
+  notNull?: boolean
+}
+export type elements = {
+  [name: string]: element
+}
+
+export type col = cqn.column_expr & { element: element }
+
+export type list = {
+  list: cqn.expr[]
+}
+// Passthrough
+export type source = cqn.source
+export type ref = cqn.ref
+export type val = cqn.val
+export type xpr = cqn.xpr
+export type expr = cqn.expr
+export type func = cqn.function_call
+export type predicate = cqn.predicate
+export type ordering_term = cqn.ordering_term
+export type limit = { rows: val; offset: val }