@cap-js/db-service 1.14.0 → 1.15.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/).
 
+## [1.15.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.14.1...db-service-v1.15.0) (2024-11-14)
+
+
+### Added
+
+* enable path expressions in infix filter after `exists` predicate ([#875](https://github.com/cap-js/cds-dbs/issues/875)) ([7e50359](https://github.com/cap-js/cds-dbs/commit/7e5035932ac3bf39f052aa67e1565567e9d6b1ad))
+
+
+### Fixed
+
+* **`search`:** ignore invalid path expressions inside `@cds.search` ([#849](https://github.com/cap-js/cds-dbs/issues/849)) ([250edd5](https://github.com/cap-js/cds-dbs/commit/250edd5ec9f7ba1d8e40e1330e4b4f9ad9e599b0))
+* nested exists wrapped in xpr ([7e50359](https://github.com/cap-js/cds-dbs/commit/7e5035932ac3bf39f052aa67e1565567e9d6b1ad))
+
+## [1.14.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.14.0...db-service-v1.14.1) (2024-10-28)
+
+
+### Fixed
+
+* deep delete for views ([#496](https://github.com/cap-js/cds-dbs/issues/496)) ([82154ef](https://github.com/cap-js/cds-dbs/commit/82154ef8b837f17e81e2516056e03ff215f1dff8))
+* properly support `default`, `cds.on.insert` and `cds.on.update` for `UPSERT` queries ([#425](https://github.com/cap-js/cds-dbs/issues/425)) ([338e9f5](https://github.com/cap-js/cds-dbs/commit/338e9f5de9109d36013208547fc648c17ce8c7b0))
+* SELECT cds.hana.BINARY ([#870](https://github.com/cap-js/cds-dbs/issues/870)) ([33c3ebe](https://github.com/cap-js/cds-dbs/commit/33c3ebe84be4c0181b1c230d5f2d332332201ce0))
+
 ## [1.14.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.13.0...db-service-v1.14.0) (2024-10-15)
 
 

package/lib/SQLService.js

@@ -1,7 +1,7 @@
 const cds = require('@sap/cds'),
   DEBUG = cds.debug('sql|db')
 const { Readable } = require('stream')
-const { resolveView } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
+const { resolveView, getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const DatabaseService = require('./common/DatabaseService')
 const cqn4sql = require('./cqn4sql')
 
@@ -25,14 +25,16 @@ class SQLService extends DatabaseService {
     this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./deep-queries').onDeep)
     if (cds.env.features.db_strict) {
       this.before(['INSERT', 'UPSERT', 'UPDATE'], ({ query }) => {
-        const elements = query.target?.elements; if (!elements) return
+        const elements = query.target?.elements
+        if (!elements) return
         const kind = query.kind || Object.keys(query)[0]
         const operation = query[kind]
         if (!operation.columns && !operation.entries && !operation.data) return
         const columns =
           operation.columns ||
           Object.keys(
-            operation.data || operation.entries?.reduce((acc, obj) => {
+            operation.data ||
+            operation.entries?.reduce((acc, obj) => {
               return Object.assign(acc, obj)
             }, {}),
           )
@@ -214,7 +216,31 @@ class SQLService extends DatabaseService {
     // REVISIT: It's not yet 100 % clear under which circumstances we can rely on db constraints
     return (super.onDELETE = /* cds.env.features.assert_integrity === 'db' ? this.onSIMPLE : */ deep_delete)
     async function deep_delete(/** @type {Request} */ req) {
-      let { compositions } = req.target
+      const transitions = getTransition(req.target, this, false, req.query.cmd || 'DELETE')
+      if (transitions.target !== transitions.queryTarget) {
+        const keys = []
+        const transitionsTarget = transitions.queryTarget.keys || transitions.queryTarget.elements
+        for (const key in transitionsTarget) {
+          const exists = e => e && !e.virtual && !e.value && !e.isAssociation
+          if (exists(transitionsTarget[key])) keys.push(key)
+        }
+        const matchedKeys = keys.filter(key => transitions.mapping.has(key)).map(k => ({ ref: [k] }))
+        const query = DELETE.from({
+          ref: [
+            {
+              id: transitions.target.name,
+              where: [
+                { list: matchedKeys.map(k => transitions.mapping.get(k.ref[0])) },
+                'in',
+                SELECT.from(req.query.DELETE.from).columns(matchedKeys).where(req.query.DELETE.where),
+              ],
+            },
+          ],
+        })
+        return this.onDELETE({ query, target: transitions.target })
+      }
+      const table = getDBTable(req.target)
+      const { compositions } = table
       if (compositions) {
         // Transform CQL`DELETE from Foo[p1] WHERE p2` into CQL`DELETE from Foo[p1 and p2]`
         let { from, where } = req.query.DELETE
@@ -241,6 +267,7 @@ class SQLService extends DatabaseService {
               )
             // Prepare and run deep query, à la CQL`DELETE from Foo[pred]:comp1.comp2...`
             const query = DELETE.from({ ref: [...from.ref, c.name] })
+            query.target = c._target
             return this.onDELETE({ query, depth, visited: [...visited], target: c._target })
           }),
         )

package/lib/cqn2sql.js

@@ -4,12 +4,6 @@ const cqn4sql = require('./cqn4sql')
 const _simple_queries = cds.env.features.sql_simple_queries
 const _strict_booleans = _simple_queries < 2
 
-const BINARY_TYPES = {
-  'cds.Binary': 1,
-  'cds.LargeBinary': 1,
-  'cds.hana.BINARY': 1,
-}
-
 const { Readable } = require('stream')
 
 const DEBUG = (() => {
@@ -42,6 +36,12 @@ class CQN2SQLRenderer {
     }
   }
 
+  BINARY_TYPES = {
+    'cds.Binary': 1,
+    'cds.LargeBinary': 1,
+    'cds.hana.BINARY': 1,
+  }
+
   static _add_mixins(aspect, mixins) {
     const fqn = this.name + aspect
     const types = cds.builtin.types
@@ -142,13 +142,15 @@ class CQN2SQLRenderer {
    */
   CREATE_elements(elements) {
     let sql = ''
+    let keys = ''
     for (let e in elements) {
       const definition = elements[e]
       if (definition.isAssociation) continue
+      if (definition.key) keys = `${keys}, ${this.quote(definition.name)}`
       const s = this.CREATE_element(definition)
-      if (s) sql += `${s}, `
+      if (s) sql += `, ${s}`
     }
-    return sql.slice(0, -2)
+    return `${sql.slice(2)}${keys && `, PRIMARY KEY(${keys.slice(2)})`}`
   }
 
   /**
@@ -491,8 +493,6 @@ class CQN2SQLRenderer {
    */
   INSERT_entries(q) {
     const { INSERT } = q
-    const entity = this.name(q.target?.name || INSERT.into.ref[0])
-    const alias = INSERT.into.as
     const elements = q.elements || q.target?.elements
     if (!elements && !INSERT.entries?.length) {
       return // REVISIT: mtx sends an insert statement without entries and no reference entity
@@ -504,19 +504,14 @@ class CQN2SQLRenderer {
     /** @type {string[]} */
     this.columns = columns
 
+    const alias = INSERT.into.as
+    const entity = this.name(q.target?.name || INSERT.into.ref[0])
     if (!elements) {
       this.entries = INSERT.entries.map(e => columns.map(c => e[c]))
       const param = this.param.bind(this, { ref: ['?'] })
       return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(c))}) VALUES (${columns.map(param)})`)
     }
 
-    const extractions = this.managed(
-      columns.map(c => ({ name: c })),
-      elements,
-      !!q.UPSERT,
-    )
-    const extraction = extractions.map(c => c.sql)
-
     // Include this.values for placeholders
     /** @type {unknown[][]} */
     this.entries = []
@@ -530,8 +525,9 @@ class CQN2SQLRenderer {
       this.entries = [[...this.values, stream]]
     }
 
+    const extractions = this._managed = this.managed(columns.map(c => ({ name: c })), elements)
     return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(c))
-      }) SELECT ${extraction} FROM json_each(?)`)
+      }) SELECT ${extractions.map(c => c.insert)} FROM json_each(?)`)
   }
 
   async *INSERT_entries_stream(entries, binaryEncoding = 'base64') {
@@ -569,7 +565,7 @@ class CQN2SQLRenderer {
 
           buffer += '"'
         } else {
-          if (elements[key]?.type in BINARY_TYPES) {
+          if (elements[key]?.type in this.BINARY_TYPES) {
             val = transformBase64(val)
           }
           buffer += `${keyJSON}${JSON.stringify(val)}`
@@ -617,7 +613,7 @@ class CQN2SQLRenderer {
 
           buffer += '"'
         } else {
-          if (elements[this.columns[key]]?.type in BINARY_TYPES) {
+          if (elements[this.columns[key]]?.type in this.BINARY_TYPES) {
             val = transformBase64(val)
           }
           buffer += `${sepsub}${val === undefined ? 'null' : JSON.stringify(val)}`
@@ -646,18 +642,7 @@ class CQN2SQLRenderer {
     const entity = this.name(q.target?.name || INSERT.into.ref[0])
     const alias = INSERT.into.as
     const elements = q.elements || q.target?.elements
-    const columns = INSERT.columns
-      || cds.error`Cannot insert rows without columns or elements`
-
-    const inputConverter = this.class._convertInput
-    const extraction = columns.map((c, i) => {
-      const extract = `value->>'$[${i}]'`
-      const element = elements?.[c]
-      const converter = element?.[inputConverter]
-      return converter?.(extract, element) || extract
-    })
-
-    this.columns = columns
+    const columns = this.columns = INSERT.columns || cds.error`Cannot insert rows without columns or elements`
 
     if (!elements) {
       this.entries = INSERT.rows
@@ -675,6 +660,10 @@ class CQN2SQLRenderer {
       this.entries = [[...this.values, stream]]
     }
 
+    const extraction = (this._managed = this.managed(columns.map(c => ({ name: c })), elements))
+      .slice(0, columns.length)
+      .map(c => c.converter(c.extract))
+
     return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(c))
       }) SELECT ${extraction} FROM json_each(?)`)
   }
@@ -686,7 +675,7 @@ class CQN2SQLRenderer {
    */
   INSERT_values(q) {
     let { columns, values } = q.INSERT
-    return this.INSERT_rows({ __proto__: q, INSERT: { __proto__: q.INSERT, columns, rows: [values] } })
+    return this.render({ __proto__: q, INSERT: { __proto__: q.INSERT, columns, rows: [values] } })
   }
 
   /**
@@ -737,14 +726,37 @@ class CQN2SQLRenderer {
    */
   UPSERT(q) {
     const { UPSERT } = q
-    const elements = q.target?.elements || {}
+
     let sql = this.INSERT({ __proto__: q, INSERT: UPSERT })
-    let keys = q.target?.keys
-    if (!keys) return this.sql = sql
-    keys = Object.keys(keys).filter(k => !keys[k].isAssociation && !keys[k].virtual)
+    if (!q.target?.keys) return sql
+    const keys = []
+    for (const k of ObjectKeys(q.target?.keys)) {
+      const element = q.target.keys[k]
+      if (element.isAssociation || element.virtual) continue
+      keys.push(k)
+    }
+
+    const elements = q.target?.elements || {}
+    // temporal data
+    for (const k of ObjectKeys(elements)) {
+      if (elements[k]['@cds.valid.from']) keys.push(k)
+    }
+
+    const keyCompare = keys
+      .map(k => `NEW.${this.quote(k)}=OLD.${this.quote(k)}`)
+      .join(' AND ')
+
+    const columns = this.columns // this.columns is computed as part of this.INSERT
+    const managed = this._managed.slice(0, columns.length)
+
+    const extractkeys = managed
+      .filter(c => keys.includes(c.name))
+      .map(c => `${c.onInsert || c.sql} as ${this.quote(c.name)}`)
 
-    let updateColumns = q.UPSERT.entries ? Object.keys(q.UPSERT.entries[0]) : this.columns
-    updateColumns = updateColumns.filter(c => {
+    const entity = this.name(q.target?.name || UPSERT.into.ref[0])
+    sql = `SELECT ${managed.map(c => c.upsert)} FROM (SELECT value, ${extractkeys} from json_each(?)) as NEW LEFT JOIN ${this.quote(entity)} AS OLD ON ${keyCompare}`
+
+    const updateColumns = columns.filter(c => {
       if (keys.includes(c)) return false //> keys go into ON CONFLICT clause
       let e = elements[c]
       if (!e) return true //> pass through to native SQL columns not in CDS model
@@ -754,14 +766,8 @@ class CQN2SQLRenderer {
       else return true
     }).map(c => `${this.quote(c)} = excluded.${this.quote(c)}`)
 
-    // temporal data
-    keys.push(...Object.values(q.target.elements).filter(e => e['@cds.valid.from']).map(e => e.name))
-
-    keys = keys.map(k => this.quote(k))
-    const conflict = updateColumns.length
-      ? `ON CONFLICT(${keys}) DO UPDATE SET ` + updateColumns
-      : `ON CONFLICT(${keys}) DO NOTHING`
-    return (this.sql = `${sql} WHERE true ${conflict}`)
+    return (this.sql = `INSERT INTO ${this.quote(entity)} (${columns.map(c => this.quote(c))}) ${sql
+      } WHERE TRUE ON CONFLICT(${keys.map(c => this.quote(c))}) DO ${updateColumns.length ? `UPDATE SET ${updateColumns}` : 'NOTHING'}`)
   }
 
   // UPDATE Statements ------------------------------------------------
@@ -790,7 +796,9 @@ class CQN2SQLRenderer {
       }
     }
 
-    const extraction = this.managed(columns, elements, true).map(c => `${this.quote(c.name)}=${c.sql}`)
+    const extraction = this.managed(columns, elements)
+      .filter((c, i) => columns[i] || c.onUpdate)
+      .map((c, i) => `${this.quote(c.name)}=${!columns[i] ? c.onUpdate : c.sql}`)
 
     sql += ` SET ${extraction}`
     if (where) sql += ` WHERE ${this.where(where)}`
@@ -1042,56 +1050,104 @@ class CQN2SQLRenderer {
   }
 
   /**
-   * Convers the columns array into an array of SQL expressions that extract the correct value from inserted JSON data
+   * Converts the columns array into an array of SQL expressions that extract the correct value from inserted JSON data
    * @param {object[]} columns
    * @param {import('./infer/cqn').elements} elements
    * @param {Boolean} isUpdate
    * @returns {string[]} Array of SQL expressions for processing input JSON data
    */
-  managed(columns, elements, isUpdate = false) {
-    const annotation = isUpdate ? '@cds.on.update' : '@cds.on.insert'
+  managed(columns, elements) {
+    const cdsOnInsert = '@cds.on.insert'
+    const cdsOnUpdate = '@cds.on.update'
+
     const { _convertInput } = this.class
     // Ensure that missing managed columns are added
     const requiredColumns = !elements
       ? []
-      : Object.keys(elements)
-        .filter(
-          e =>
-            (elements[e]?.[annotation] || (!isUpdate && elements[e]?.default && !elements[e].virtual && !elements[e].isAssociation)) &&
-            !columns.find(c => c.name === e),
-        )
+      : ObjectKeys(elements)
+        .filter(e => {
+          const element = elements[e]
+          // Actual mandatory check
+          if (!(element.default || element[cdsOnInsert] || element[cdsOnUpdate])) return false
+          // Physical column check
+          if (!element || element.virtual || element.isAssociation) return false
+          // Existence check
+          if (columns.find(c => c.name === e)) return false
+          return true
+        })
         .map(name => ({ name, sql: 'NULL' }))
 
+    const keys = ObjectKeys(elements).filter(e => elements[e].key && !elements[e].isAssociation)
+    const keyZero = keys[0] && this.quote(keys[0])
+
     return [...columns, ...requiredColumns].map(({ name, sql }) => {
-      let element = elements?.[name] || {}
-      if (!sql) sql = `value->>'$."${name}"'`
-
-      let converter = element[_convertInput]
-      if (converter && sql[0] !== '$') sql = converter(sql, element)
-
-      let val = _managed[element[annotation]?.['=']]
-      if (val) sql = `coalesce(${sql}, ${this.func({ func: 'session_context', args: [{ val, param: false }] })})`
-      else if (!isUpdate && element.default) {
-        const d = element.default
-        if (d.val !== undefined || d.ref?.[0] === '$now') {
-          // REVISIT: d.ref is not used afterwards
-          sql = `(CASE WHEN json_type(value,'$."${name}"') IS NULL THEN ${this.defaultValue(d.val) // REVISIT: this.defaultValue is a strange function
-            } ELSE ${sql} END)`
-        }
+      const element = elements?.[name] || {}
+
+      const converter = a => element[_convertInput]?.(a, element) || a
+      let extract
+      if (!sql) {
+        ({ sql, extract } = this.managed_extract(name, element, converter))
+      } else {
+        extract = sql = converter(sql)
       }
+      // if (sql[0] !== '$') sql = converter(sql, element)
+
+      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 })
+      let onUpdate = this.managed_session_context(element[cdsOnUpdate]?.['='])
+
+      if (onInsert) onInsert = this.expr(onInsert)
+      if (onUpdate) onUpdate = this.expr(onUpdate)
+
+      const qname = this.quote(name)
+
+      const insert = onInsert ? this.managed_default(name, converter(onInsert), sql) : sql
+      const update = onUpdate ? this.managed_default(name, converter(onUpdate), sql) : sql
+      const upsert = keyZero && (
+        // upsert requires the keys to be provided for the existance join (default values optional)
+        element.key
+          // If both insert and update have the same managed definition exclude the old value check
+          || (onInsert && onUpdate && insert === update)
+          ? `${insert} as ${qname}`
+          : `CASE WHEN OLD.${keyZero} IS NULL THEN ${
+          // If key of old is null execute insert
+          insert
+          } ELSE ${
+          // Else execute managed update or keep old if no new data if provided
+          onUpdate ? update : this.managed_default(name, `OLD.${qname}`, update)
+          } END as ${qname}`
+      )
 
-      return { name, sql }
+      return {
+        name, // Element name
+        sql, // Reference SQL
+        extract, // Source SQL
+        converter, // Converter logic
+        // action specific full logic
+        insert, update, upsert,
+        // action specific isolated logic
+        onInsert, onUpdate
+      }
     })
   }
 
-  /**
-   * Returns the default value
-   * @param {string} defaultValue
-   * @returns {string}
-   */
-  // REVISIT: This is a strange method, also overridden inconsistently in postgres
-  defaultValue(defaultValue = this.context.timestamp.toISOString()) {
-    return typeof defaultValue === 'string' ? this.string(defaultValue) : defaultValue
+  managed_extract(name, element, converter) {
+    const { UPSERT, INSERT } = this.cqn
+    const extract = !(INSERT?.entries || UPSERT?.entries) && (INSERT?.rows || UPSERT?.rows)
+      ? `value->>'$[${this.columns.indexOf(name)}]'`
+      : `value->>'$."${name.replace(/"/g, '""')}"'`
+    const sql = converter?.(extract) || extract
+    return { extract, sql }
+  }
+
+  managed_session_context(src) {
+    const val = _managed[src]
+    return val && { func: 'session_context', args: [{ val, param: false }] }
+  }
+
+  managed_default(name, managed, src) {
+    return `(CASE WHEN json_type(value,${this.managed_extract(name).extract.slice(8)}) IS NULL THEN ${managed} ELSE ${src} END)`
   }
 }
 

package/lib/cqn4sql.js

@@ -266,10 +266,10 @@ function cqn4sql(originalQuery, model) {
         const id = localized(r.queryArtifact)
         args.push({ ref: [r.args ? { id, args: r.args } : id], as: r.alias })
       }
-      from = { join: 'left', args, on: [] }
+      from = { join: r.join || 'left', args, on: [] }
       r.children.forEach(c => {
         from = joinForBranch(from, c)
-        from = { join: 'left', args: [from], on: [] }
+        from = { join: c.join || 'left', args: [from], on: [] }
       })
     })
     return from.args.length > 1 ? from : from.args[0]
@@ -309,7 +309,7 @@ function cqn4sql(originalQuery, model) {
       }
       if (node.children) {
         node.children.forEach(c => {
-          lhs = { join: 'left', args: [lhs], on: [] }
+          lhs = { join: c.join || 'left', args: [lhs], on: [] }
           lhs = joinForBranch(lhs, c)
         })
       }
@@ -2093,11 +2093,6 @@ function cqn4sql(originalQuery, model) {
       const unmanagedOn = onCondFor(inWhere ? next : current, inWhere ? current : next, inWhere)
       on.push(...(customWhere && hasLogicalOr(unmanagedOn) ? [asXpr(unmanagedOn)] : unmanagedOn))
     }
-    // infix filter conditions are wrapped in `xpr` when added to the on-condition
-    if (customWhere) {
-      const filter = getTransformedTokenStream(customWhere, next)
-      on.push(...['and', ...(hasLogicalOr(filter) ? [asXpr(filter)] : filter)])
-    }
 
     const subquerySource = assocTarget(nextDefinition) || nextDefinition
     const id = localized(subquerySource)
@@ -2115,6 +2110,26 @@ function cqn4sql(originalQuery, model) {
       ],
       where: on,
     }
+    if (next.pathExpressionInsideFilter) {
+      SELECT.where = customWhere
+      const transformedExists = transformSubquery({ SELECT })
+      // infix filter conditions are wrapped in `xpr` when added to the on-condition
+      if (transformedExists.SELECT.where) {
+        on.push(
+          ...[
+            'and',
+            ...(hasLogicalOr(transformedExists.SELECT.where)
+              ? [asXpr(transformedExists.SELECT.where)]
+              : transformedExists.SELECT.where),
+          ],
+        )
+      }
+      transformedExists.SELECT.where = on
+      return transformedExists.SELECT
+    } else if (customWhere) {
+      const filter = getTransformedTokenStream(customWhere, next)
+      on.push(...['and', ...(hasLogicalOr(filter) ? [asXpr(filter)] : filter)])
+    }
     return SELECT
   }
 

package/lib/infer/index.js

@@ -184,16 +184,13 @@ function infer(originalQuery, model) {
           if (e.target) {
             // only fk access in infix filter
             const nextStep = ref[1]?.id || ref[1]
-            // no unmanaged assoc in infix filter path
-            if (!expandOrExists && e.on) {
-              const err = `Unexpected unmanaged association “${e.name}” in filter expression of “${$baseLink.definition.name}”`
-              throw new Error(err)
+            if (isNonForeignKeyNavigation(e, nextStep)) {
+              if (expandOrExists) {
+                Object.defineProperty($baseLink, 'pathExpressionInsideFilter', { value: true })
+              } else {
+                rejectNonFkNavigation(e, e.on ? $baseLink.definition.name : nextStep)
+              }
             }
-            // no non-fk traversal in infix filter
-            if (!expandOrExists && nextStep && !isForeignKeyOf(nextStep, e))
-              throw new Error(
-                `Only foreign keys of “${e.name}” can be accessed in infix filter, but found “${nextStep}”`,
-              )
           }
           arg.$refLinks.push({ definition: e, target: definition })
           // filter paths are flattened
@@ -226,7 +223,7 @@ function infer(originalQuery, model) {
               // don't miss an exists within an expression
               token.xpr.forEach(walkTokenStream)
             } else {
-              attachRefLinksToArg(token, arg.$refLinks[i], existsPredicate)
+              attachRefLinksToArg(token, arg.$refLinks[i], existsPredicate || expandOrExists)
               existsPredicate = false
             }
           }
@@ -235,6 +232,7 @@ function infer(originalQuery, model) {
       }
       i += 1
     }
+    if ($baseLink?.pathExpressionInsideFilter) Object.defineProperty(arg, 'join', { value: 'inner' })
     const { definition, target } = arg.$refLinks[arg.$refLinks.length - 1]
     if (definition.value) {
       // nested calculated element
@@ -542,9 +540,19 @@ function infer(originalQuery, model) {
             const elements = getDefinition(definition.target)?.elements || definition.elements
             if (elements && id in elements) {
               const element = elements[id]
-              rejectNonFkAccess(element)
+              if (inInfixFilter) {
+                const nextStep = column.ref[1]?.id || column.ref[1]
+                if (isNonForeignKeyNavigation(element, nextStep)) {
+                  if (inExists) {
+                    Object.defineProperty($baseLink, 'pathExpressionInsideFilter', { value: true })
+                  } else {
+                    rejectNonFkNavigation(element, element.on ? $baseLink.definition.name : nextStep)
+                  }
+                }
+              }
               const resolvableIn = getDefinition(definition.target) || target
-              column.$refLinks.push({ definition: elements[id], target: resolvableIn })
+              const $refLink = { definition: elements[id], target: resolvableIn }
+              column.$refLinks.push($refLink)
             } else {
               stepNotFoundInPredecessor(id, definition.name)
             }
@@ -593,7 +601,16 @@ function infer(originalQuery, model) {
 
           const target = getDefinition(definition.target) || column.$refLinks[i - 1].target
           if (element) {
-            if ($baseLink) rejectNonFkAccess(element)
+            if ($baseLink && inInfixFilter) {
+              const nextStep = column.ref[i + 1]?.id || column.ref[i + 1]
+              if (isNonForeignKeyNavigation(element, nextStep)) {
+                if (inExists) {
+                  Object.defineProperty($baseLink, 'pathExpressionInsideFilter', { value: true })
+                } else {
+                  rejectNonFkNavigation(element, element.on ? $baseLink.definition.name : nextStep)
+                }
+              }
+            }
             const $refLink = { definition: elements[id], target }
             column.$refLinks.push($refLink)
           } else if (firstStepIsSelf) {
@@ -637,7 +654,7 @@ function infer(originalQuery, model) {
               skipJoinsForFilter = true
             } else if (token.ref || token.xpr) {
               inferQueryElement(token, false, column.$refLinks[i], {
-                inExists: skipJoinsForFilter,
+                inExists: skipJoinsForFilter || inExists,
                 inExpr: !!token.xpr,
                 inInfixFilter: true,
               })
@@ -646,7 +663,7 @@ function infer(originalQuery, model) {
                 applyToFunctionArgs(token.args, inferQueryElement, [
                   false,
                   column.$refLinks[i],
-                  { inExists: skipJoinsForFilter, inExpr: true, inInfixFilter: true },
+                  { inExists: skipJoinsForFilter || inExists, inExpr: true, inInfixFilter: true },
                 ])
               }
             }
@@ -700,31 +717,11 @@ function infer(originalQuery, model) {
             }
           }
         }
-
-        /**
-         * Check if the next step in the ref is foreign key of `assoc`
-         * if not, an error is thrown.
-         *
-         * @param {CSN.Element} assoc if this is an association, the next step must be a foreign key of the element.
-         */
-        function rejectNonFkAccess(assoc) {
-          if (inInfixFilter && assoc.target) {
-            // only fk access in infix filter
-            const nextStep = column.ref[i + 1]?.id || column.ref[i + 1]
-            // no unmanaged assoc in infix filter path
-            if (!inExists && assoc.on) {
-              const err = `Unexpected unmanaged association “${assoc.name}” in filter expression of “${$baseLink.definition.name}”`
-              throw new Error(err)
-            }
-            // no non-fk traversal in infix filter in non-exists path
-            if (nextStep && !assoc.on && !isForeignKeyOf(nextStep, assoc))
-              throw new Error(
-                `Only foreign keys of “${assoc.name}” can be accessed in infix filter, but found “${nextStep}”`,
-              )
-          }
-        }
       })
 
+      // we need inner joins for the path expressions inside filter expressions after exists predicate
+      if ($baseLink?.pathExpressionInsideFilter) Object.defineProperty(column, 'join', { value: 'inner' })
+
       // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
       if (column.expand) {
         const { $refLinks } = column
@@ -1214,6 +1211,26 @@ function infer(originalQuery, model) {
   }
 }
 
+/**
+ * Determines if a given association is a non-foreign key navigation.
+ *
+ * @param {Object} assoc - The association.
+ * @param {Object} nextStep - The next step in the navigation path.
+ * @returns {boolean} - Returns true if the next step is a non-foreign key navigation, otherwise false.
+ */
+function isNonForeignKeyNavigation(assoc, nextStep) {
+  if (!nextStep || !assoc.target) return false
+
+  return assoc.on || !isForeignKeyOf(nextStep, assoc)
+}
+
+function rejectNonFkNavigation(assoc, additionalInfo) {
+  if (assoc.on) {
+    throw new Error(`Unexpected unmanaged association “${assoc.name}” in filter expression of “${additionalInfo}”`)
+  }
+  throw new Error(`Only foreign keys of “${assoc.name}” can be accessed in infix filter, but found “${additionalInfo}”`)
+}
+
 /**
  * Returns true if e is a foreign key of assoc.
  * this function is also compatible with unfolded csn (UCSN),

package/lib/infer/join-tree.js

@@ -181,6 +181,7 @@ class JoinTree {
     // if no root node was found, the column is selected from a subquery
     if (!node) return
     while (i < col.ref.length) {
+      if(col.join === 'inner') node.join = 'inner'
       const step = col.ref[i]
       const { where, args } = step
       const id = joinId(step, args, where)

package/lib/search.js

@@ -114,7 +114,7 @@ const _getSearchableColumns = entity => {
     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]) {
+        if (next?.isAssociation && !c.ref[i + 1]) {
           const searchInTarget = _getSearchableColumns(next._target)
           searchInTarget.forEach(elementRefInTarget => {
             searchableColumns.push({ ref: c.ref.concat(...elementRefInTarget.ref) })

package/package.json

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