@cap-js/db-service 1.0.1 → 1.2.0

package/lib/cqn4sql.js

@@ -70,13 +70,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       // 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 {
+        } else if (!queryNeedsJoins) {
           transformedProp.entity = transformedFrom
         }
 
@@ -94,7 +95,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         }
       }
 
-      if (inferred.joinTree && !inferred.joinTree.isInitial) {
+      if (queryNeedsJoins) {
         transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
       }
     }
@@ -119,7 +120,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (columns) {
       transformedQuery.SELECT.columns = getTransformedColumns(columns)
     } else {
-      transformedQuery.SELECT.columns = getColumnsForWildcard()
+      transformedQuery.SELECT.columns = getColumnsForWildcard(originalQuery.SELECT?.excluding)
     }
 
     // Like the WHERE clause, aliases from the SELECT list are not accessible for `group by`/`having` (in most DB's)
@@ -158,7 +159,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * @param {string} kind - The type of operation: "INSERT" or "UPSERT".
    *
-   * @returns {Object} - The transformed query with updated `into` clause.
+   * @returns {object} - The transformed query with updated `into` clause.
    */
   function transformQueryForInsertUpsert(kind) {
     const { as } = transformedQuery[kind].into
@@ -170,10 +171,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   /**
    * 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.
+   * @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.
+   * @returns {object} - The transformed query with updated STREAM clauses.
    */
   function transformStreamQuery() {
     const { into, where } = inferred.STREAM
@@ -193,8 +194,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   /**
    * Transforms a search expression to a WHERE clause for a SELECT operation.
    *
-   * @param {Object} search - The search expression which shall be applied to the searchable columns on the query source.
-   * @param {Object} from - The FROM clause of the CQN statement.
+   * @param {object} search - The search expression which shall be applied to the searchable columns on the query source.
+   * @param {object} from - The FROM clause of the CQN statement.
    *
    * @returns {(Object|Array|undefined)} - If the target of the query contains searchable elements, the function returns an array that represents the WHERE clause.
    *     If the SELECT query already contains a WHERE clause, this array includes the existing clause and appends an AND condition with the new 'contains' clause.
@@ -293,6 +294,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
   }
 
+  function isCalculatedOnRead(def) {
+    return def?.value && !def.value.stored
+  }
+
   /**
    * Walks over a list of columns (ref's, xpr, subqueries, val), applies flattening on structured types and expands wildcards.
    *
@@ -304,13 +309,23 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     for (let i = 0; i < columns.length; i++) {
       const col = columns[i]
 
-      if (col.expand) {
+      if (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
+        const calcElement = resolveCalculatedElement(col)
+        transformedColumns.push(calcElement)
+      } else if (col.expand) {
         if (col.ref?.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
           const dollarSelfReplacement = calculateDollarSelfColumn(col)
           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) {
@@ -322,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)
@@ -333,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) {
@@ -375,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)
       })
     }
 
@@ -396,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)
 
@@ -404,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 {
@@ -433,6 +484,36 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
   }
 
+  function resolveCalculatedElement(column, omitAlias = false, baseLink = null) {
+    let value
+
+    if (column.$refLinks) {
+      const { $refLinks } = column
+      value = $refLinks[$refLinks.length - 1].definition.value
+      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
+    }
+    const { ref, val, xpr, func } = value
+
+    let res
+    if (ref) {
+      res = getTransformedTokenStream([value], baseLink)[0]
+    } else if (xpr) {
+      res = { xpr: getTransformedTokenStream(value.xpr, baseLink) }
+    } else if (val) {
+      res = { val }
+    } else if (func) res = { args: getTransformedTokenStream(value.args, baseLink), func: value.func }
+    if (!omitAlias) res.as = column.as || column.name || column.flatName
+    return res
+  }
+
   /**
    * This function resolves a `ref` starting with a `$self`.
    * Such a path targets another element of the query by it's implicit, or explicit alias.
@@ -467,7 +548,7 @@ 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,
@@ -512,7 +593,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, {
@@ -632,7 +718,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * @param {CSN.column} column - The column with the 'expand' property to be transformed into a subquery.
    *
-   * @returns {Object} Returns a subquery correlated with the enclosing query, with added properties `expand:true` and `one:true|false`.
+   * @returns {object} Returns a subquery correlated with the enclosing query, with added properties `expand:true` and `one:true|false`.
    */
   function expandColumn(column) {
     let outerAlias
@@ -726,7 +812,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     const res = []
     for (let i = 0; i < columns.length; i++) {
       const col = columns[i]
-      if (col.isJoinRelevant) {
+      if (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
+        const calcElement = resolveCalculatedElement(col, true)
+        res.push(calcElement)
+      } else if (col.isJoinRelevant) {
         const tableAlias$refLink = getQuerySourceName(col)
         const transformedColumn = {
           ref: [tableAlias$refLink, getFullName(col.$refLinks[col.$refLinks.length - 1].definition)],
@@ -822,10 +911,12 @@ 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] })
+      } else if (isCalculatedOnRead(element)) {
+        wildcardColumns.push(resolveCalculatedElement(element))
       } else {
         const flatColumns = getFlatColumnsFor(element, { tableAlias: index }, [], { exclude, replace }, true)
         wildcardColumns.push(...flatColumns)
@@ -834,13 +925,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
     }
   }
 
@@ -923,6 +1014,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)
     }
 
@@ -976,7 +1069,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)
         }
@@ -1157,6 +1253,14 @@ 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)
+              continue
+            }
             if (token.ref.length > 1 && token.ref[0] === '$self' && !token.$refLinks[0].definition.kind) {
               const dollarSelfReplacement = [calculateDollarSelfColumn(token, true)]
               transformedTokenStream.push(...getTransformedTokenStream(dollarSelfReplacement))
@@ -1472,11 +1576,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         each.ref[0] in { $self: true, $projection: true } ? getParentEntity(assoc) : target,
       ),
     )
-
-    function getParentEntity(element) {
-      if (element.kind === 'entity') return element
-      else return getParentEntity(element.parent)
-    }
   }
 
   /**
@@ -1525,6 +1624,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')
@@ -1538,32 +1665,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) {
@@ -1587,7 +1688,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('_')]
@@ -1838,7 +1939,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
@@ -1920,6 +2020,11 @@ function getLastStringSegment(str) {
   return index != -1 ? str.substring(index + 1) : str
 }
 
+function getParentEntity(element) {
+  if (element.kind === 'entity') return element
+  else return getParentEntity(element.parent)
+}
+
 /**
  * Assigns the given `element` as non-enumerable property 'element' onto `col`.
  *

package/lib/deep-queries.js

@@ -4,6 +4,17 @@ const { _target_name4 } = require('./SQLService')
 
 const handledDeep = Symbol('handledDeep')
 
+/**
+ * @callback nextCallback
+ * @param {Error|undefined} error
+ * @returns {Promise<unknown>}
+ */
+
+/**
+ * @param {import('@sap/cds/apis/services').Request} req
+ * @param {nextCallback} next
+ * @returns {Promise<number>}
+ */
 async function onDeep(req, next) {
   const { query } = req
   // REVISIT: req.target does not match the query.INSERT target for path insert
@@ -136,11 +147,16 @@ const _calculateExpandColumns = (target, data, expandColumns = [], elementMap =
   }
 }
 
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ */
 const getExpandForDeep = (query, target) => {
   const from = query.DELETE?.from || query.UPDATE?.entity
   const data = query.UPDATE?.data || null
   const where = query.DELETE?.where || query.UPDATE?.where
 
+  /** @type {import("@sap/cds/apis/ql").SELECT<unknown>} */
   const cqn = SELECT.from(from)
   if (where) cqn.SELECT.where = where
 
@@ -150,6 +166,12 @@ const getExpandForDeep = (query, target) => {
   return cqn
 }
 
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {unknown[]} dbData
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ * @returns
+ */
 const getDeepQueries = (query, dbData, target) => {
   let queryData
   if (query.INSERT) {
@@ -167,14 +189,20 @@ const getDeepQueries = (query, dbData, target) => {
     diff = [diff]
   }
 
-  return _getDeepQueries(diff, target)
+  return _getDeepQueries(diff, target, true)
 }
 
 const _hasManagedElements = target => {
   return Object.keys(target.elements).filter(elementName => target.elements[elementName]['@cds.on.update']).length > 0
 }
 
-const _getDeepQueries = (diff, 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, root = false) => {
   const queries = []
 
   for (const diffEntry of diff) {
@@ -213,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,14 +38,20 @@ const generateUUIDandPropagateKeys = (target, data, event) => {
           generateUUIDandPropagateKeys(elements[element]._target, sub, 'CREATE')
         }
       }
-
-      propagateForeignKeys(element, data, elements[element]._foreignKeys, elements[element].isComposition, {
-        deleteAssocs: true,
-      })
     }
   }
 }
 
+/**
+ * @callback nextCallback
+ * @param {Error|undefined} error
+ * @returns {Promise<unknown>}
+ */
+
+/**
+ * @param {import('@sap/cds/apis/services').Request} req
+ * @param {nextCallback} next
+ */
 module.exports = async function fill_in_keys(req, next) {
   // REVISIT dummy handler until we have input processing
   if (!req.target || !this.model || req.target._unresolved) return next()

package/lib/infer/cqn.d.ts

@@ -0,0 +1,45 @@
+import * as cqn from '@sap/cds/apis/cqn'
+import * as csn from '@sap/cds/apis/csn'
+
+type linkedQuery = {
+  target: csn.Definition
+  elements: elements
+}
+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
+
+export type Query = SELECT | INSERT | UPSERT | UPDATE | DELETE | CREATE | DROP
+
+export type element = csn.Element & {
+  key?: boolean
+  virtual?: boolean
+  unique?: boolean
+  notNull?: boolean
+}
+export type elements = {
+  [name: string]: element
+}
+
+export type col = cqn.column_expr & { element: element }
+
+export type list = {
+  list: cqn.expr[]
+}
+// Passthrough
+export type source = cqn.source
+export type ref = cqn.ref
+export type val = cqn.val
+export type xpr = cqn.xpr
+export type expr = cqn.expr
+export type func = cqn.function_call
+export type predicate = cqn.predicate
+export type ordering_term = cqn.ordering_term
+export type limit = { rows: val; offset: val }