@cap-js/db-service 1.1.0 → 1.2.1

package/lib/cqn4sql.js

@@ -318,7 +318,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           transformedColumns.push(...getTransformedColumns([dollarSelfReplacement]))
           continue
         }
-        handleExpand(col)
+        transformedColumns.push(() => {
+          const expandResult = handleExpand(col)
+          if (expandResult.length > 1) {
+            return expandResult
+          } else {
+            return expandResult[0]
+          }
+        })
       } else if (col.inline) {
         handleInline(col)
       } else if (col.ref) {
@@ -330,10 +337,34 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         handleRef(col)
       } else if (col === '*') {
         handleWildcard(columns)
+      } else if (col.SELECT) {
+        handleSubquery(col)
       } else {
         handleDefault(col)
       }
     }
+    // subqueries are processed in the end
+    for (let i = 0; i < transformedColumns.length; i++) {
+      const c = transformedColumns[i]
+      if (typeof c === 'function') {
+        const res = c() || [] // target of expand / subquery could also be skipped -> no result
+        if (res.length !== undefined) {
+          transformedColumns.splice(i, 1, ...res)
+          i += res.length - 1
+        } else {
+          const replaceWith = res.as
+            ? transformedColumns.findIndex(t => (t.as || t.ref?.[t.ref.length - 1]) === res.as)
+            : -1
+          if (replaceWith === -1) transformedColumns.splice(i, 1, res)
+          else {
+            transformedColumns.splice(replaceWith, 1, res)
+            transformedColumns.splice(i, 1)
+            // When removing an element, the next element moves to the current index
+            i--
+          }
+        }
+      }
+    }
 
     if (transformedColumns.length === 0 && columns.length) {
       handleEmptyColumns(columns)
@@ -341,16 +372,35 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
     return transformedColumns
 
+    function handleSubquery(col) {
+      if (isLocalized(inferred.target)) col.SELECT.localized = true
+      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
+        return res
+      })
+    }
+
     function handleExpand(col) {
       const { $refLinks } = col
+      const res = []
       const last = $refLinks?.[$refLinks.length - 1]
       if (last && !last.skipExpand && last.definition.isAssociation) {
         const expandedSubqueryColumn = expandColumn(col)
-        transformedColumns.push(expandedSubqueryColumn)
+        setElementOnColumns(expandedSubqueryColumn, col.element)
+        res.push(expandedSubqueryColumn)
       } else if (!last?.skipExpand) {
         const expandCols = nestedProjectionOnStructure(col, 'expand')
-        transformedColumns.push(...expandCols)
+        res.push(...expandCols)
       }
+      return res
     }
 
     function handleInline(col) {
@@ -383,10 +433,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
       if (col.$refLinks.some(link => link.definition._target?.['@cds.persistence.skip'] === true)) return
 
+      const getName = col => col.as || col.ref?.at(-1)
       const flatColumns = getFlatColumnsFor(col, { baseName, columnAlias, tableAlias })
       flatColumns.forEach(flatColumn => {
-        const { as } = flatColumn
-        if (!(as && transformedColumns.some(inserted => inserted?.as === as))) transformedColumns.push(flatColumn)
+        const name = getName(flatColumn)
+        if (!transformedColumns.some(inserted => getName(inserted) === name)) transformedColumns.push(flatColumn)
       })
     }
 
@@ -404,7 +455,9 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       let transformedColumn = getTransformedColumn(col)
       if (col.as) transformedColumn.as = col.as
 
-      const replaceWith = transformedColumns.findIndex(t => (t.as || t.ref[t.ref.length - 1]) === transformedColumn.as)
+      const replaceWith = transformedColumns.findIndex(
+        t => (t.as || t.ref?.[t.ref.length - 1]) === transformedColumn.as,
+      )
       if (replaceWith === -1) transformedColumns.push(transformedColumn)
       else transformedColumns.splice(replaceWith, 1, transformedColumn)
 
@@ -412,17 +465,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
 
     function getTransformedColumn(col) {
-      if (col.SELECT) {
-        if (isLocalized(inferred.target)) col.SELECT.localized = true
-        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 })
-        }
-        return transformSubquery(col)
-      } else if (col.xpr) {
+      if (col.xpr) {
         return { xpr: getTransformedTokenStream(col.xpr) }
       } else if (col.func) {
         return {
@@ -447,7 +490,13 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (column.$refLinks) {
       const { $refLinks } = column
       value = $refLinks[$refLinks.length - 1].definition.value
-      baseLink = [...column.$refLinks].reverse().find(link => link.definition.isAssociation) || baseLink
+      if (column.$refLinks.length > 1) {
+        baseLink =
+          [...$refLinks].reverse().find($refLink => $refLink.definition.isAssociation) ||
+          // if there is no association in the path, the table alias is the base link
+          // TA might refer to subquery -> we need to propagate the alias to all paths of the calc element
+          column.$refLinks[0]
+      }
     } else {
       value = column.value
     }
@@ -460,7 +509,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       res = { xpr: getTransformedTokenStream(value.xpr, baseLink) }
     } else if (val) {
       res = { val }
-    } else if (func) res = { args: getTransformedTokenStream(value.args), func: value.func }
+    } else if (func) res = { args: getTransformedTokenStream(value.args, baseLink), func: value.func }
     if (!omitAlias) res.as = column.as || column.name || column.flatName
     return res
   }
@@ -499,7 +548,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         dollarSelfColumn.ref = [...referencedColumn.ref, ...dollarSelfColumn.ref.slice(2)]
         Object.defineProperties(dollarSelfColumn, {
           flatName: {
-            value: dollarSelfColumn.ref.join('_'),
+            value:
+              referencedColumn.$refLinks[0].definition.kind === 'entity'
+                ? dollarSelfColumn.ref.slice(1).join('_')
+                : dollarSelfColumn.ref.join('_'),
           },
           isJoinRelevant: {
             value: referencedColumn.isJoinRelevant,
@@ -544,7 +596,12 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         if (nestedProjection.ref) {
           const augmentedInlineCol = { ...nestedProjection }
           augmentedInlineCol.ref = col.ref ? [...col.ref, ...nestedProjection.ref] : nestedProjection.ref
-          if (col.as || nestedProjection.as || nestedProjection.isJoinRelevant) {
+          if (
+            col.as ||
+            nestedProjection.as ||
+            nestedProjection.$refLinks[nestedProjection.$refLinks.length - 1].definition.value ||
+            nestedProjection.isJoinRelevant
+          ) {
             augmentedInlineCol.as = nameParts.join('_')
           }
           Object.defineProperties(augmentedInlineCol, {
@@ -857,7 +914,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       const { index, tableAlias } = inferred.$combinedElements[k][0]
       const element = tableAlias.elements[k]
       // ignore FK for odata csn / ignore blobs from wildcard expansion
-      if (isODataFlatForeignKey(element) || (element['@Core.MediaType'] && !element['@Core.IsURL'])) return
+      if (isManagedAssocInFlatMode(element) || (element['@Core.MediaType'] && !element['@Core.IsURL'])) return
       // for wildcard on subquery in from, just reference the elements
       if (tableAlias.SELECT && !element.elements && !element.target) {
         wildcardColumns.push(index ? { ref: [index, k] } : { ref: [k] })
@@ -871,13 +928,13 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     return wildcardColumns
 
     /**
-     * HACK for odata csn input - foreign keys are already part of the elements in this csn flavor
-     * not excluding them from the wildcard columns would cause duplicate columns upon foreign key expansion
+     * foreign keys are already part of the elements in a flat model
+     * not excluding the associations from the wildcard columns would cause duplicate columns upon foreign key expansion
      * @param {CSN.element} e
-     * @returns {boolean} true if the element is a flat foreign key generated by the compiler
+     * @returns {boolean} true if the element is a managed association and the model is flat
      */
-    function isODataFlatForeignKey(e) {
-      return Boolean(e['@odata.foreignKey4'] || e._foreignKey4)
+    function isManagedAssocInFlatMode(e) {
+      return model.meta.transformation === 'odata' && e.isAssociation && e.keys
     }
   }
 
@@ -960,6 +1017,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         // we need to provide the correct table alias
         tableAlias = getQuerySourceName(replacedBy)
 
+      if (replacedBy.expand) return [{ as: baseName }]
+
       return getFlatColumnsFor(replacedBy, { baseName, columnAlias: replacedBy.as, tableAlias }, csnPath)
     }
 
@@ -1013,7 +1072,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           else flatColumn = { ref: [fkBaseName] }
           if (tableAlias) flatColumn.ref.unshift(tableAlias)
 
-          setElementOnColumns(flatColumn, fkElement)
+          // in a flat model, we must assign the foreign key rather than the key in the target
+          const flatForeignKey = model.definitions[element.parent.name]?.elements[fkBaseName]
+
+          setElementOnColumns(flatColumn, flatForeignKey || fkElement)
           Object.defineProperty(flatColumn, '_csnPath', { value: csnPath, writable: true })
           flatColumns.push(flatColumn)
         }
@@ -1183,7 +1245,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           ) {
             if (notSupportedOps.some(([firstOp]) => firstOp === next))
               cds.error(`The operator "${next}" is not supported for structure comparison`)
-            const newTokens = expandComparison(token, ops, rhs)
+            const newTokens = expandComparison(token, ops, rhs, $baseLink)
             const needXpr = Boolean(tokenStream[i - 1] || tokenStream[indexRhs + 1])
             transformedTokenStream.push(...(needXpr ? [asXpr(newTokens)] : newTokens))
             i = indexRhs // jump to next relevant index
@@ -1195,6 +1257,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive! //
           if (token.ref) {
             const { definition } = token.$refLinks[token.$refLinks.length - 1]
+            // Add definition to result
+            setElementOnColumns(result, definition)
             if (isCalculatedOnRead(definition)) {
               const calculatedElement = resolveCalculatedElement(token, true, $baseLink)
               transformedTokenStream.push(calculatedElement)
@@ -1240,9 +1304,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    * @param {object} token with $refLinks
    * @param {string} operator one of allOps
    * @param {object} value either `null` or a column (with `ref` and `$refLinks`)
+   * @param {object} $baseLink optional base `$refLink`, e.g. for infix filters of scoped queries.
+   *                           In the following example, we must pass `bookshop:Reproduce` as $baseLink for `author`:
+   *
+   *                           `DELETE.from('bookshop.Reproduce[author = null]:accessGroup')`
+   *                                                            ^^^^^^
    * @returns {array}
    */
-  function expandComparison(token, operator, value) {
+  function expandComparison(token, operator, value, $baseLink = null) {
     const { definition } = token.$refLinks[token.$refLinks.length - 1]
     let flatRhs
     const result = []
@@ -1305,7 +1374,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       if (!def.$refLinks) return def
       const leaf = def.$refLinks[def.$refLinks.length - 1]
       const first = def.$refLinks[0]
-      const tableAlias = getQuerySourceName(def, def.ref.length > 1 && first.definition.isAssociation ? first : null)
+      const tableAlias = getQuerySourceName(
+        def,
+        def.ref.length > 1 && first.definition.isAssociation ? first : $baseLink,
+      )
       if (leaf.definition.parent.kind !== 'entity')
         // we need the base name
         return getFlatColumnsFor(leaf.definition, {
@@ -1563,6 +1635,34 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           continue
         }
         const rhs = result[i + 2]
+        if (rhs?.ref || lhs.ref) {
+          // if we have refs on each side of the comparison, we might need to perform tuple expansion
+          // or flatten the structures
+          const refLinkFaker = thing => {
+            const { ref } = thing
+            const assocHost = getParentEntity(assocRefLink.definition)
+            Object.defineProperty(thing, '$refLinks', {
+              value: [],
+              writable: true,
+            })
+            ref.reduce((prev, res, i) => {
+              if (res === '$self')
+                // next is resolvable in entity
+                return prev
+              const definition = prev?.elements?.[res] || prev?._target?.elements[res] || pseudos.elements[res]
+              const target = getParentEntity(definition)
+              thing.$refLinks[i] = { definition, target, alias: definition.name }
+              return prev?.elements?.[res] || prev?._target?.elements[res] || pseudos.elements[res]
+            }, assocHost)
+          }
+
+          // comparison in on condition needs to be expanded...
+          // re-use existing algorithm for that
+          // we need to fake some $refLinks for that to work though...
+          lhs?.ref && !lhs.$refLinks && refLinkFaker(lhs)
+          rhs?.ref && !rhs.$refLinks && refLinkFaker(rhs)
+        }
+
         let backlink
         if (rhs?.ref && lhs?.ref) {
           if (lhs?.ref?.length === 1 && lhs.ref[0] === '$self')
@@ -1576,32 +1676,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
               lhs.ref[0] in { $self: true, $projection: true } ? getParentEntity(assocRefLink.definition) : target,
             )
           else {
-            // if we have refs on each side of the comparison, we might need to perform tuple expansion
-            // or flatten the structures
-            // REVISIT: this whole section needs a refactoring, it is too complex and some edge cases may still be not considered...
-            const refLinkFaker = thing => {
-              const { ref } = thing
-              const assocHost = getParentEntity(assocRefLink.definition)
-              Object.defineProperty(thing, '$refLinks', {
-                value: [],
-                writable: true,
-              })
-              ref.reduce((prev, res, i) => {
-                if (res === '$self')
-                  // next is resolvable in entity
-                  return prev
-                const definition = prev?.elements?.[res] || prev?._target?.elements[res] || pseudos.elements[res]
-                const target = getParentEntity(definition)
-                thing.$refLinks[i] = { definition, target, alias: definition.name }
-                return prev?.elements?.[res] || prev?._target?.elements[res] || pseudos.elements[res]
-              }, assocHost)
-            }
-
-            // comparison in on condition needs to be expanded...
-            // re-use existing algorithm for that
-            // we need to fake some $refLinks for that to work though...
-            lhs?.ref && refLinkFaker(lhs)
-            rhs?.ref && refLinkFaker(rhs)
             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) {
@@ -1625,7 +1699,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
               lhs.$refLinks[0].definition ===
               getParentEntity(assocRefLink.definition).elements[assocRefLink.definition.name]
             )
-              result[i].ref = [result[i].ref[0], lhs.ref.slice(1).join('_')]
+              result[i].ref = [assocRefLink.alias, lhs.ref.slice(1).join('_')]
             // naive assumption: if the path starts with an association which is not the association from
             // which the on-condition originates, it must be a foreign key and hence resolvable in the source
             else if (lhs.$refLinks[0].definition.target) result[i].ref = [result[i].ref.join('_')]
@@ -1876,7 +1950,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (node.isJoinRelevant) {
       return getJoinRelevantAlias(node)
     }
-
     return getSelectOrEntityAlias(node) || getCombinedElementAlias(node)
     function getBaseLinkAlias($baseLink) {
       return $baseLink.alias

package/lib/deep-queries.js

@@ -189,7 +189,7 @@ const getDeepQueries = (query, dbData, target) => {
     diff = [diff]
   }
 
-  return _getDeepQueries(diff, target)
+  return _getDeepQueries(diff, target, true)
 }
 
 const _hasManagedElements = target => {
@@ -199,9 +199,10 @@ const _hasManagedElements = target => {
 /**
  * @param {unknown[]} diff
  * @param {import('@sap/cds/apis/csn').Definition} target
+ * @param {boolean} [root=false]
  * @returns {import('@sap/cds/apis/cqn').Query[]}
  */
-const _getDeepQueries = (diff, target) => {
+const _getDeepQueries = (diff, target, root = false) => {
   const queries = []
 
   for (const diffEntry of diff) {
@@ -240,7 +241,7 @@ const _getDeepQueries = (diff, target) => {
       queries.push(INSERT.into(target).entries(diffEntry))
     } else if (op === 'delete') {
       queries.push(DELETE.from(target).where(diffEntry))
-    } else if (op === 'update' || (op === undefined && subQueries.length && _hasManagedElements(target))) {
+    } else if (op === 'update' || (op === undefined && (root || subQueries.length) && _hasManagedElements(target))) {
       // TODO do we need the where here?
       const keys = target.keys
       const cqn = UPDATE(target).with(diffEntry)

package/lib/fill-in-keys.js

@@ -23,6 +23,11 @@ const generateUUIDandPropagateKeys = (target, data, event) => {
     }
 
     if (elements[element].is2one || elements[element].is2many) {
+      // propagate own foreign keys to propagate further to sub data
+      propagateForeignKeys(element, data, elements[element]._foreignKeys, elements[element].isComposition, {
+        deleteAssocs: true,
+      })
+
       let subData = data[element]
       if (subData) {
         if (!Array.isArray(subData)) {
@@ -33,10 +38,6 @@ const generateUUIDandPropagateKeys = (target, data, event) => {
           generateUUIDandPropagateKeys(elements[element]._target, sub, 'CREATE')
         }
       }
-
-      propagateForeignKeys(element, data, elements[element]._foreignKeys, elements[element].isComposition, {
-        deleteAssocs: true,
-      })
     }
   }
 }

package/lib/infer/index.js

@@ -451,7 +451,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      */
 
     function inferQueryElement(column, insertIntoQueryElements = true, $baseLink = null, context) {
-      const { inExists, inExpr, inNestedProjection, inCalcElement } = 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.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))
@@ -493,11 +493,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const elements = definition.elements || definition._target?.elements
             if (elements && id in elements) {
               const element = elements[id]
-              if (!inExists && !inNestedProjection && !inCalcElement && element.target) {
+              if (!inNestedProjection && !inCalcElement && element.target) {
                 // only fk access in infix filter
                 const nextStep = column.ref[1]?.id || column.ref[1]
                 // no unmanaged assoc in infix filter path
-                if (element.on)
+                if (!inExists && element.on)
                   throw new Error(
                     `"${element.name}" in path "${column.ref
                       .map(idOnly)
@@ -577,7 +577,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         }
 
         if (step.where) {
-          const danglingFilter = !(column.ref[i + 1] || column.expand || inExists)
+          const danglingFilter = !(column.ref[i + 1] || column.expand || column.inline || inExists)
           if (!column.$refLinks[i].definition.target || danglingFilter)
             throw new Error(/A filter can only be provided when navigating along associations/)
           if (!column.expand) Object.defineProperty(column, 'isJoinRelevant', { value: true })
@@ -657,16 +657,22 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       const leafArt = column.$refLinks[column.$refLinks.length - 1].definition
       const virtual = (leafArt.virtual || !isPersisted) && !inExpr
       // check if we need to merge the column `ref` into the join tree of the query
-      if (!inExists && !virtual && !inCalcElement && isColumnJoinRelevant(column, firstStepIsSelf)) {
-        if (originalQuery.UPDATE)
-          throw cds.error(
-            'Path expressions for UPDATE statements are not supported. Use “where exists” with infix filters instead.',
-          )
-        Object.defineProperty(column, 'isJoinRelevant', { value: true })
-        joinTree.mergeColumn(column, $baseLink)
+      if (!inExists && !virtual && !inCalcElement) {
+        // for a ref inside an `inline` we need to consider the column `ref` which has the `inline` prop
+        const colWithBase = baseColumn
+          ? { ref: [...baseColumn.ref, ...column.ref], $refLinks: [...baseColumn.$refLinks, ...column.$refLinks] }
+          : column
+        if (isColumnJoinRelevant(colWithBase)) {
+          if (originalQuery.UPDATE)
+            throw cds.error(
+              'Path expressions for UPDATE statements are not supported. Use “where exists” with infix filters instead.',
+            )
+          Object.defineProperty(column, 'isJoinRelevant', { value: true })
+          joinTree.mergeColumn(colWithBase, originalQuery.outerQueries)
+        }
       }
       if (leafArt.value && !leafArt.value.stored) {
-        resolveCalculatedElement(leafArt, column)
+        resolveCalculatedElement(column, $baseLink, baseColumn)
       }
 
       /**
@@ -689,7 +695,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         const $leafLink = $refLinks[$refLinks.length - 1]
         let elements = {}
         inline.forEach(inlineCol => {
-          inferQueryElement(inlineCol, false, $leafLink, { inExpr: true, inNestedProjection: true })
+          inferQueryElement(inlineCol, false, $leafLink, { inExpr: true, inNestedProjection: true, baseColumn: col })
           if (inlineCol === '*') {
             const wildCardElements = {}
             // either the `.elements´ of the struct or the `.elements` of the assoc target
@@ -795,17 +801,27 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         throw new Error(err)
       }
     }
-    function resolveCalculatedElement(calcElement) {
+    function resolveCalculatedElement(column, baseLink, baseColumn) {
+      const calcElement = column.$refLinks?.[column.$refLinks.length - 1].definition || column
       if (alreadySeenCalcElements.has(calcElement)) return
       else alreadySeenCalcElements.add(calcElement)
       const { ref, xpr, func } = calcElement.value
       if (ref || xpr) {
-        attachRefLinksToArg(calcElement.value, { definition: calcElement.parent, target: calcElement.parent }, true)
+        baseLink = baseLink || { definition: calcElement.parent, target: calcElement.parent }
+        attachRefLinksToArg(calcElement.value, baseLink, true)
+        const basePath = { $refLinks: [], ref: [] }
+        if (baseColumn) {
+          basePath.$refLinks.push(...baseColumn.$refLinks)
+          basePath.ref.push(...baseColumn.ref)
+        }
         // column is now fully linked, now we need to find out if we need to merge it into the join tree
         // for that, we calculate all paths from a calc element and merge them into the join tree
-        mergePathsIntoJoinTree(calcElement.value)
+        mergePathsIntoJoinTree(calcElement.value, basePath)
       }
-      if (func) calcElement.value.args?.forEach(arg => inferQueryElement(arg, false)) // {func}.args are optional
+      if (func)
+        calcElement.value.args?.forEach(arg =>
+          inferQueryElement(arg, false, { definition: calcElement.parent, target: calcElement.parent }),
+        ) // {func}.args are optional
       function mergePathsIntoJoinTree(e, basePath = null) {
         basePath = basePath || { $refLinks: [], ref: [] }
         if (e.ref) {
@@ -841,8 +857,14 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         function mergePathIfNecessary(p, step) {
           const calcElementIsJoinRelevant = isColumnJoinRelevant(p)
           if (calcElementIsJoinRelevant) {
-            if (!calcElement.value.isColumnJoinRelevant) Object.defineProperty(step, 'isJoinRelevant', { value: true })
-            joinTree.mergeColumn(p)
+            if (!calcElement.value.isColumnJoinRelevant)
+              Object.defineProperty(step, 'isJoinRelevant', { value: true, writable: 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 })
           }
         }
       }

package/lib/infer/join-tree.js

@@ -154,7 +154,7 @@ class JoinTree {
    * @param {object} col - The column object to be merged into the existing join tree. This object should have the properties $refLinks and ref.
    * @returns {boolean} - Always returns true, indicating the column has been successfully merged into the join tree.
    */
-  mergeColumn(col) {
+  mergeColumn(col, outerQueries = null) {
     if (this.isInitial) this.isInitial = false
     const head = col.$refLinks[0]
     let node = this._roots.get(head.alias)
@@ -196,7 +196,7 @@ class JoinTree {
           } else {
             child.$refLink.onlyForeignKeyAccess = true
           }
-          child.$refLink.alias = this.addNextAvailableTableAlias($refLink.alias)
+          child.$refLink.alias = this.addNextAvailableTableAlias($refLink.alias, outerQueries)
         }
 
         const foreignKeys = node.$refLink?.definition.foreignKeys

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {
@@ -26,10 +26,7 @@
     "npm": ">=8"
   },
   "scripts": {
-    "prettier": "npx prettier --write .",
-    "test": "npm run build && npx jest --silent",
-    "build": "tsc && find lib/ -type f -name '*.d.ts' -exec cp '{}' 'dist/{}' ';' && cp ts.eslintrc.cjs dist/.eslintrc.cjs && npx eslint ./dist --ext .d.ts",
-    "lint": "npx eslint . && npx prettier --check . "
+    "test": "jest --silent"
   },
   "peerDependencies": {
     "@sap/cds": ">=7.1.1"