@cap-js/db-service 1.14.1 → 1.15.1

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.15.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.15.0...db-service-v1.15.1) (2024-11-18)
+
+
+### Fixed
+
+* cross joins without on-condition ([#899](https://github.com/cap-js/cds-dbs/issues/899)) ([c61a04a](https://github.com/cap-js/cds-dbs/commit/c61a04aa4394511100f97cfebd362a2298221d96))
+* pseudo paths in expands ([#896](https://github.com/cap-js/cds-dbs/issues/896)) ([014c50c](https://github.com/cap-js/cds-dbs/commit/014c50cec9c2de1ee3dfdf1861940ae0e2520c16))
+
+## [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)
 
 

package/lib/cqn2sql.js

@@ -363,8 +363,7 @@ class CQN2SQLRenderer {
       return _aliased(this.quote(this.name(z)))
     }
     if (from.SELECT) return _aliased(`(${this.SELECT(from)})`)
-    if (from.join)
-      return `${this.from(from.args[0])} ${from.join} JOIN ${this.from(from.args[1])} ON ${this.where(from.on)}`
+    if (from.join) return `${this.from(from.args[0])} ${from.join} JOIN ${this.from(from.args[1])}${from.on ? ` ON ${this.where(from.on)}` : ''}`
   }
 
   /**

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)
         })
       }
@@ -1868,13 +1868,18 @@ function cqn4sql(originalQuery, model) {
               value: [],
               writable: true,
             })
+            let pseudoPath = false
             ref.reduce((prev, res, i) => {
               if (res === '$self')
                 // next is resolvable in entity
                 return prev
               if (res in pseudos.elements) {
+                pseudoPath = true
                 thing.$refLinks.push({ definition: pseudos.elements[res], target: pseudos })
                 return pseudos.elements[res]
+              } else if (pseudoPath) {
+                thing.$refLinks.push({ definition: {}, target: pseudos })
+                return prev?.elements[res]
               }
               const definition =
                 prev?.elements?.[res] || getDefinition(prev?.target)?.elements[res] || pseudos.elements[res]
@@ -2093,11 +2098,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 +2115,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

@@ -172,28 +172,30 @@ function infer(originalQuery, model) {
     if (!ref) return
     init$refLinks(arg)
     let i = 0
+    let pseudoPath = false
     for (const step of ref) {
       const id = step.id || step
       if (i === 0) {
-        // infix filter never have table alias
-        // we need to search for first step in ´model.definitions[infixAlias]`
-        if ($baseLink) {
+        if (id in pseudos.elements) {
+          // pseudo path
+          arg.$refLinks.push({ definition: pseudos.elements[id], target: pseudos })
+          pseudoPath = true // only first path step must be well defined
+        } else if ($baseLink) {
+          // infix filter never have table alias
+          // we need to search for first step in ´model.definitions[infixAlias]`
           const { definition } = $baseLink
           const elements = getDefinition(definition.target)?.elements || definition.elements
           const e = elements?.[id] || cds.error`"${id}" not found in the elements of "${definition.name}"`
           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
@@ -204,11 +206,15 @@ function infer(originalQuery, model) {
           const definition = getDefinition(id) || cds.error`"${id}" not found in the definitions of your model`
           arg.$refLinks[0] = { definition, target: definition }
         }
+      } else if (arg.ref[0] === '$user' && pseudoPath) {
+        // `$user.some.unknown.element` -> no error
+        arg.$refLinks.push({ definition: {}, target: pseudos })
       } else {
         const recent = arg.$refLinks[i - 1]
         const { elements } = getDefinition(recent.definition.target) || recent.definition
         const e = elements[id]
-        if (!e) throw new Error(`"${id}" not found in the elements of "${arg.$refLinks[i - 1].definition.name}"`)
+        const notFoundIn = pseudoPath ? arg.ref[i - 1] : getFullPathForLinkedArg(arg)
+        if (!e) throw new Error(`"${id}" not found in the elements of "${notFoundIn}"`)
         arg.$refLinks.push({ definition: e, target: getDefinition(e.target) || e })
       }
       arg.$refLinks[i].alias = !ref[i + 1] && arg.as ? arg.as : id.split('.').pop()
@@ -226,7 +232,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 +241,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 +549,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 +610,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 +663,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 +672,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 +726,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 +1220,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.1",
+  "version": "1.15.1",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {