@cap-js/db-service 1.20.0 → 1.20.1

package/CHANGELOG.md

@@ -4,6 +4,16 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.20.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.20.0...db-service-v1.20.1) (2025-05-27)
+
+
+### Fixed
+
+* **`search`:** do not search on non-projected elements ([#1198](https://github.com/cap-js/cds-dbs/issues/1198)) ([1461673](https://github.com/cap-js/cds-dbs/commit/14616730ba8c27e8ffa30c5962b881badfab991c))
+* current_utctimestamp as default ([#1161](https://github.com/cap-js/cds-dbs/issues/1161)) ([c0cccad](https://github.com/cap-js/cds-dbs/commit/c0cccad921c45db96e14f0e2afeced6af69da4a2))
+* exists within expression is properly detected ([#1156](https://github.com/cap-js/cds-dbs/issues/1156)) ([febe175](https://github.com/cap-js/cds-dbs/commit/febe1755186d291b92edbdf69cebbab68a53d0af))
+* resilience for query re-use scenarios ([#1175](https://github.com/cap-js/cds-dbs/issues/1175)) ([fe9abd5](https://github.com/cap-js/cds-dbs/commit/fe9abd5e4c5e9153c0afad9164f240ae2eadf581))
+
 ## [1.20.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.19.1...db-service-v1.20.0) (2025-04-17)
 
 

package/lib/cqn2sql.js

@@ -1102,7 +1102,7 @@ class CQN2SQLRenderer {
 
       let onInsert = this.managed_session_context(element[cdsOnInsert]?.['='])
         || this.managed_session_context(element.default?.ref?.[0])
-        || (element.default?.val !== undefined && { val: element.default.val, param: false })
+        || (element.default && { __proto__:  element.default, param: false })
       let onUpdate = this.managed_session_context(element[cdsOnUpdate]?.['='])
 
       if (onInsert) onInsert = this.expr(onInsert)

package/lib/cqn4sql.js

@@ -5,7 +5,7 @@ cds.infer.target ??= q => q._target || q.target // instanceof cds.entity ? q._ta
 
 const infer = require('./infer')
 const { computeColumnsToBeSearched } = require('./search')
-const { prettyPrintRef, isCalculatedOnRead, isCalculatedElement, getImplicitAlias, getModelUtils } = require('./utils')
+const { prettyPrintRef, isCalculatedOnRead, isCalculatedElement, getImplicitAlias, defineProperty, getModelUtils } = require('./utils')
 
 /**
  * For operators of <eqOps>, this is replaced by comparing all leaf elements with null, combined with and.
@@ -845,10 +845,7 @@ function cqn4sql(originalQuery, model) {
     }
     const expanded = transformSubquery(subquery)
     const correlated = _correlate({ ...expanded, as: columnAlias }, outerAlias)
-    Object.defineProperty(correlated, 'elements', {
-      value: expanded.elements,
-      writable: true,
-    })
+    defineProperty(correlated, 'elements', expanded.elements)
     return correlated
 
     function _correlate(subq, outer) {
@@ -1070,7 +1067,7 @@ function cqn4sql(originalQuery, model) {
     else {
       const outerQueries = inferred.outerQueries || []
       outerQueries.push(inferred)
-      Object.defineProperty(q, 'outerQueries', { value: outerQueries })
+      defineProperty(q, 'outerQueries', outerQueries)
     }
     const target = cds.infer.target(inferred) // REVISIT: we should reliably use inferred._target instead
     if (isLocalized(target)) q.SELECT.localized = true
@@ -1084,7 +1081,7 @@ function cqn4sql(originalQuery, model) {
         getImplicitAlias(last.id || last),
         inferred.outerQueries,
       )
-      Object.defineProperty(q.SELECT.from, 'uniqueSubqueryAlias', { value: uniqueSubqueryAlias })
+      defineProperty(q.SELECT.from, 'uniqueSubqueryAlias', uniqueSubqueryAlias)
     }
   }
 
@@ -1311,7 +1308,7 @@ function cqn4sql(originalQuery, model) {
             const flatForeignKey = getDefinition(element.parent.name)?.elements[fkBaseName]
 
             setElementOnColumns(flatColumn, flatForeignKey || fkElement)
-            Object.defineProperty(flatColumn, '_csnPath', { value: csnPath, writable: true })
+            defineProperty(flatColumn, '_csnPath', csnPath)
             flatColumns.push(flatColumn)
           }
         }
@@ -1343,7 +1340,7 @@ function cqn4sql(originalQuery, model) {
     if (column.sort) flatRef.sort = column.sort
     if (columnAlias) flatRef.as = columnAlias
     setElementOnColumns(flatRef, element)
-    Object.defineProperty(flatRef, '_csnPath', { value: csnPath, writable: true })
+    defineProperty(flatRef, '_csnPath', csnPath)
     return [flatRef]
 
     function getReplacement(from) {
@@ -1676,7 +1673,7 @@ function cqn4sql(originalQuery, model) {
     const transformedWhere = []
     let transformedFrom = copy(from) // REVISIT: too expensive!
     if (from.$refLinks)
-      Object.defineProperty(transformedFrom, '$refLinks', { value: [...from.$refLinks], writable: true })
+      defineProperty(transformedFrom, '$refLinks', [...from.$refLinks])
     if (from.args) {
       transformedFrom.args = []
       from.args.forEach(arg => {
@@ -1924,10 +1921,7 @@ function cqn4sql(originalQuery, model) {
           const refLinkFaker = thing => {
             const { ref } = thing
             const assocHost = getParentEntity(assocRefLink.definition)
-            Object.defineProperty(thing, '$refLinks', {
-              value: [],
-              writable: true,
-            })
+            defineProperty(thing, '$refLinks', [])
             let pseudoPath = false
             ref.reduce((prev, res, i) => {
               if (res === '$self') {
@@ -2370,10 +2364,7 @@ function getParentEntity(element) {
  * @param {csn.Element} element
  */
 function setElementOnColumns(col, element) {
-  Object.defineProperty(col, 'element', {
-    value: element,
-    writable: true,
-  })
+  defineProperty(col, 'element', element)
 }
 
 const getName = col => col.as || col.ref?.at(-1)

package/lib/infer/index.js

@@ -4,7 +4,7 @@ const cds = require('@sap/cds')
 
 const JoinTree = require('./join-tree')
 const { pseudos } = require('./pseudos')
-const { isCalculatedOnRead, getImplicitAlias, getModelUtils } = require('../utils')
+const { isCalculatedOnRead, getImplicitAlias, getModelUtils, defineProperty } = require('../utils')
 const cdsTypes = cds.linked({
   definitions: {
     Timestamp: { type: 'cds.Timestamp' },
@@ -75,7 +75,7 @@ function infer(originalQuery, model) {
       joinTree: { value: joinTree, writable: true, configurable: true }, // REVISIT: eliminate
     })
     // also enrich original query -> writable because it may be inferred again
-    Object.defineProperty(originalQuery, 'elements', { value: elements, writable: true, configurable: true })
+    defineProperty(originalQuery, 'elements', elements)
   }
   return inferred
 
@@ -171,10 +171,7 @@ function infer(originalQuery, model) {
    * @param {csn.Element} element
    */
   function setElementOnColumns(col, element) {
-    Object.defineProperty(col, 'element', {
-      value: element,
-      writable: true,
-    })
+    defineProperty(col, 'element', element)
   }
 
   /**
@@ -245,7 +242,7 @@ function infer(originalQuery, model) {
       // link $refLinks -> special name resolution rules for orderBy
       orderBy.forEach(token => {
         let $baseLink
-        let rejectJoinRelevantPath
+        let needsElementsOfQueryAsBase
         // first check if token ref is resolvable in query elements
         if (columns) {
           const firstStep = token.ref?.[0].id || token.ref?.[0]
@@ -253,14 +250,11 @@ function infer(originalQuery, model) {
             const columnName = c.as || c.flatName || c.ref?.at(-1).id || c.ref?.at(-1) || c.func
             return columnName === firstStep
           })
-          const needsElementsOfQueryAsBase =
+          needsElementsOfQueryAsBase =
             tokenPointsToQueryElements &&
-            queryElements[token.ref?.[0]] &&
-            /* expand on structure can be addressed */ !queryElements[token.ref?.[0]].$assocExpand
+            queryElements[firstStep] &&
+            /* expand on structure can be addressed */ !queryElements[firstStep].$assocExpand
 
-          // if the ref points into the query itself and follows an exposed association
-          // to a non-fk column, we must reject the ref, as we can't join with the queries own results
-          rejectJoinRelevantPath = needsElementsOfQueryAsBase
           if (needsElementsOfQueryAsBase) $baseLink = { definition: { elements: queryElements }, target: inferred }
         } else {
           // fallback to elements of query source
@@ -268,7 +262,9 @@ function infer(originalQuery, model) {
         }
 
         inferArg(token, queryElements, $baseLink, { inQueryModifier: true })
-        if (token.isJoinRelevant && rejectJoinRelevantPath) {
+        // if the ref points into the query itself and follows an exposed association
+        // to a non-fk column, we must reject the ref, as we can't join with the queries own results
+        if (token.isJoinRelevant && needsElementsOfQueryAsBase) {
           // reverse the array, find the last association and calculate the index of the association in non-reversed order
           const assocIndex =
             token.$refLinks.length - 1 - token.$refLinks.reverse().findIndex(link => link.definition.isAssociation)
@@ -406,18 +402,22 @@ function infer(originalQuery, model) {
     if (arg.param || arg.SELECT) return // parameter references are only resolved into values on execution e.g. :val, :1 or ?
     if (arg.args) applyToFunctionArgs(arg.args, inferArg, [null, $baseLink, context])
     if (arg.list) arg.list.forEach(arg => inferArg(arg, null, $baseLink, context))
-    if (arg.xpr) arg.xpr.forEach(token => inferArg(token, queryElements, $baseLink, { ...context, inXpr: true })) // e.g. function in expression
+    if (arg.xpr)
+      arg.xpr.forEach((token, i) =>
+        inferArg(token, queryElements, $baseLink, { ...context, inXpr: true, inExists: arg.xpr[i - 1] === 'exists' }),
+      ) // e.g. function in expression
 
     if (!arg.ref) {
       if (arg.expand && queryElements) queryElements[arg.as] = resolveExpand(arg)
       return
     }
 
-    // initialize $refLinks
-    Object.defineProperty(arg, '$refLinks', {
-      value: [],
-      writable: true,
-    })
+    // Before the arg is linked, it's meta information should be cleaned up.
+    // This may be important if one manipulates the arg object
+    // __after__ a query has been fired and re-uses the manipulated query
+    defineProperty(arg, '$refLinks', [])
+    defineProperty(arg, 'isJoinRelevant', false)
+
     // if any path step points to an artifact with `@cds.persistence.skip`
     // we must ignore the element from the queries elements
     let isPersisted = true
@@ -428,7 +428,7 @@ function infer(originalQuery, model) {
       expandOnTableAlias = arg.ref.length === 1 && arg.ref[0] in sources && (arg.expand || arg.inline)
     }
     if (dollarSelfRefs && firstStepIsSelf) {
-      Object.defineProperty(arg, 'inXpr', { value: true, writable: true })
+      defineProperty(arg, 'inXpr', true)
       dollarSelfRefs.push(arg)
       return
     }
@@ -455,7 +455,7 @@ function infer(originalQuery, model) {
               const nextStep = arg.ref[1]?.id || arg.ref[1]
               if (isNonForeignKeyNavigation(element, nextStep)) {
                 if (inExists) {
-                  Object.defineProperty($baseLink, 'pathExpressionInsideFilter', { value: true })
+                  defineProperty($baseLink, 'pathExpressionInsideFilter', true)
                 } else {
                   rejectNonFkNavigation(element, element.on ? $baseLink.definition.name : nextStep)
                 }
@@ -519,7 +519,7 @@ function infer(originalQuery, model) {
             const nextStep = arg.ref[i + 1]?.id || arg.ref[i + 1]
             if (isNonForeignKeyNavigation(element, nextStep)) {
               if (inExists) {
-                Object.defineProperty($baseLink, 'pathExpressionInsideFilter', { value: true })
+                defineProperty($baseLink, 'pathExpressionInsideFilter', true)
               } else {
                 rejectNonFkNavigation(element, element.on ? $baseLink.definition.name : nextStep)
               }
@@ -535,7 +535,7 @@ function infer(originalQuery, model) {
         } else if (id === '$dummy') {
           // `some.known.element.$dummy` -> no error; used by cds.ql to simulate joins
           arg.$refLinks.push({ definition: { name: '$dummy', parent: arg.$refLinks[i - 1].target } })
-          Object.defineProperty(arg, 'isJoinRelevant', { value: true })
+          defineProperty(arg, 'isJoinRelevant', true)
         } else {
           const notFoundIn = pseudoPath ? arg.ref[i - 1] : getFullPathForLinkedArg(arg)
           stepNotFoundInPredecessor(id, notFoundIn)
@@ -561,7 +561,7 @@ function infer(originalQuery, model) {
         const definition = arg.$refLinks[i].definition
         if ((!definition.target && definition.kind !== 'entity') || (!inFrom && danglingFilter))
           throw new Error('A filter can only be provided when navigating along associations')
-        if (!inFrom && !arg.expand) Object.defineProperty(arg, 'isJoinRelevant', { value: true })
+        if (!inFrom && !arg.expand)defineProperty(arg, 'isJoinRelevant', true)
         let skipJoinsForFilter = false
         step.where.forEach(token => {
           if (token === 'exists') {
@@ -590,7 +590,7 @@ function infer(originalQuery, model) {
       if (getDefinition(arg.$refLinks[i].definition.target)?.['@cds.persistence.skip'] === true) isPersisted = false
       if (!arg.ref[i + 1]) {
         const flatName = nameSegments.join('_')
-        Object.defineProperty(arg, 'flatName', { value: flatName, writable: true })
+        defineProperty(arg, 'flatName', flatName)
         // if column is casted, we overwrite it's origin with the new type
         if (arg.cast) {
           const base = getElementForCast(arg)
@@ -635,7 +635,7 @@ function infer(originalQuery, model) {
     })
 
     // we need inner joins for the path expressions inside filter expressions after exists predicate
-    if ($baseLink?.pathExpressionInsideFilter) Object.defineProperty(arg, 'join', { value: 'inner' })
+    if ($baseLink?.pathExpressionInsideFilter) defineProperty(arg, 'join', 'inner')
 
     // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
     if (arg.expand) {
@@ -655,7 +655,7 @@ function infer(originalQuery, model) {
         ? { ref: [...baseColumn.ref, ...arg.ref], $refLinks: [...baseColumn.$refLinks, ...arg.$refLinks] }
         : arg
       if (isColumnJoinRelevant(colWithBase)) {
-        Object.defineProperty(arg, 'isJoinRelevant', { value: true })
+        defineProperty(arg, 'isJoinRelevant', true)
         joinTree.mergeColumn(colWithBase, originalQuery.outerQueries)
       }
     }
@@ -761,7 +761,7 @@ function infer(originalQuery, model) {
         const res = $leafLink.definition.is2one
           ? new cds.struct({ elements: inferredExpandSubquery.elements })
           : new cds.array({ items: new cds.struct({ elements: inferredExpandSubquery.elements }) })
-        return Object.defineProperty(res, '$assocExpand', { value: true })
+        return defineProperty(res, '$assocExpand', true)
       } else if ($leafLink.definition.elements) {
         let elements = {}
         expand.forEach(e => {
@@ -900,13 +900,13 @@ function infer(originalQuery, model) {
         const calcElementIsJoinRelevant = isColumnJoinRelevant(p)
         if (calcElementIsJoinRelevant) {
           if (!calcElement.value.isJoinRelevant)
-            Object.defineProperty(step, 'isJoinRelevant', { value: true, writable: true })
+            defineProperty(step, 'isJoinRelevant',true)
           joinTree.mergeColumn(p, originalQuery.outerQueries)
         } else {
           // we need to explicitly set the value to false in this case,
           // e.g. `SELECT from booksCalc.Books { ID, author.{name }, author {name } }`
           // --> for the inline column, the name is join relevant, while for the expand, it is not
-          Object.defineProperty(step, 'isJoinRelevant', { value: false, writable: true })
+          defineProperty(step, 'isJoinRelevant', false)
         }
       }
     }
@@ -1064,7 +1064,6 @@ function infer(originalQuery, model) {
    * @returns {object} a copy of @param base with all annotations of @param from
    * @TODO prototype based
    */
-  // REVISIT: TODO: inferred.elements should be linked
   function getCopyWithAnnos(from, base) {
     const result = { ...base }
     // REVISIT: we don't need to and hence should not handle annotations at runtime
@@ -1072,7 +1071,7 @@ function infer(originalQuery, model) {
       if (prop.startsWith('@')) result[prop] = from[prop]
     }
 
-    if (from.as && base.name !== from.as) Object.defineProperty(result, 'name', { value: from.as }) // TODO double check if this is needed
+    if (from.as && base.name !== from.as) defineProperty(result, 'name', from.as) // TODO double check if this is needed
     // in subqueries we need the linked element if an outer query accesses it
     return Object.setPrototypeOf(result, base)
   }

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/lib/utils.js

@@ -62,6 +62,14 @@ function getImplicitAlias(str, useTechnicalAlias = true) {
   return index != -1 ? str.substring(index + 1) : str
 }
 
+function defineProperty(obj, prop, value) {
+  return Object.defineProperty(obj, prop, {
+    value,
+    writable: true,
+    configurable: true,
+  })
+}
+
 /**
  * Shared utility functions which operate dynamically on the model / query.
  *
@@ -129,5 +137,6 @@ module.exports = {
   isCalculatedOnRead,
   isCalculatedElement,
   getImplicitAlias,
+  defineProperty,
   getModelUtils,
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.20.0",
+  "version": "1.20.1",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {
     "type": "git",
-    "url": "https://github.com/cap-js/cds-dbs"
+    "url": "git+https://github.com/cap-js/cds-dbs.git"
   },
   "bugs": {
     "url": "https://github.com/cap-js/cds-dbs/issues"