@cap-js/db-service 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -1,10 +1,17 @@
-# Change Log
+# Changelog
 
 - All notable changes to this project are documented in this file.
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
-## Version 1.3.1 - 2023-10-10
+## [1.3.2](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.1...db-service-v1.3.2) (2023-10-13)
+
+
+### Fixed
+
+- preserve $count for result of SELECT queries ([#280](https://github.com/cap-js/cds-dbs/issues/280)) ([23bef24](https://github.com/cap-js/cds-dbs/commit/23bef245e62952a57ed82afcfd238c0b294b2e9e))
+
+## [1.3.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.0...db-service-v1.3.1) (2023-10-10)
 
 ### Fixed
 

package/README.md

@@ -12,6 +12,11 @@ This project is open to feature requests/suggestions, bug reports etc. via [GitH
 
 Contribution and feedback are encouraged and always welcome. For more information about how to contribute, the project structure, as well as additional contribution information, see our [Contribution Guidelines](CONTRIBUTING.md).
 
+## Versioning
+
+This library follows [Semantic Versioning](https://semver.org/).
+All notable changes are documented in [CHANGELOG.md](CHANGELOG.md).
+
 ## Code of Conduct
 
 We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone. By participating in this project, you agree to abide by its [Code of Conduct](CODE_OF_CONDUCT.md) at all times.

package/lib/SQLService.js

@@ -18,7 +18,7 @@ class SQLService extends DatabaseService {
   init() {
     this.on(['SELECT'], this.transformStreamFromCQN)
     this.on(['UPDATE'], this.transformStreamIntoCQN)
-    this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./fill-in-keys')) // REVISIT should be replaced by correct input processing eventually
+    this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./fill-in-keys')) // REVISIT: should be replaced by correct input processing eventually
     this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./deep-queries').onDeep)
     this.on(['SELECT'], this.onSELECT)
     this.on(['INSERT'], this.onINSERT)
@@ -79,7 +79,10 @@ class SQLService extends DatabaseService {
     let rows = await ps.all(values)
     if (rows.length)
       if (cqn.SELECT.expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
-    if (cqn.SELECT.count) rows.$count = await this.count(query, rows)
+    if (cqn.SELECT.count) {
+      // REVISIT: the runtime always expects that the count is preserved with .map, required for renaming in mocks
+      return SQLService._arrayWithCount(rows, await this.count(query, rows))
+    }
     return cqn.SELECT.one || query.SELECT.from?.ref?.[0].cardinality?.max === 1 ? rows[0] : rows
   }
 
@@ -252,6 +255,17 @@ class SQLService extends DatabaseService {
    */
   static CQN2SQL = require('./cqn2sql').class
 
+  // REVISIT: There must be a better way!
+  // preserves $count for .map calls on array
+  static _arrayWithCount = function (a, count) {
+    const _map = a.map
+    const map = function (..._) { return SQLService._arrayWithCount(_map.call(a, ..._), count) }
+    return Object.defineProperties(a, {
+      $count: { value: count, enumerable: false, configurable: true, writable: true },
+      map: { value: map, enumerable: false, configurable: true, writable: true }
+    })
+  }
+
   /** @param {unknown[]} args */
   constructor(...args) {
     super(...args)
@@ -387,6 +401,7 @@ const _unquirked = q => {
   return q
 }
 
+
 const sqls = new class extends SQLService { get factory() { return null } }
 cds.extend(cds.ql.Query).with(
   class {

package/lib/cqn4sql.js

@@ -12,7 +12,7 @@ const infer = require('./infer')
 const eqOps = [['is'], ['='] /* ['=='] */]
 /**
  * For operators of <notEqOps>, do the same but use or instead of and.
- * This ensures that not struc == <value> is the same as struc != <value>.
+ * This ensures that not struct == <value> is the same as struct != <value>.
  */
 const notEqOps = [['is', 'not'], ['<>'], ['!=']]
 /**
@@ -668,12 +668,24 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     // everything after the wildcard, is a potential replacement
     // in the wildcard expansion
     const replace = []
+
+    const baseRef = col.ref || []
+    const baseRefLinks = col.$refLinks || []
+
+    // column has no ref, then it is an anonymous expand:
+    // select from books { { * } as bar }
+    // only possible if there is exactly one query source
+    if (!baseRef.length) {
+      const [tableAlias, definition] = Object.entries(inferred.sources)[0]
+      baseRef.push(tableAlias)
+      baseRefLinks.push({ definition, source: definition })
+    }
     // we need to make the refs absolute
     col[prop].slice(wildcardIndex + 1).forEach(c => {
       const fakeColumn = { ...c }
       if (fakeColumn.ref) {
-        fakeColumn.ref = [...col.ref, ...fakeColumn.ref]
-        fakeColumn.$refLinks = [...col.$refLinks, ...c.$refLinks]
+        fakeColumn.ref = [...baseRef, ...fakeColumn.ref]
+        fakeColumn.$refLinks = [...baseRefLinks, ...c.$refLinks]
       }
       replace.push(fakeColumn)
     })
@@ -682,15 +694,15 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       // fake the ref since excluding only has strings
       col.excluding.forEach(c => {
         const fakeColumn = {
-          ref: [...col.ref, c],
+          ref: [...baseRef, c],
         }
         exclude.push(fakeColumn)
       })
     }
 
-    if (col.$refLinks[col.$refLinks.length - 1].definition.kind === 'entity')
-      res.push(...getColumnsForWildcard(exclude, replace))
-    else
+    if (baseRefLinks.at(-1).definition.kind === 'entity') {
+      res.push(...getColumnsForWildcard(exclude, replace, col.as))
+    } else
       res.push(
         ...getFlatColumnsFor(col, { columnAlias: col.as, tableAlias: getQuerySourceName(col) }, [], {
           exclude,
@@ -907,12 +919,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * Furthermore, foreign keys (FK) for OData CSN and blobs are excluded from the wildcard expansion.
    *
-   * @param {Array} exclude - An optional list of columns to be excluded during the wildcard expansion.
-   * @param {Array} replace - An optional list of columns to replace during the wildcard expansion.
+   * @param {array} exclude - An optional list of columns to be excluded during the wildcard expansion.
+   * @param {array} replace - An optional list of columns to replace during the wildcard expansion.
+   * @param {string} baseName - the explicit alias of the column.
+   * Only possible for anonymous expands on implicit table alias: `select from books { { * } as FOO }`
    *
    * @returns {Array} Returns an array of explicit columns derived from the wildcard.
    */
-  function getColumnsForWildcard(exclude = [], replace = []) {
+  function getColumnsForWildcard(exclude = [], replace = [], baseName = null) {
     const wildcardColumns = []
     Object.keys(inferred.$combinedElements)
       .filter(k => !exclude.includes(k))
@@ -927,7 +941,13 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         } else if (isCalculatedOnRead(element)) {
           wildcardColumns.push(resolveCalculatedElement(replace.find(r => r.as === k) || element))
         } else {
-          const flatColumns = getFlatColumnsFor(element, { tableAlias: index }, [], { exclude, replace }, true)
+          const flatColumns = getFlatColumnsFor(
+            element,
+            { tableAlias: index, baseName },
+            [],
+            { exclude, replace },
+            true,
+          )
           wildcardColumns.push(...flatColumns)
         }
       })
@@ -969,7 +989,16 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    * Columns excluded in a wildcard expansion or replaced by other columns are also handled accordingly.
    *
    * @param {object} column - The structured element which needs to be expanded.
-   * @param {string} baseName - The prefixes of the column reference (joined with '_'). Optional.
+   * @param {{
+   *  columnAlias: string
+   *  tableAlias: string
+   *  baseName: string
+   * }} names - configuration object for naming parameters:
+   * columnAlias - The explicit alias which the user has defined for the column.
+   *                               For instance `{ struct.foo as bar}` will be transformed into
+   *                               `{ struct_foo_leaf1 as bar_foo_leaf1, struct_foo_leaf2 as bar_foo_leaf2 }`.
+   * tableAlias - The table alias to prepend to the column name. Optional.
+   * baseName - The prefixes of the column reference (joined with '_'). Optional.
    * @param {string} columnAlias - The explicit alias which the user has defined for the column.
    *                               For instance `{ struct.foo as bar}` will be transformed into
    *                               `{ struct_foo_leaf1 as bar_foo_leaf1, struct_foo_leaf2 as bar_foo_leaf2 }`.
@@ -1352,7 +1381,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (flatRhs) {
       const flatLhs = flattenWithBaseName(token)
 
-      //Revisit: Early exit here? We kndow we cant compare the structs, however we do not know exactly why
+      //REVISIT: Early exit here? We kndow we cant compare the structs, however we do not know exactly why
       //        --> calculate error message or exit early? See test "proper error if structures cannot be compared / too many elements on lhs"
       if (flatRhs.length !== flatLhs.length)
         // make sure we can compare both structures
@@ -1419,10 +1448,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
   function assertNoStructInXpr(token, inInfixFilter = false) {
     if (!inInfixFilter && token.$refLinks?.[token.$refLinks.length - 1].definition.target)
-      // revisit: let this through if not requested otherwise
+      // REVISIT: let this through if not requested otherwise
       rejectAssocInExpression()
     if (isStructured(token.$refLinks?.[token.$refLinks.length - 1].definition))
-      // revisit: let this through if not requested otherwise
+      // REVISIT: let this through if not requested otherwise
       rejectStructInExpression()
 
     function rejectAssocInExpression() {

package/lib/infer/index.js

@@ -173,7 +173,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const nextStep = ref[1]?.id || ref[1]
             // no unmanaged assoc in infix filter path
             if (!expandOrExists && e.on)
-              throw new Error(`"${e.name}" in path "${arg.ref.map(idOnly).join('.')}" must not be an unmanaged association`)
+              throw new Error(
+                `"${e.name}" in path "${arg.ref.map(idOnly).join('.')}" must not be an unmanaged association`,
+              )
             // no non-fk traversal in infix filter
             if (!expandOrExists && nextStep && !(nextStep in e.foreignKeys))
               throw new Error(`Only foreign keys of "${e.name}" can be accessed in infix filter`)
@@ -339,13 +341,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
     }
 
     // walk over all paths in other query properties
-    if (where)
-      walkTokenStream(where)
-    if (groupBy)
-      groupBy.forEach(token => inferQueryElement(token, false))
-    if (having)
-      walkTokenStream(having)
-    if (_.with) // consider UPDATE.with
+    if (where) walkTokenStream(where)
+    if (groupBy) groupBy.forEach(token => inferQueryElement(token, false))
+    if (having) walkTokenStream(having)
+    if (_.with)
+      // consider UPDATE.with
       Object.values(_.with).forEach(val => inferQueryElement(val, false))
 
     return queryElements
@@ -355,8 +355,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      * on the information whether the next token is resolved within an `exists` predicates.
      * If such a token has an infix filter, it is not join relevant, because the filter
      * condition is applied to the generated `exists <subquery>` condition.
-     * 
-     * @param {array} tokenStream 
+     *
+     * @param {array} tokenStream
      */
     function walkTokenStream(tokenStream) {
       let skipJoins
@@ -476,12 +476,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       // if any path step points to an artifact with `@cds.persistence.skip`
       // we must ignore the element from the queries elements
       let isPersisted = true
-      const firstStepIsTableAlias =
-        (column.ref.length > 1 && column.ref[0] in sources) ||
-        // nested projection on table alias
-        (column.ref.length === 1 && column.ref[0] in sources && column.inline)
+      const firstStepIsTableAlias = column.ref.length > 1 && column.ref[0] in sources
       const firstStepIsSelf =
         !firstStepIsTableAlias && column.ref.length > 1 && ['$self', '$projection'].includes(column.ref[0])
+      const expandOnTableAlias = column.ref.length === 1 && column.ref[0] in sources && (column.expand || column.inline)
       const nameSegments = []
       // if a (segment) of a (structured) foreign key is renamed, we must not include
       // the aliased ref segments into the name of the final foreign key which is e.g. used in
@@ -535,6 +533,12 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const $refLink = { definition, target: $combinedElements[id][0].tableAlias }
             column.$refLinks.push($refLink)
             nameSegments.push(id)
+          } else if (expandOnTableAlias) {
+            // expand on table alias
+            column.$refLinks.push({
+              definition: sources[id],
+              target: sources[id],
+            })
           } else {
             stepNotFoundInCombinedElements(id) // REVISIT: fails with {__proto__:elements)
           }
@@ -545,9 +549,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
           if (firstStepIsSelf && element?.isAssociation) {
             throw new Error(
-              `Paths starting with “$self” must not contain steps of type “cds.Association”: ref: [ ${column.ref.map(
-                idOnly,
-              ).join(', ')} ]`,
+              `Paths starting with “$self” must not contain steps of type “cds.Association”: ref: [ ${column.ref
+                .map(idOnly)
+                .join(', ')} ]`,
             )
           }
 
@@ -619,7 +623,12 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             if (insertIntoQueryElements) queryElements[column.as || flatName] = getCopyWithAnnos(column, base)
           } else if (column.expand) {
             const elements = resolveExpand(column)
-            if (insertIntoQueryElements) queryElements[column.as || flatName] = elements
+            let elementName
+            // expand on table alias
+            if (column.$refLinks.length === 1 && column.$refLinks[0].definition.kind === 'entity')
+              elementName = column.$refLinks[0].alias
+            else elementName = column.as || flatName
+            if (insertIntoQueryElements) queryElements[elementName] = elements
           } else if (column.inline && insertIntoQueryElements) {
             const elements = resolveInline(column)
             queryElements = { ...queryElements, ...elements }
@@ -752,8 +761,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
        */
       function resolveExpand(col) {
         const { expand, $refLinks } = col
-        const $leafLink = $refLinks?.[$refLinks.length - 1]
-        if ($leafLink?.definition._target) {
+        const $leafLink = $refLinks?.[$refLinks.length - 1] || inferred.SELECT.from.$refLinks.at(-1) // fallback to anonymous expand
+        if ($leafLink.definition._target) {
           const expandSubquery = {
             SELECT: {
               from: $leafLink.definition._target.name,

package/lib/infer/join-tree.js

@@ -148,7 +148,6 @@ class JoinTree {
    *
    * It begins by inferring the source of the given column, which is the table alias where the column is resolvable.
    * Each step during this process represents a node in the join tree. If a node already exists in the tree, the current step is replaced by the already merged node.
-   * For each step, it checks whether it has been seen before. If so, it resets the $refLink to point to the already merged $refLink.
    * If not, it creates a new Node and ensures proper aliasing and foreign key access.
    *
    * @param {object} col - The column object to be merged into the existing join tree. This object should have the properties $refLinks and ref.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {