@cap-js/db-service 1.5.1 → 1.6.1

package/lib/cqn4sql.js

@@ -54,88 +54,84 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     transformedQuery = transformQueryForInsertUpsert(kind)
   } else {
     const queryProp = inferred[kind]
-    if (!inferred.STREAM?.from && inferred.STREAM?.into) {
-      transformedQuery = transformStreamQuery()
-    } else {
-      const { entity, where } = queryProp
-      const from = queryProp.from
+    const { entity, where } = queryProp
+    const from = queryProp.from
 
-      const transformedProp = { __proto__: queryProp } // IMPORTANT: don't lose anything you might not know of
+    const transformedProp = { __proto__: queryProp } // IMPORTANT: don't lose anything you might not know of
 
-      // Transform the existing where, prepend table aliases, and so on...
-      if (where) {
-        transformedProp.where = getTransformedTokenStream(where)
-      }
+    // Transform the existing where, prepend table aliases, and so on...
+    if (where) {
+      transformedProp.where = getTransformedTokenStream(where)
+    }
 
-      // Transform the from clause: association path steps turn into `WHERE EXISTS` subqueries.
-      // The already transformed `where` clause is then glued together with the resulting subqueries.
-      const { transformedWhere, transformedFrom } = getTransformedFrom(from || entity, transformedProp.where)
-      const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
+    // Transform the from clause: association path steps turn into `WHERE EXISTS` subqueries.
+    // The already transformed `where` clause is then glued together with the resulting subqueries.
+    const { transformedWhere, transformedFrom } = getTransformedFrom(from || entity, transformedProp.where)
+    const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
 
-      if (inferred.SELECT) {
-        transformedQuery = transformSelectQuery(queryProp, transformedFrom, transformedWhere, transformedQuery)
-      } else {
-        if (from) {
-          transformedProp.from = transformedFrom
-        } else if (!queryNeedsJoins) {
-          transformedProp.entity = transformedFrom
-        }
+    if (inferred.SELECT) {
+      transformedQuery = transformSelectQuery(queryProp, transformedFrom, transformedWhere, transformedQuery)
+    } else {
+      if (from) {
+        transformedProp.from = transformedFrom
+      } else if (!queryNeedsJoins) {
+        transformedProp.entity = transformedFrom
+      }
 
-        if (transformedWhere?.length > 0) {
-          transformedProp.where = transformedWhere
-        }
+      if (transformedWhere?.length > 0) {
+        transformedProp.where = transformedWhere
+      }
 
-        transformedQuery[kind] = transformedProp
+      transformedQuery[kind] = transformedProp
 
-        if (inferred.UPDATE?.with) {
-          Object.entries(inferred.UPDATE.with).forEach(([key, val]) => {
-            const transformed = getTransformedTokenStream([val])
-            inferred.UPDATE.with[key] = transformed[0]
-          })
-        }
+      if (inferred.UPDATE?.with) {
+        Object.entries(inferred.UPDATE.with).forEach(([key, val]) => {
+          const transformed = getTransformedTokenStream([val])
+          inferred.UPDATE.with[key] = transformed[0]
+        })
       }
+    }
 
-      if (queryNeedsJoins) {
-        if (inferred.UPDATE || inferred.DELETE) {
-          const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
-          const subquery = {
-            SELECT: {
-              from: { ...transformedFrom },
-              columns: [], // primary keys of the query target will be added later
-              where: [...transformedProp.where],
-            },
-          }
-          // The alias of the original query is now the alias for the subquery
-          // so that potential references in the where clause to the alias match.
-          // Hence, replace the alias of the original query with the next
-          // available alias, so that each alias is unique.
-          const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
-          transformedFrom.as = uniqueSubqueryAlias
-
-          // calculate the primary keys of the target entity, there is always exactly
-          // one query source for UPDATE / DELETE
-          const queryTarget = Object.values(originalQuery.sources)[0]
-          const keys = Object.values(queryTarget.elements).filter(e => e.key === true)
-          const primaryKey = { list: [] }
-          keys.forEach(k => {
-            // cqn4sql will add the table alias to the column later, no need to add it here
-            subquery.SELECT.columns.push({ ref: [k.name] })
-
-            // add the alias of the main query to the list of primary key references
-            primaryKey.list.push({ ref: [transformedFrom.as, k.name] })
-          })
+    if (queryNeedsJoins) {
+      if (inferred.UPDATE || inferred.DELETE) {
+        const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
+        const subquery = {
+          SELECT: {
+            from: { ...transformedFrom },
+            columns: [], // primary keys of the query target will be added later
+            where: [...transformedProp.where],
+          },
+        }
+        // The alias of the original query is now the alias for the subquery
+        // so that potential references in the where clause to the alias match.
+        // Hence, replace the alias of the original query with the next
+        // available alias, so that each alias is unique.
+        const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
+        transformedFrom.as = uniqueSubqueryAlias
+
+        // calculate the primary keys of the target entity, there is always exactly
+        // one query source for UPDATE / DELETE
+        const queryTarget = Object.values(originalQuery.sources)[0]
+        const keys = Object.values(queryTarget.elements).filter(e => e.key === true)
+        const primaryKey = { list: [] }
+        keys.forEach(k => {
+          // cqn4sql will add the table alias to the column later, no need to add it here
+          subquery.SELECT.columns.push({ ref: [k.name] })
+
+          // add the alias of the main query to the list of primary key references
+          primaryKey.list.push({ ref: [transformedFrom.as, k.name] })
+        })
 
-          const transformedSubquery = cqn4sql(subquery)
+        const transformedSubquery = cqn4sql(subquery)
 
-          // replace where condition of original query with the transformed subquery
-          // correlate UPDATE / DELETE query with subquery by primary key matches
-          transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
+        // replace where condition of original query with the transformed subquery
+        // correlate UPDATE / DELETE query with subquery by primary key matches
+        transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
 
-          if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
-          else transformedQuery.DELETE.from = transformedFrom
-        } else {
-          transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
-        }
+        if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
+        else transformedQuery.DELETE.from = transformedFrom
+      } else {
+        transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
       }
     }
   }
@@ -207,29 +203,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     return transformedQuery
   }
 
-  /**
-   * Transforms a stream query, replacing the `where` and `into` clauses after processing.
-   *
-   * @param {object} inferred - The inferred object containing the STREAM query.
-   * @param {object} transformedQuery - The query object to be transformed.
-   *
-   * @returns {object} - The transformed query with updated STREAM clauses.
-   */
-  function transformStreamQuery() {
-    const { into, where } = inferred.STREAM
-    const transformedProp = { __proto__: inferred.STREAM }
-    if (where) {
-      transformedProp.where = getTransformedTokenStream(where)
-    }
-    const { transformedWhere, transformedFrom } = getTransformedFrom(into, transformedProp.where)
-    if (transformedWhere?.length > 0) {
-      transformedProp.where = transformedWhere
-    }
-    transformedProp.into = transformedFrom
-    transformedQuery.STREAM = transformedProp
-    return transformedQuery
-  }
-
   /**
    * Transforms a search expression to a WHERE clause for a SELECT operation.
    *
@@ -415,13 +388,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     return transformedColumns
 
     function handleSubquery(col) {
-      if (!col.SELECT.from.as) {
-        const uniqueSubqueryAlias = inferred.joinTree.addNextAvailableTableAlias(
-          getLastStringSegment(col.SELECT.from.ref[col.SELECT.from.ref.length - 1]),
-          originalQuery.outerQueries,
-        )
-        Object.defineProperty(col.SELECT.from, 'uniqueSubqueryAlias', { value: uniqueSubqueryAlias })
-      }
       transformedColumns.push(() => {
         const res = transformSubquery(col)
         if (col.as) res.as = col.as
@@ -469,7 +435,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       }
 
       let columnAlias = col.as || (col.isJoinRelevant ? col.flatName : null)
-      const refNavigation = col.ref.slice(col.ref[0] === tableAlias ? 1 : 0).join('_')
+      const refNavigation = col.ref.slice(col.$refLinks[0].definition.kind !== 'element' ? 1 : 0).join('_')
       if (!columnAlias && col.flatName && col.flatName !== refNavigation) columnAlias = refNavigation
 
       if (col.$refLinks.some(link => link.definition._target?.['@cds.persistence.skip'] === true)) return
@@ -945,7 +911,18 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       Object.defineProperty(q, 'outerQueries', { value: outerQueries })
     }
     if (isLocalized(inferred.target)) q.SELECT.localized = true
+    if (q.SELECT.from.ref && !q.SELECT.from.as) assignUniqueSubqueryAlias()
     return cqn4sql(q, model)
+
+    function assignUniqueSubqueryAlias() {
+      if (q.SELECT.from.uniqueSubqueryAlias) return
+      const last = q.SELECT.from.ref.at(-1)
+      const uniqueSubqueryAlias = inferred.joinTree.addNextAvailableTableAlias(
+        getLastStringSegment(last.id||last),
+        originalQuery.outerQueries,
+      )
+      Object.defineProperty(q.SELECT.from, 'uniqueSubqueryAlias', { value: uniqueSubqueryAlias })
+    }
   }
 
   /**
@@ -998,7 +975,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
      * @returns {boolean} true if the element is a managed association and the model is flat
      */
     function isManagedAssocInFlatMode(e) {
-      return model.meta.transformation === 'odata' && e.isAssociation && e.keys
+      return (
+        (model.meta.transformation === 'odata' || model.meta.unfolded?.some(u => u === 'assocs')) &&
+        e.isAssociation &&
+        e.keys
+      )
     }
   }
 
@@ -1051,25 +1032,32 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (!column) return column
     if (column.val || column.func || column.SELECT) return [column]
 
+    const structsAreUnfoldedAlready = model.meta.unfolded?.some(u => u === 'structs')
     let { baseName, columnAlias, tableAlias } = names
     const { exclude, replace } = excludeAndReplace || {}
     const { $refLinks, flatName, isJoinRelevant } = column
     let leafAssoc
     let element = $refLinks ? $refLinks[$refLinks.length - 1].definition : column
     if (isWildcard && element.type === 'cds.LargeBinary') return []
-    if (element.on) return [] // unmanaged doesn't make it into columns
+    if (element.on && !element.keys) return [] // unmanaged doesn't make it into columns
     else if (element.virtual === true) return []
     else if (!isJoinRelevant && flatName) baseName = flatName
     else if (isJoinRelevant) {
       const leaf = column.$refLinks[column.$refLinks.length - 1]
       leafAssoc = [...column.$refLinks].reverse().find(link => link.definition.isAssociation)
-      const { foreignKeys } = leafAssoc.definition
-      if (foreignKeys && leaf.alias in foreignKeys) {
+      let elements
+      //> REVISIT: remove once UCSN is standard (no more .foreignKeys)
+      elements = leafAssoc.definition.elements || leafAssoc.definition.foreignKeys
+      if (elements && leaf.alias in elements) {
         element = leafAssoc.definition
         baseName = getFullName(leafAssoc.definition)
         columnAlias = column.ref.slice(0, -1).map(idOnly).join('_')
       } else baseName = getFullName(column.$refLinks[column.$refLinks.length - 1].definition)
-    } else baseName = baseName ? `${baseName}_${element.name}` : getFullName(element)
+    } else if (!baseName && structsAreUnfoldedAlready) {
+      baseName = element.name // name is already fully constructed
+    } else {
+      baseName = baseName ? `${baseName}_${element.name}` : getFullName(element)
+    }
 
     // now we have the name of the to be expanded column
     // it could be a structure, an association or a scalar
@@ -1289,7 +1277,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
             transformedTokenStream.push({ list: [] })
           }
         } else {
-          transformedTokenStream.push({ list: getTransformedTokenStream(token.list) })
+          const { list } = token
+          if (list.every(e => e.val)) // no need for transformation
+            transformedTokenStream.push({ list })
+          else transformedTokenStream.push({ list: getTransformedTokenStream(list, $baseLink) })
         }
       } else if (tokenStream.length === 1 && token.val && $baseLink) {
         // infix filter - OData variant w/o mentioning key --> flatten out and compare each leaf to token.val
@@ -1418,19 +1409,16 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
     if (flatRhs) {
       const flatLhs = flattenWithBaseName(token)
-
-      //REVISIT: Early exit here? We kndow we cant compare the structs, however we do not know exactly why
-      //        --> calculate error message or exit early? See test "proper error if structures cannot be compared / too many elements on lhs"
-      if (flatRhs.length !== flatLhs.length)
-        // make sure we can compare both structures
+      // make sure we can compare both structures
+      if (flatRhs.length !== flatLhs.length) {
         throw new Error(
           `Can't compare "${definition.name}" with "${
             value.$refLinks[value.$refLinks.length - 1].definition.name
           }": the operands must have the same structure`,
         )
-      const pathNotFoundErr = []
+      }
+
       const boolOp = notEqOps.some(([f, s]) => operator[0] === f && operator[1] === s) ? 'or' : 'and'
-      const rhsPath = value.ref.join('.') // original path of the comparison, used in error message
       while (flatLhs.length > 0) {
         // retrieve and remove one flat element from LHS and search for it in RHS (remove it there too)
         const { ref, _csnPath: lhs_csnPath } = flatLhs.shift()
@@ -1439,20 +1427,16 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           // all following steps must also be part of lhs
           return lhs_csnPath.slice(1).every((val, i) => val === rhs_csnPath[i + 1]) // first step is name of struct -> ignore
         })
+        // not found in rhs --> exit
         if (indexOfElementOnRhs === -1) {
-          pathNotFoundErr.push(`Path "${lhs_csnPath.slice(1).join('.')}" not found in "${rhsPath}"`)
-          continue
+          const lhsPath = token.ref.join('.')
+          const rhsPath = value.ref.join('.')
+          throw new Error(`Can't compare "${lhsPath}" with "${rhsPath}": the operands must have the same structure`)
         }
         const rhs = flatRhs.splice(indexOfElementOnRhs, 1)[0] // remove the element also from RHS
         result.push({ ref }, ...operator, rhs)
         if (flatLhs.length > 0) result.push(boolOp)
       }
-      if (flatRhs.length) {
-        // if we still have elements in flatRhs -> those were not found in lhs
-        const lhsPath = token.ref.join('.') // original path of the comparison, used in error message
-        flatRhs.forEach(t => pathNotFoundErr.push(`Path "${t._csnPath.slice(1).join('.')}" not found in "${lhsPath}"`))
-        throw new Error(`Can't compare "${lhsPath}" with "${rhsPath}": ${pathNotFoundErr.join(', ')}`)
-      }
     } else {
       // compare with value
       const flatLhs = flattenWithBaseName(token)
@@ -1647,7 +1631,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    * @returns {boolean}
    */
   function isStructured(elt) {
-    return Boolean(elt?.elements && elt.kind === 'element')
+    return Boolean(elt?.kind !== 'entity' && elt?.elements && !elt.isAssociation)
   }
 
   /**
@@ -1774,7 +1758,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           else {
             const lhsLeafArt = lhs.ref && lhs.$refLinks[lhs.$refLinks.length - 1].definition
             const rhsLeafArt = rhs.ref && rhs.$refLinks[rhs.$refLinks.length - 1].definition
-            if (lhsLeafArt?.target || rhsLeafArt?.target) {
+            if ((lhsLeafArt?.target && rhsLeafArt?.target) || (lhsLeafArt?.elements && rhsLeafArt?.elements)) {
               if (rhs.$refLinks[0].definition !== assocRefLink.definition) {
                 rhs.ref.unshift(targetSideRefLink.alias)
                 rhs.$refLinks.unshift(targetSideRefLink)
@@ -2020,7 +2004,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    * @returns the flat name of the element
    */
   function getFullName(node, name = node.name) {
-    if (node.parent.kind === 'entity') return name
+    // REVISIT: this is an unfortunate implementation
+    if (!node.parent || node.parent.kind === 'entity') return name
 
     return getFullName(node.parent, `${node.parent.name}_${name}`)
   }

package/lib/fill-in-keys.js

@@ -8,7 +8,12 @@ const generateUUIDandPropagateKeys = (target, data, event) => {
   if (!data) return
   const keys = target.keys
   for (const key in keys) {
-    if (keys[key].type === 'cds.UUID' && !data[key] && event === 'CREATE') {
+    const keyElement = keys[key]
+    if (
+      keyElement.type === 'cds.UUID' &&
+      !data[key] && event === 'CREATE' && 
+      !keyElement.parent.elements[keyElement._foreignKey4]?._isAssociationStrict
+    ) {
       data[key] = cds.utils.uuid()
     }
   }

package/lib/infer/cqn.d.ts

@@ -9,9 +9,6 @@ export type SELECT = cqn.SELECT & linkedQuery
 export type INSERT = cqn.INSERT & linkedQuery
 export type UPSERT = cqn.UPSERT & linkedQuery
 export type UPDATE = cqn.UPDATE & linkedQuery
-export type STREAM = {
-  STREAM: { into: cqn.name | ref; data: ReadableStream<Buffer>; from: cqn.source; column?: ref; where: predicate }
-} & linkedQuery
 export type DELETE = cqn.DELETE & linkedQuery
 export type CREATE = cqn.CREATE & linkedQuery
 export type DROP = cqn.DROP & linkedQuery

package/lib/infer/index.js

@@ -36,8 +36,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
     inferred.UPDATE ||
     inferred.DELETE ||
     inferred.CREATE ||
-    inferred.DROP ||
-    inferred.STREAM
+    inferred.DROP
 
   // cache for already processed calculated elements
   const alreadySeenCalcElements = new Set()
@@ -58,7 +57,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       writable: true,
     },
   })
-  if (originalQuery.SELECT || originalQuery.DELETE || originalQuery.UPDATE || originalQuery.STREAM) {
+  if (originalQuery.SELECT || originalQuery.DELETE || originalQuery.UPDATE) {
     const $combinedElements = inferCombinedElements()
     /**
      * TODO: this function is currently only called on DELETE's
@@ -100,12 +99,12 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       if (!target) throw new Error(`"${first}" not found in the definitions of your model`)
       if (ref.length > 1) {
         target = from.ref.slice(1).reduce((d, r) => {
-          const next = d.elements[r.id || r]?.elements ? d.elements[r.id || r] : d.elements[r.id || r]?._target
+          const next = d.elements[r.id || r]?._target || d.elements[r.id || r]
           if (!next) throw new Error(`No association “${r.id || r}” in ${d.kind} “${d.name}”`)
           return next
         }, target)
       }
-      if (target.kind !== 'entity' && !target._isAssociation)
+      if (target.kind !== 'entity' && !target.isAssociation)
         throw new Error('Query source must be a an entity or an association')
 
       attachRefLinksToArg(from) // REVISIT: remove
@@ -154,9 +153,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * @returns {void} This function does not return a value; it mutates the 'arg' object directly.
    */
   function attachRefLinksToArg(arg, $baseLink = null, expandOrExists = false) {
-    const { ref, xpr, args } = arg
+    const { ref, xpr, args, list } = arg
     if (xpr) xpr.forEach(t => attachRefLinksToArg(t, $baseLink, expandOrExists))
     if (args) args.forEach(arg => attachRefLinksToArg(arg, $baseLink, expandOrExists))
+    if (list) list.forEach(arg => attachRefLinksToArg(arg, $baseLink, expandOrExists))
     if (!ref) return
     init$refLinks(arg)
     ref.forEach((step, i) => {
@@ -166,7 +166,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         // we need to search for first step in ´model.definitions[infixAlias]`
         if ($baseLink) {
           const { definition } = $baseLink
-          const elements = definition.elements || definition._target?.elements
+          const elements = 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
@@ -177,7 +177,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
                 `"${e.name}" in path "${arg.ref.map(idOnly).join('.')}" must not be an unmanaged association`,
               )
             // no non-fk traversal in infix filter
-            if (!expandOrExists && nextStep && !(nextStep in e.foreignKeys))
+            if (!expandOrExists && nextStep && !isForeignKeyOf(nextStep, e))
               throw new Error(`Only foreign keys of "${e.name}" can be accessed in infix filter`)
           }
           arg.$refLinks.push({ definition: e, target: definition })
@@ -460,12 +460,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
     function inferQueryElement(column, insertIntoQueryElements = true, $baseLink = null, context) {
       const { inExists, inExpr, inNestedProjection, inCalcElement, baseColumn } = context || {}
-      if (column.param) return // parameter references are only resolved into values on execution e.g. :val, :1 or ?
+      if (column.param || column.SELECT) return // parameter references are only resolved into values on execution e.g. :val, :1 or ?
       if (column.args) column.args.forEach(arg => inferQueryElement(arg, false, $baseLink, context)) // e.g. function in expression
       if (column.list) column.list.forEach(arg => inferQueryElement(arg, false, $baseLink, context))
       if (column.xpr)
         column.xpr.forEach(token => inferQueryElement(token, false, $baseLink, { ...context, inExpr: true })) // e.g. function in expression
-      if (column.SELECT) return
 
       if (!column.ref) {
         if (column.expand) queryElements[column.as] = resolveExpand(column)
@@ -496,7 +495,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             nameSegments.push(id)
           } else if ($baseLink) {
             const { definition, target } = $baseLink
-            const elements = definition.elements || definition._target?.elements
+            const elements = definition._target?.elements || definition.elements
             if (elements && id in elements) {
               const element = elements[id]
               rejectNonFkAccess(element)
@@ -531,7 +530,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           }
         } else {
           const { definition } = column.$refLinks[i - 1]
-          const elements = definition.elements || definition._target?.elements
+          const elements = definition._target?.elements || definition.elements //> go for assoc._target first, instead of assoc as struct
           const element = elements?.[id]
 
           if (firstStepIsSelf && element?.isAssociation) {
@@ -649,25 +648,25 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         }
 
         /**
-         * Check if the next step in the ref is foreign key of `element`
+         * Check if the next step in the ref is foreign key of `assoc`
          * if not, an error is thrown.
-         * 
-         * @param {CSN.Element} element if this is an association, the next step must be a foreign key of the element.
+         *
+         * @param {CSN.Element} assoc if this is an association, the next step must be a foreign key of the element.
          */
-        function rejectNonFkAccess(element) {
-          if (!inNestedProjection && !inCalcElement && element.target) {
+        function rejectNonFkAccess(assoc) {
+          if (!inNestedProjection && !inCalcElement && 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 && element.on)
+            if (!inExists && assoc.on)
               throw new Error(
-                `"${element.name}" in path "${column.ref
+                `"${assoc.name}" in path "${column.ref
                   .map(idOnly)
                   .join('.')}" must not be an unmanaged association`
               )
-            // no non-fk traversal in infix filter
-            if (nextStep && element.foreignKeys && !(nextStep in element.foreignKeys))
-              throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
+            // 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`)
           }
         }
       })
@@ -724,7 +723,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           if (inlineCol === '*') {
             const wildCardElements = {}
             // either the `.elements´ of the struct or the `.elements` of the assoc target
-            const leafLinkElements = $leafLink.definition.elements || $leafLink.definition._target.elements
+            const leafLinkElements = $leafLink.definition._target?.elements || $leafLink.definition.elements
             Object.entries(leafLinkElements).forEach(([k, v]) => {
               const name = namePrefix ? `${namePrefix}_${k}` : k
               // if overwritten/excluded omit from wildcard elements
@@ -1131,6 +1130,20 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
     }, '')
   }
 }
+/**
+ * Returns true if e is a foreign key of assoc.
+ * this function is also compatible with unfolded csn (UCSN),
+ * where association do not have foreign keys anymore.
+ *
+ * @param {*} e 
+ * @param {*} assoc
+ * @returns 
+ */
+function isForeignKeyOf(e, assoc) {
+  if(!assoc.isAssociation) return false
+  if(assoc.foreignKeys) return e in assoc.foreignKeys
+  return assoc.elements && e in assoc.elements
+}
 const idOnly = ref => ref.id || ref
 
 module.exports = infer

package/lib/infer/join-tree.js

@@ -101,9 +101,6 @@ class JoinTree {
     Object.entries(sources).forEach(entry => {
       const alias = this.addNextAvailableTableAlias(entry[0])
       this._roots.set(alias, new Root(entry))
-      if (entry[1].sources)
-        // respect outer aliases
-        this.addAliasesOfSubqueryInFrom(entry[1].sources)
     })
   }
 
@@ -200,9 +197,11 @@ class JoinTree {
           }
           child.$refLink.alias = this.addNextAvailableTableAlias($refLink.alias, outerQueries)
         }
-
-        const foreignKeys = node.$refLink?.definition.foreignKeys
-        if (node.$refLink && (!foreignKeys || !(child.$refLink.alias in foreignKeys)))
+        //> REVISIT: remove fallback once UCSN is standard
+        const elements =
+          node.$refLink?.definition.isAssociation &&
+          (node.$refLink.definition.elements || node.$refLink.definition.foreignKeys)
+        if (node.$refLink && (!elements || !(child.$refLink.alias in elements)))
           // foreign key access
           node.$refLink.onlyForeignKeyAccess = false
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {
@@ -29,7 +29,7 @@
     "test": "jest --silent"
   },
   "peerDependencies": {
-    "@sap/cds": ">=7.1.1"
+    "@sap/cds": ">=7.6"
   },
   "license": "SEE LICENSE",
   "devDependencies": {