@cap-js/db-service 2.11.0 → 3.0.0

package/CHANGELOG.md

@@ -4,6 +4,31 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [3.0.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.11.0...db-service-v3.0.0) (2026-06-01)
+
+
+### ⚠ BREAKING CHANGES
+
+* require cds10 ([#1628](https://github.com/cap-js/cds-dbs/issues/1628))
+
+### Added
+
+* own flag for db service results ([#1630](https://github.com/cap-js/cds-dbs/issues/1630)) ([3946e59](https://github.com/cap-js/cds-dbs/commit/3946e59b19ca11afda999d44babeeff835c23817))
+* **pool:** make builtin pool the default ([#1537](https://github.com/cap-js/cds-dbs/issues/1537)) ([919dfe6](https://github.com/cap-js/cds-dbs/commit/919dfe6c5d0cf0ee37a695d2edcc870c1353a93d))
+* require cds10 ([#1628](https://github.com/cap-js/cds-dbs/issues/1628)) ([93e8305](https://github.com/cap-js/cds-dbs/commit/93e83053679f9ef94293caa08917855404db880d))
+
+
+### Fixed
+
+* **builtin-pool:** ignore released/destroyed resource if already draining ([#1631](https://github.com/cap-js/cds-dbs/issues/1631)) ([de37489](https://github.com/cap-js/cds-dbs/commit/de37489bb80b25be1d292a284119c1c0f6405970))
+* calc element with exists through association ([#1608](https://github.com/cap-js/cds-dbs/issues/1608)) ([0d24b28](https://github.com/cap-js/cds-dbs/commit/0d24b285ae8eb71eeca0c6f4bf811a729a8cff4b))
+* InsertResult for keyless entities ([#1617](https://github.com/cap-js/cds-dbs/issues/1617)) ([2efe922](https://github.com/cap-js/cds-dbs/commit/2efe922e2eb4b0c750eb09a74dfd155e8febc9bc))
+* InsertResult is broken if entity has assoc keys ([#1616](https://github.com/cap-js/cds-dbs/issues/1616)) ([9925d22](https://github.com/cap-js/cds-dbs/commit/9925d22236846081e1013381f79249ab0f8f9447))
+* query results fixed gaps ([#1625](https://github.com/cap-js/cds-dbs/issues/1625)) ([5d60e7f](https://github.com/cap-js/cds-dbs/commit/5d60e7f15b4f0a9e7859b0662e690a1790b350ad))
+* resolve `$self` in infix filters with path expressions and nested exists ([#1604](https://github.com/cap-js/cds-dbs/issues/1604)) ([baa3528](https://github.com/cap-js/cds-dbs/commit/baa3528aa735cc3707c4c2a128cf6b57feaf913b))
+* resolve nested assoc-into-assoc inline path resolution ([#1602](https://github.com/cap-js/cds-dbs/issues/1602)) ([ec6fba0](https://github.com/cap-js/cds-dbs/commit/ec6fba0597c75bb206c859bea4e50ce61be40b40))
+* we can't return keys for `INSERT.from(SELECT.from(...))` ([#1622](https://github.com/cap-js/cds-dbs/issues/1622)) ([ccc9f88](https://github.com/cap-js/cds-dbs/commit/ccc9f881adc62cbc16f1feef13da7c658b27d551))
+
 ## [2.11.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.10.1...db-service-v2.11.0) (2026-04-29)
 
 

package/lib/InsertResults.js

@@ -1,4 +1,3 @@
-const iterator = Symbol.iterator
 
 // eslint-disable-next-line no-unused-vars
 const USAGE_SAMPLE = async () => {
@@ -11,106 +10,113 @@ const USAGE_SAMPLE = async () => {
   ])
 }
 
-module.exports = class InsertResult {
+module.exports = class InsertResult extends Array {
+
   /**
    * @param {import('@sap/cds/apis/cqn').INSERT} query
    * @param {unknown[]} results
    */
-  constructor(query, results) {
-    // Storing query as non-enumerable property to avoid polluting trace output
-    Object.defineProperty(this, 'query', { value: query })
-    this.results = results
+  constructor (query, results) {
+    Object.defineProperties (super(), { // using non-enumerable properties to avoid polluting trace output
+      results: { value: results },
+      query: { value: query },
+    })
   }
 
-  /**
-   * Lazy access to auto-generated keys.
+  /** Legacy alias for compatibility */
+  get affectedRows() { return this.affected }
+
+  /** The number of affected rows is determined as follows:
+   * - For INSERTs with entries/rows/values the number of these entries/rows/values is returned
+   * - For other INSERTs the number of affected rows as returned by the database is returned
+   * - For other statements the number of affected rows as returned by the database is returned
    */
-  get [iterator]() {
-    // For INSERT.from(SELECT.from(...)) return a dummy iterator with correct length
+  get affected() {
     const { INSERT } = this.query
-    if (INSERT.from || INSERT.as) {
-      return (super[iterator] = function* () {
-        for (let i = 0; i < this.affectedRows; i++) yield {}
-      })
-    }
+    if (INSERT.from || INSERT.as) return super.affected = this.affectedRows4 (this.results[0] || this.results)
+    else return super.affected = INSERT.entries?.length || INSERT.rows?.length || this.results.length || 1
+  }
+
+  [Symbol.iterator]() {
+    if (!this.length) this.#materialize() // materialize on first access, e.g. for [...results]
+    return super[Symbol.iterator]()
+  }
+
+  toJSON(){
+    if (!this.length) this.#materialize() // ensure materialized keys for JSON.stringify
+    return this
+  }
+
+  /**
+   * Lazy materialization of auto-generated keys.
+   */
+  #materialize() {
 
     const target = this.query._target
-    if (!target?.keys) return (super[iterator] = this.results[iterator])
-    const keys = Object.keys(target.keys),
-      [k1] = keys
+    const keys = target?.keys && Object.keys(target.keys).filter(k => !target.keys[k].virtual && !target.keys[k].value && !target.keys[k].isAssociation)
+    if (!keys?.length) {
+      return this
+    }
+
+    const { INSERT } = this.query
+
+    // For INSERT.from(SELECT.from(...)), we can't return keys
+    if (INSERT.from || INSERT.as) return this
+
+    const k0 = keys[0]
 
     // For INSERT.entries() with generated keys in there return these keys
-    const { entries } = INSERT
-    if (entries && k1 in entries[0]) {
-      return (super[iterator] = function* () {
-        for (const each of entries)
-          yield keys.reduce((p, k) => {
-            p[k] = each[k]
-            return p
-          }, {})
-      })
+    if (INSERT.entries && k0 in INSERT.entries[0]) {
+      for (const d of INSERT.entries) {
+        this.push (keys.reduce((p,k) => (p[k] = d[k], p), {}))
+      }
     }
 
     // For INSERT.rows/values() with generated keys in there return these keys
-    const { columns } = INSERT
-    if (columns && columns.includes(k1)) {
-      return (super[iterator] = function* () {
-        const indices = keys.reduce((p, k) => {
-          let i = columns.indexOf(k)
-          if (i >= 0) p[k] = i
-          return p
-        }, {})
-        for (const each of INSERT.rows || [INSERT.values])
-          yield keys.reduce((p, k) => {
-            p[k] = each[indices[k]]
-            return p
-          }, {})
-      })
+    else if (INSERT.columns && INSERT.columns.includes(k0)) {
+      const indices = keys.reduce((p, k) => {
+        let i = INSERT.columns.indexOf(k)
+        if (i >= 0) p[k] = i
+        return p
+      }, {})
+      for (const d of INSERT.rows || [INSERT.values]) {
+        this.push (keys.reduce((p,k) => (p[k] = d[indices[k]], p), {}))
+      }
     }
 
     // If no generated keys in entries/rows/values we might have database-generated keys
-    return (super[iterator] = function* () {
-      for (const row of this.results) {
-        const affectedRows = this.affectedRows4(row) - 1
-        const lastInsertRowid = this.insertedRowId4(row)
-        for (let i = lastInsertRowid - affectedRows; i<=lastInsertRowid;i++) yield { [k1]: i }
+    else for (const row of this.results) {
+      const affectedRows = this.affectedRows4(row) - 1
+      const lastInsertRowid = this.insertedRowId4(row)
+      for (let i = lastInsertRowid - affectedRows; i<=lastInsertRowid;i++) {
+        this.push ({ [k0]: i })
       }
-    })
-  }
+    }
 
-  /**
-   * the number of inserted (root) entries or the number of affectedRows in case of INSERT into SELECT
-   * @return {number}
-   */
-  get affectedRows() {
-    const { INSERT: _ } = this.query
-    if (_.from || _.as) return (super.affectedRows = this.affectedRows4(this.results[0] || this.results))
-    else return (super.affectedRows = _.entries?.length || _.rows?.length || this.results.length || 1)
+    return this
   }
 
   /**
-   * for checks such as res > 2
-   * @return {number}
+   * Number of affected rows
+   * @param {unknown[]} result
+   * @returns {number}
    */
-  valueOf() {
-    return this.affectedRows
+  affectedRows4(result) {
+    return result.changes
   }
 
   /**
-   * The last id of the auto incremented key column
-   * @param {unknown[]} result
-   * @returns {number}
+   * The last id of auto-incremented key columns
    */
   insertedRowId4(result) {
     return result.lastInsertRowid
   }
 
   /**
-   * Number of affected rows
-   * @param {unknown[]} result
-   * @returns {number}
+   * for checks such as res > 2
+   * @return {number}
    */
-  affectedRows4(result) {
-    return result.changes
+  valueOf() {
+    return this.affected
   }
 }

package/lib/SQLService.js

@@ -18,7 +18,7 @@ const BINARY_TYPES = {
 /**
  * Checks if parameter is an object that at least contains one property.
  *
- * @param {*} obj 
+ * @param {*} obj
  * @returns Boolean
  */
 const _hasProps = (obj) => {
@@ -199,10 +199,10 @@ class SQLService extends DatabaseService {
   async onUPSERT({ query, data }) {
     const { sql, entries } = this.cqn2sql(query, data)
     if (!sql) return // Do nothing when there is nothing to be done // REVISIT: When does this happen?
-    const ps = await this.prepare(sql)
-    const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
-    // REVISIT: results isn't an array, when no entries -> how could that work? when do we have no entries?
-    return results.reduce((total, affectedRows) => total + affectedRows.changes, 0)
+    let ps = await this.prepare(sql)
+    let results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
+    let changes = results.reduce?.((total,r) => total + r.changes, 0) ?? results.changes
+    return this._return_affected(changes)
   }
 
   /**
@@ -216,7 +216,7 @@ class SQLService extends DatabaseService {
       !_hasProps(req.query.UPDATE.with) &&
       !Object.values(req.target?.elements || {}).some(e => e['@cds.on.update'])
     )
-      return 0
+      return this._return_affected(0)
     return this.onSIMPLE(req)
   }
 
@@ -227,7 +227,8 @@ class SQLService extends DatabaseService {
   async onSIMPLE({ query, data }) {
     const { sql, values } = this.cqn2sql(query, data)
     let ps = await this.prepare(sql)
-    return (await ps.run(values)).changes
+    let { changes } = await ps.run(values)
+    return this._return_affected(changes)
   }
 
   get onDELETE() {
@@ -300,7 +301,7 @@ class SQLService extends DatabaseService {
    * @type {Handler}
    */
   async onEVENT({ event }) {
-    if(DEBUG._debug) DEBUG.debug(event) // in the other cases above DEBUG happens in cqn2sql
+    if (DEBUG._debug) DEBUG.debug(event) // in the other cases above DEBUG happens in cqn2sql
     return await this.exec(event)
   }
 
@@ -310,7 +311,7 @@ class SQLService extends DatabaseService {
    */
   async onPlainSQL({ query, data }, next) {
     if (typeof query === 'string') {
-      if(DEBUG._debug) DEBUG.debug(query, data)
+      if (DEBUG._debug) DEBUG.debug(query, data)
       const ps = await this.prepare(query)
       const exec = this.hasResults(query) ? d => ps.all(d) : d => ps.run(d)
       if (Array.isArray(data) && Array.isArray(data[0])) return await Promise.all(data.map(exec))
@@ -415,7 +416,7 @@ class SQLService extends DatabaseService {
    * @param {import('@sap/cds/apis/cqn').Query} q
    * @returns {import('./infer/cqn').Query}
    */
-  cqn4sql(q, useTechnicalAlias=true) {
+  cqn4sql(q, useTechnicalAlias = true) {
     if (
       !cds.env.features.db_strict &&
       !q.SELECT?.from?.join &&
@@ -517,7 +518,7 @@ const DEBUG_PQL = cds.log('pql')
 if (DEBUG_PQL._debug || cds.repl) {
 
   // Add helper method to convert CQN to PQL, used below...
-  SQLService.prototype.cqn2pql = function cqn2pql (query, values) {
+  SQLService.prototype.cqn2pql = function cqn2pql(query, values) {
     const CQN2PQL = cqn2pql.renderer ??= require('./cqn2pql')
     return new CQN2PQL(this).render(query, values)
   }
@@ -533,7 +534,7 @@ if (DEBUG_PQL._debug || cds.repl) {
     }
   }
 
-  // If running in the REPL, extend cds.ql.Query with helpers to inspect queries. 
+  // If running in the REPL, extend cds.ql.Query with helpers to inspect queries.
   if (cds.repl) {
 
     cds.extend(cds.ql.Query).with(
@@ -563,12 +564,12 @@ if (DEBUG_PQL._debug || cds.repl) {
       }
     )
 
-    /** 
-     * Dummy SQL service used in extensions to cds.ql above, 
-     * if no real SQL service is available yet through cds.db. 
+    /**
+     * Dummy SQL service used in extensions to cds.ql above,
+     * if no real SQL service is available yet through cds.db.
      */
     class db extends SQLService {
-      /** @returns {SQLService} */ 
+      /** @returns {SQLService} */
       static get srv() { return cds.db || (this.singleton ??= new this) }
       get factory() { return null }
       get model() { return cds.model }

package/lib/common/DatabaseService.js

@@ -167,5 +167,13 @@ class DatabaseService extends cds.Service {
   }
 }
 
+const _as_array = changes => Object.assign ([],{ affected: changes })
+const _as_number = changes => changes
+DatabaseService.prototype._return_affected = _as_number
+DatabaseService._always_return_arrays = on_off => {
+  if (on_off === undefined) return DatabaseService.prototype._return_affected === _as_array
+  DatabaseService.prototype._return_affected = on_off ? _as_array : _as_number
+}
+DatabaseService._always_return_arrays (cds.env.features.legacy_db_results === false) // TODO: invert default value
 DatabaseService.prototype.isDatabaseService = true
-module.exports = DatabaseService
+module.exports = exports = DatabaseService

package/lib/common/generic-pool.js

@@ -1,7 +1,7 @@
 const cds = require('@sap/cds')
 const LOG = cds.log('db')
 
-const use_new_pool = cds.requires.db?.pool?.builtin || cds.env.features.pool === 'builtin'
+const use_new_pool = cds.requires.db?.pool?.builtin === false || cds.env.features.pool === 'generic-pool' ? false : true
 const createPool = use_new_pool ? (...args) => new Pool(...args) : require('generic-pool').createPool
 
 function ConnectionPool (factory, tenant) {
@@ -145,6 +145,10 @@ constructor (factory, options = {}) {
   }
 
   async release(resource) {
+    if (this._draining) {
+      LOG.debug('Pool is already draining. Resource cannot be returned to pool')
+      return
+    }
     const loan = this._loans.get(resource)
     if (!loan) throw new Error('Resource not currently part of this pool')
     this._loans.delete(resource)
@@ -155,6 +159,10 @@ constructor (factory, options = {}) {
   }
 
   async destroy(resource) {
+    if (this._draining) {
+      LOG.debug('Pool is already draining. Resource will be destroyed anyway')
+      return
+    }
     const loan = this._loans.get(resource)
     if (!loan) throw new Error('Resource not currently part of this pool')
     this._loans.delete(resource)

package/lib/cqn4sql.js

@@ -1823,6 +1823,17 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
               continue
             }
             if (token.ref.length > 1 && token.ref[0] === '$self' && !token.$refLinks[0].definition.kind) {
+              if (inferred.outerQueries) {
+                const outerQuery = inferred.outerQueries[0]
+                const stepToFind = token.ref[1]?.id || token.ref[1]
+                const outerAlias = outerQuery.$combinedElements?.[stepToFind]?.[0].index
+                if (outerAlias) {
+                  let result = copy(token)
+                  result.ref = [outerAlias, token.flatName]
+                  transformedTokenStream.push(result)
+                  continue
+                }
+              }
               const dollarSelfReplacement = [calculateDollarSelfColumn(token, true)]
               transformedTokenStream.push(...getTransformedTokenStream(dollarSelfReplacement))
               continue

package/lib/infer/index.js

@@ -453,7 +453,7 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
           arg.$refLinks.push({ definition: pseudos.elements[id], target: pseudos })
           pseudoPath = true // only first path step must be well defined
           nameSegments.push(id)
-        } else if ($baseLink) {
+        } else if ($baseLink && !firstStepIsSelf) {
           const { definition, target } = $baseLink
           const elements = getDefinition(definition.target)?.elements || definition.elements
           if (elements && id in elements) {
@@ -484,7 +484,15 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
             target: getDefinitionFromSources(sources, id),
           })
         } else if (firstStepIsSelf) {
-          arg.$refLinks.push({ definition: { elements: queryElements }, target: { elements: queryElements } })
+          const nextStep = arg.ref[1]?.id || arg.ref[1]
+          let elements = queryElements
+          if (nextStep && (!queryElements || !(nextStep in queryElements)) && inferred.outerQueries) {
+            const outerQuery = inferred.outerQueries[0]
+            if (outerQuery?.elements && nextStep in outerQuery.elements) {
+              elements = outerQuery.elements
+            }
+          }
+          arg.$refLinks.push({ definition: { elements }, target: { elements } })
         } else if (arg.ref.length > 1 && inferred.outerQueries?.find(outer => id in outer.sources)) {
           // outer query accessed via alias
           const outerAlias = inferred.outerQueries.find(outer => id in outer.sources)
@@ -707,7 +715,7 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
      *    d. Otherwise, the corresponding `$refLinks` definition is added to the `elements` object.
      * 2. Returns the `elements` object.
      */
-    function resolveInline(col, namePrefix = col.as || col.flatName) {
+    function resolveInline(col, namePrefix = col.as || col.flatName, outerBase = null) {
       const { inline, $refLinks } = col
       const $leafLink = $refLinks[$refLinks.length - 1]
       if (!$leafLink.definition.target && !$leafLink.definition.elements) {
@@ -715,10 +723,13 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
           `Unexpected “inline” on “${col.ref.map(idOnly)}”; can only be used after a reference to a structure, association or table alias`,
         )
       }
+      const effectiveBase = outerBase
+        ? { ref: [...outerBase.ref, ...col.ref], $refLinks: [...outerBase.$refLinks, ...col.$refLinks] }
+        : col
       let elements = {}
       let seenWildcard = false
       inline.forEach(inlineCol => {
-        inferArg(inlineCol, null, $leafLink, { inXpr: true, baseColumn: col })
+        inferArg(inlineCol, null, $leafLink, { inXpr: true, baseColumn: effectiveBase })
         if (inlineCol === '*') {
           if (seenWildcard) throw new Error(`Duplicate wildcard "*" in inline of "${col.as || col.ref.map(idOnly).join('_')}"`)
           seenWildcard = true
@@ -777,7 +788,7 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
           else if (inlineCol.ref) nameParts.push(...inlineCol.ref.map(idOnly))
           const name = nameParts.join('_')
           if (inlineCol.inline) {
-            const inlineElements = resolveInline(inlineCol, name)
+            const inlineElements = resolveInline(inlineCol, name, effectiveBase)
             elements = { ...elements, ...inlineElements }
           } else if (inlineCol.expand) {
             const expandElements = resolveExpand(inlineCol)
@@ -953,19 +964,39 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
         mergePathIfNecessary(basePath, arg)
       } else if (arg.xpr || arg.args) {
         const prop = arg.xpr ? 'xpr' : 'args'
+        let inExists = false
         arg[prop].forEach(step => {
+          if (step === 'exists') {
+            inExists = true
+            return
+          }
           let subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
           if (step.ref) {
-            step.$refLinks.forEach((link, i) => {
-              const { definition } = link
-              if (definition.value) {
-                mergePathsIntoJoinTree(definition.value, subPath)
-              } else {
-                subPath.$refLinks.push(link)
-                subPath.ref.push(step.ref[i])
+            if (inExists) {
+              // refs following `exists` become subqueries in cqn4sql — only the basePath prefix
+              // needs a JOIN (for correlation), the exists-target association itself does not.
+              if (subPath.$refLinks.length > 0) {
+                inferred.joinTree.mergeColumn(subPath, originalQuery.outerQueries)
+                // The exists subquery correlates against the last assoc in basePath,
+                // so it's not just a FK access — force a real JOIN.
+                const lastLink = subPath.$refLinks[subPath.$refLinks.length - 1]
+                if (lastLink.onlyForeignKeyAccess) lastLink.onlyForeignKeyAccess = false
+                if (!calcElement.value.isJoinRelevant)
+                  defineProperty(step, 'isJoinRelevant', true)
               }
-            })
-            mergePathIfNecessary(subPath, step)
+            } else {
+              step.$refLinks.forEach((link, i) => {
+                const { definition } = link
+                if (definition.value) {
+                  mergePathsIntoJoinTree(definition.value, subPath)
+                } else {
+                  subPath.$refLinks.push(link)
+                  subPath.ref.push(step.ref[i])
+                }
+              })
+              mergePathIfNecessary(subPath, step)
+            }
+            inExists = false
           } else if (step.args || step.xpr) {
             const nestedProp = step.xpr ? 'xpr' : 'args'
             step[nestedProp].forEach(a => {
@@ -974,6 +1005,9 @@ function infer(originalQuery, model, useTechnicalAlias = true) {
               if (!a.ref) subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
               mergePathsIntoJoinTree(a, subPath)
             })
+            inExists = false
+          } else {
+            if (step !== 'not') inExists = false
           }
         })
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "2.11.0",
+  "version": "3.0.0",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {
@@ -23,11 +23,14 @@
   "scripts": {
     "test": "cds-test"
   },
-  "dependencies": {
+  "peerDependencies": {
+    "@sap/cds": "^10",
     "generic-pool": "^3.9.0"
   },
-  "peerDependencies": {
-    "@sap/cds": ">=9.8"
+  "peerDependenciesMeta": {
+    "generic-pool": {
+      "optional": true
+    }
   },
   "license": "Apache-2.0"
 }