@cap-js/db-service 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -4,6 +4,28 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.1.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.0.1...db-service-v2.1.0) (2025-06-04)
+
+
+### Added
+
+* opt-in replacement for `generic-pool` ([#815](https://github.com/cap-js/cds-dbs/issues/815)) ([32c08f4](https://github.com/cap-js/cds-dbs/commit/32c08f474eab67c71dad3b5e6a378f8bc52520b0))
+
+## [2.0.1](https://github.com/cap-js/cds-dbs/compare/db-service-v2.0.0...db-service-v2.0.1) (2025-05-27)
+
+
+### Fixed
+
+* **`search`:** do not search on non-projected elements ([#1198](https://github.com/cap-js/cds-dbs/issues/1198)) ([73d9e67](https://github.com/cap-js/cds-dbs/commit/73d9e67b1bc7d7727c04b4577cb73f4daaed852b))
+* add shortcut for empty UPDATE.data ([#1203](https://github.com/cap-js/cds-dbs/issues/1203)) ([cf991ff](https://github.com/cap-js/cds-dbs/commit/cf991ff8179efee6a4621d2a2bd8bf6265e58893))
+* hierarchies in quoted mode ([3465cba](https://github.com/cap-js/cds-dbs/commit/3465cbab579d4560d12d3b230c55b746d4d3f5a5))
+* only sort by locale if locale is set ([#1193](https://github.com/cap-js/cds-dbs/issues/1193)) ([3465cba](https://github.com/cap-js/cds-dbs/commit/3465cbab579d4560d12d3b230c55b746d4d3f5a5))
+
+
+### Changed
+
+* remove stream_compat ([#1139](https://github.com/cap-js/cds-dbs/issues/1139)) ([#1144](https://github.com/cap-js/cds-dbs/issues/1144)) ([1b8b2d9](https://github.com/cap-js/cds-dbs/commit/1b8b2d9539cd97be2cef088c98d88ef9ec7dd1bf))
+
 ## [2.0.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.20.0...db-service-v2.0.0) (2025-05-07)
 
 

package/lib/SQLService.js

@@ -11,6 +11,20 @@ const BINARY_TYPES = {
   'cds.hana.BINARY': 1
 }
 
+/**
+ * Checks if parameter is an object that at least contains one property.
+ *
+ * @param {*} obj 
+ * @returns Boolean
+ */
+const _hasProps = (obj) => { 
+  if (!obj) return false
+  for (const p in obj) {
+    return true
+  }
+  return false
+}
+
 /** @typedef {import('@sap/cds/apis/services').Request} Request */
 
 /**
@@ -57,24 +71,18 @@ class SQLService extends DatabaseService {
     return super.init()
   }
 
-  _changeToStreams(columns, rows, one, compat) {
+  _changeToStreams(columns, rows, one) {
     if (!rows || !columns) return
     if (!Array.isArray(rows)) rows = [rows]
-    if (!rows.length || !Object.keys(rows[0]).length) return
-
-    // REVISIT: remove after removing stream_compat feature flag
-    if (compat) {
-      rows[0][Object.keys(rows[0])[0]] = this._stream(Object.values(rows[0])[0])
-      return
-    }
+    if (!rows.length || !Object.keys(rows[0]).length) return   
 
     let changes = false
     for (let col of columns) {
       const name = col.as || col.ref?.[col.ref.length - 1] || (typeof col === 'string' && col)
       if (col.element?.isAssociation) {
-        if (one) this._changeToStreams(col.SELECT.columns, rows[0][name], false, compat)
+        if (one) this._changeToStreams(col.SELECT.columns, rows[0][name], false)
         else
-          changes = rows.some(row => !this._changeToStreams(col.SELECT.columns, row[name], false, compat))
+          changes = rows.some(row => !this._changeToStreams(col.SELECT.columns, row[name], false))
       } else if (col.element?.type === 'cds.LargeBinary') {
         changes = true
         if (one) rows[0][name] = this._stream(rows[0][name])
@@ -141,23 +149,7 @@ class SQLService extends DatabaseService {
         if (expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
 
       if (!iterator) {
-        // REVISIT: remove after removing stream_compat feature flag
-        if (cds.env.features.stream_compat) {
-          if (query._streaming) {
-            if (!rows.length) return
-            this._changeToStreams(cqn.SELECT.columns, rows, true, true)
-            const result = rows[0]
-
-            // stream is always on position 0. Further properties like etag are inserted later.
-            let [key, val] = Object.entries(result)[0]
-            result.value = val
-            delete result[key]
-
-            return result
-          }
-        } else {
-          this._changeToStreams(cqn.SELECT.columns, rows, query.SELECT.one, false)
-        }
+         this._changeToStreams(cqn.SELECT.columns, rows, query.SELECT.one)
       } else if (objectMode) {
         const converter = (row) => this._changeToStreams(cqn.SELECT.columns, row, true)
         const changeToStreams = new Transform({
@@ -216,8 +208,8 @@ class SQLService extends DatabaseService {
   async onUPDATE(req) {
     // noop if not a touch for @cds.on.update
     if (
-      !req.query.UPDATE.data &&
-      !req.query.UPDATE.with &&
+      !_hasProps(req.query.UPDATE.data) &&
+      !_hasProps(req.query.UPDATE.with) &&
       !Object.values(req.target?.elements || {}).some(e => e['@cds.on.update'])
     )
       return 0
@@ -404,8 +396,6 @@ class SQLService extends DatabaseService {
     let kind = q.kind || Object.keys(q)[0]
     if (kind in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 }) {
       q = resolveView(q, this.model, this) // REVISIT: before resolveView was called on flat cqn obtained from cqn4sql -> is it correct to call on original q instead?
-      let target = q[kind]._transitions?.[0].target
-      if (target) q._target = target // REVISIT: Why isn't that done in resolveView?
     }
     let cqn2sql = new this.class.CQN2SQL(this)
     return cqn2sql.render(q, values)

package/lib/common/generic-pool.js

@@ -1,4 +1,10 @@
-const { createPool } = require('generic-pool')
+const cds = require('@sap/cds')
+const LOG = cds.log('db')
+
+const createPool = (factory, config) => {
+  if (cds.requires.db?.pool?.builtin) return new Pool(factory, config)
+  return require('generic-pool').createPool(factory, config)
+}
 
 function ConnectionPool (factory, tenant) {
   let bound_factory = { __proto__: factory, create: factory.create.bind(null, tenant) }
@@ -29,4 +35,256 @@ function TrackedConnectionPool (factory, tenant) {
 }
 
 const DEBUG = /\bpool\b/.test(process.env.DEBUG)
-module.exports = DEBUG ? TrackedConnectionPool : ConnectionPool
+module.exports = DEBUG && !cds.requires.db?.pool?.builtin ? TrackedConnectionPool : ConnectionPool
+
+// Drop-in replacement for https://github.com/coopernurse/node-pool
+// TODO: fifo: true? relevant for our use case?
+
+const { EventEmitter } = require('events')
+
+const ResourceState = Object.freeze({
+  ALLOCATED: 'allocated',
+  IDLE: 'idle',
+  INVALID: 'invalid',
+  VALIDATION: 'validation'
+})
+
+const RequestState = Object.freeze({
+  PENDING: 'pending',
+  RESOLVED: 'resolved',
+  REJECTED: 'rejected'
+})
+
+class Request {
+  constructor (ttl) {
+    this.state = 'pending'
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = value => {
+        clearTimeout(this._timeout)
+        this.state = RequestState.RESOLVED
+        resolve(value)
+      }
+      this._reject = reason => {
+        clearTimeout(this._timeout)
+        this.state = RequestState.REJECTED
+        reject(reason)
+      }
+      if (typeof ttl === 'number' && ttl >= 0) {
+        const err = new Error(`Pool resource could not be acquired within ${ttl / 1000}s`)
+        this._timeout = setTimeout(() => this._reject(err), ttl)
+      }
+    })
+  }
+  resolve (v) { if (this.state === 'pending') this._resolve(v) }
+  reject (e) { if (this.state === 'pending') this._reject(e) }
+}
+
+class PooledResource {
+  constructor(resource) {
+    this.obj = resource
+    this.creationTime = Date.now()
+    this.idle()
+  }
+
+  update(newState) {
+    this.state = newState
+  }
+  idle() {
+    this.state = ResourceState.IDLE
+    this.lastIdleTime = Date.now()
+  }
+}
+
+class Pool extends EventEmitter {
+
+constructor (factory, options = {}) {
+  super()
+  this.factory = factory
+
+  this.options = Object.assign({
+    testOnBorrow: false,
+    evictionRunIntervalMillis: 100000,
+    numTestsPerEvictionRun: 3,
+    softIdleTimeoutMillis: -1,
+    idleTimeoutMillis: 30000,
+    acquireTimeoutMillis: null,
+    destroyTimeoutMillis: null,
+    fifo: false,
+    min: 0,
+    max: 10
+  }, options)
+
+  /** @type {boolean} */
+  this._draining = false
+
+  /** @type {Set<PooledResource>} */
+  this._available = new Set()
+
+  /** @type {Map<any, { pooledResource: PooledResource }>} */
+  this._loans = new Map()
+
+  /** @type {Set<PooledResource>} */
+  this._all = new Set()
+
+  /** @type {Set<Promise<void>>} */
+  this._creates = new Set()
+
+  /** @type {Request[]} */
+  this._queue = []
+
+  this.#scheduleEviction()
+  for (let i = 0; i < this.options.min - this.size; i++) this.#createResource()
+}
+
+  async acquire() {
+    if (this._draining) throw new Error('Pool is draining and cannot accept new requests')
+    const request = new Request(this.options.acquireTimeoutMillis)
+    this._queue.push(request)
+    this.#dispense()
+    return request.promise
+  }
+
+  async release(resource) {
+    const loan = this._loans.get(resource)
+    if (!loan) throw new Error('Resource not currently part of this pool')
+    this._loans.delete(resource)
+    const pooledResource = loan.pooledResource
+    pooledResource.idle()
+    this._available.add(pooledResource)
+    this.#dispense()
+  }
+
+  async destroy(resource) {
+    const loan = this._loans.get(resource)
+    if (!loan) throw new Error('Resource not currently part of this pool')
+    this._loans.delete(resource)
+    const pooledResource = loan.pooledResource
+    await this.#destroy(pooledResource)
+    this.#dispense()
+  }
+
+  async drain() {
+    this._draining = true
+    for (const request of this._queue.splice(0)) {
+      if (request.state === RequestState.PENDING) request.reject(new Error('Pool is draining and cannot fulfil request'))
+    }
+    clearTimeout(this._scheduledEviction)
+  }
+
+  async clear() {
+    await Promise.allSettled(Array.from(this._creates))
+    await Promise.allSettled(Array.from(this._available).map(resource => this.#destroy(resource)))
+  }
+
+  async #createResource() {
+    const createPromise = (async () => {
+      try {
+        const resource = new PooledResource(await this.factory.create())
+        this._all.add(resource)
+        this._available.add(resource)
+      } catch (err) {
+        this._queue.shift()?.reject(err)
+      }
+    })()
+    this._creates.add(createPromise)
+    createPromise.finally(() => {
+      this._creates.delete(createPromise)
+      this.#dispense()
+    })
+    return createPromise
+  }
+
+  async #dispense() {
+    const waiting = this._queue.length
+    if (waiting === 0) return
+    const capacity = this._available.size + this._creates.size
+    const shortfall = waiting - capacity
+    if (shortfall > 0 && this.size < this.options.max) {
+      const needed = Math.min(shortfall, this.options.max - this.size)
+      for (let i = 0; i < needed; i++) this.#createResource()
+    }
+    const dispense = async resource => {
+      const request = this._queue.shift()
+      if (!request) {
+        resource.idle()
+        this._available.add(resource)
+        return false
+      }
+      if (request.state !== RequestState.PENDING) {
+        this.#dispense()
+        return false
+      }
+      this._loans.set(resource.obj, { pooledResource: resource })
+      resource.update(ResourceState.ALLOCATED)
+      request.resolve(resource.obj)
+      return true
+    }
+
+    const _dispenses = []
+    for (let i = 0; i < Math.min(this._available.size, waiting); i++) {
+      const resource = this._available.values().next().value
+      this._available.delete(resource)
+      if (this.options.testOnBorrow) {
+        const validationPromise = (async () => {
+          resource.update(ResourceState.VALIDATION)
+          try {
+            const isValid = await this.factory.validate(resource.obj)
+            if (isValid) return dispense(resource)
+          } catch {/* marked as invalid below */}
+          resource.update(ResourceState.INVALID)
+          await this.#destroy(resource)
+          this.#dispense()
+          return false
+        })()
+        _dispenses.push(validationPromise)
+      } else {
+        _dispenses.push(dispense(resource))
+      }
+    }
+    await Promise.all(_dispenses)
+  }
+
+  async #destroy(resource) {
+    resource.update(ResourceState.INVALID)
+    this._all.delete(resource)
+    this._available.delete(resource)
+    this._loans.delete(resource.obj)
+    try {
+      await this.factory.destroy(resource.obj)
+    } catch (e) {
+       LOG.error(e)
+       /* FIXME: We have to ignore errors here due to a TypeError in hdb */
+       /* This was also a problem with the old (generic-pool) implementation */
+       /* Root cause in hdb needs to be fixed */
+    } finally {
+      if (!this._draining && this.size < this.options.min) {
+        await this.#createResource()
+      }
+    }
+  }
+
+  #scheduleEviction() {
+    const { evictionRunIntervalMillis, numTestsPerEvictionRun, softIdleTimeoutMillis, min, idleTimeoutMillis } = this.options
+    if (evictionRunIntervalMillis <= 0) return
+    this._scheduledEviction = setTimeout(async () => {
+      try {
+        const resourcesToEvict = Array.from(this._available)
+          .slice(0, numTestsPerEvictionRun)
+          .filter(resource => {
+            const idleTime = Date.now() - resource.lastIdleTime
+            const softEvict = softIdleTimeoutMillis > 0 && softIdleTimeoutMillis < idleTime && min < this._available.size
+            return softEvict || idleTimeoutMillis < idleTime
+          })
+        await Promise.all(resourcesToEvict.map(resource => this.#destroy(resource)))
+      } finally {
+        this.#scheduleEviction()
+      }
+    }, evictionRunIntervalMillis).unref()
+  }
+
+  get size()      { return this._all.size + this._creates.size }
+  get available() { return this._available.size }
+  get borrowed()  { return this._loans.size }
+  get pending()   { return this._queue.length }
+  get tenant()    { return this.options.tenant }
+}

package/lib/cqn2sql.js

@@ -338,8 +338,8 @@ class CQN2SQLRenderer {
     const parentKeys = []
     const association = target.elements[recurse.ref[0]]
     association._foreignKeys.forEach(fk => {
-      nodeKeys.push(this.quote(fk.childElement.name))
-      parentKeys.push(this.quote(fk.parentElement.name))
+      nodeKeys.push(fk.childElement.name)
+      parentKeys.push(fk.parentElement.name)
     })
 
     columnsIn.push(
@@ -364,11 +364,13 @@ class CQN2SQLRenderer {
     // In the case of join operations make sure to compute the hierarchy from the source table only
     const stableFrom = getStableFrom(from)
     const alias = stableFrom.as
-    const source = () => ({
+    const source = () => {
+      return ({
       func: 'HIERARCHY',
       args: [{ xpr: ['SOURCE', { SELECT: { columns: columnsIn, from: stableFrom } }, ...(orderBy ? ['SIBLING', 'ORDER', 'BY', `${this.orderBy(orderBy)}`] : [])] }],
       as: alias
     })
+  }
 
     const expandedByNr = { list: [] } // DistanceTo(...,null)
     const expandedByOne = { list: [] } // DistanceTo(...,1)
@@ -724,7 +726,7 @@ class CQN2SQLRenderer {
    */
   orderBy(orderBy, localized) {
     return orderBy.map(c => {
-      const o = localized
+      const o = (localized && this.context.locale)
         ? this.expr(c) +
         (c.element?.[this.class._localized] ? ' COLLATE NOCASE' : '') +
         (c.sort?.toLowerCase() === 'desc' || c.sort === -1 ? ' DESC' : ' ASC')

package/lib/cqn4sql.js

@@ -802,11 +802,7 @@ function cqn4sql(originalQuery, model) {
         })
     } else {
       outerAlias = transformedQuery.SELECT.from.as
-      const getInnermostTarget = q => (q._target ? getInnermostTarget(q._target) : q)
-      subqueryFromRef = [
-        ...(transformedQuery.SELECT.from.ref || /* subq in from */ [getInnermostTarget(transformedQuery).name]),
-        ...ref,
-      ]
+      subqueryFromRef = [transformedQuery._target.name, ...ref]
     }
 
     // this is the alias of the column which holds the correlated subquery

package/lib/search.js

@@ -79,7 +79,7 @@ const _getSearchableColumns = entity => {
     const column = entity.elements[columnName]
     if (column?.isAssociation || columnName.includes('.')) {
       deepSearchCandidates.push({ ref: columnName.split('.') })
-      continue;
+      continue
     }
     cdsSearchColumnMap.set(columnName, annotationValue)
   }
@@ -93,8 +93,8 @@ const _getSearchableColumns = entity => {
     // `@cds.search { element1: true }` or `@cds.search { element1 }`
     if (annotatedColumnValue) return true
 
-    // calculated elements are only searchable if requested through `@cds.search` 
-    if(column.value) return false
+    // calculated elements are only searchable if requested through `@cds.search`
+    if (column.value) return false
 
     // if at least one element is explicitly annotated as searchable, e.g.:
     // `@cds.search { element1: true }` or `@cds.search { element1 }`
@@ -112,16 +112,23 @@ const _getSearchableColumns = entity => {
 
   if (deepSearchCandidates.length) {
     deepSearchCandidates.forEach(c => {
-      const element = c.ref.reduce((resolveIn, curr, i) => {
-        const next = resolveIn.elements?.[curr] || resolveIn._target.elements[curr]
-        if (next?.isAssociation && !c.ref[i + 1]) {
-          const searchInTarget = _getSearchableColumns(next._target)
-          searchInTarget.forEach(elementRefInTarget => {
-            searchableColumns.push({ ref: c.ref.concat(...elementRefInTarget.ref) })
-          })
+      let element = entity
+      for (let i = 0; i < c.ref.length; ++i) {
+        const curr = c.ref[i]
+        const next = element.elements?.[curr] ?? element._target?.elements?.[curr]
+
+        if (!next) { // e.g. if a search element is not part of a projection
+          element = undefined
+          break
         }
-        return next
-      }, entity)
+
+        if (next.isAssociation && i === c.ref.length - 1) {
+          _getSearchableColumns(next._target).forEach(r => searchableColumns.push({ ref: c.ref.concat(...r.ref) }))
+        }
+
+        element = next
+      }
+
       if (element?.type === DEFAULT_SEARCHABLE_TYPE) {
         searchableColumns.push({ ref: c.ref })
       }
@@ -129,9 +136,8 @@ const _getSearchableColumns = entity => {
   }
 
   return searchableColumns.map(column => {
-    if(column.ref)
-      return column
-    return { ref: [ column.name ] }
+    if (column.ref) return column
+    return { ref: [column.name] }
   })
 }
 
@@ -183,15 +189,16 @@ const computeColumnsToBeSearched = (cqn, entity = { __searchableColumns: [] }) =
       }
     })
   } else {
-    if(entity.kind === 'entity') {
+    if (entity.kind === 'entity') {
       // first check cache
-      toBeSearched = entity.own('__searchableColumns') || entity.set('__searchableColumns', _getSearchableColumns(entity))
+      toBeSearched =
+        entity.own('__searchableColumns') || entity.set('__searchableColumns', _getSearchableColumns(entity))
     } else {
       // if we search on a subquery, we don't have a cache
       toBeSearched = _getSearchableColumns(entity)
     }
     toBeSearched = toBeSearched.map(c => {
-      const column = {ref: [...c.ref]}
+      const column = { ref: [...c.ref] }
       return column
     })
   }

package/package.json

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