@sap/cds 5.5.3 → 5.6.1

package/libx/_runtime/common/utils/foreignKeyPropagations.js

@@ -1,93 +1,6 @@
-const cds = require('../../cds')
-
-const _generateParentField = (foreignKeyPropagations, row) => {
-  if (
-    foreignKeyPropagations.parentFieldName &&
-    !row[foreignKeyPropagations.parentFieldName] &&
-    foreignKeyPropagations.autoGenerate
-  ) {
-    row[foreignKeyPropagations.parentFieldName] = cds.utils.uuid()
-  }
-}
-
-const _generateChildField = (foreignKeyPropagations, childRow) => {
-  if (foreignKeyPropagations.deep) {
-    const deep = foreignKeyPropagations.deep
-    _generateChildField(deep.propagation, childRow[deep.targetName])
-  } else if (childRow && !childRow[foreignKeyPropagations.childFieldName] && foreignKeyPropagations.autoGenerate) {
-    childRow[foreignKeyPropagations.childFieldName] = cds.utils.uuid()
-  }
-}
-
-const _getNestedVal = (row, prefix) => {
-  let val = row
-  const splitted = prefix.split('_')
-  let k = ''
-
-  while (splitted.length > 0) {
-    k += splitted.shift()
-    if (k in val) {
-      val = val[k]
-      k = ''
-    } else {
-      k += '_'
-    }
-  }
-
-  return val
-}
-
-const _propagateToChid = (foreignKeyPropagation, row, childRow) => {
-  const { parentFieldName, childFieldName, prefix, parentFieldValue } = foreignKeyPropagation
-
-  if (parentFieldName) {
-    if (prefix) {
-      const nested = _getNestedVal(row, prefix)
-      childRow[childFieldName] = nested[parentFieldName]
-    } else {
-      childRow[childFieldName] = row[parentFieldName]
-    }
-  } else if (parentFieldValue !== undefined) {
-    childRow[childFieldName] = parentFieldValue
-  }
-}
-
-const _propagateToParent = (foreignKeyPropagations, childRow, row) => {
-  if (foreignKeyPropagations.deep) {
-    const deep = foreignKeyPropagations.deep
-    _propagateToParent(deep.propagation, childRow[deep.targetName], childRow)
-  }
-
-  if (childRow && Object.prototype.hasOwnProperty.call(childRow, foreignKeyPropagations.childFieldName)) {
-    row[foreignKeyPropagations.parentFieldName] = childRow[foreignKeyPropagations.childFieldName]
-  }
-}
-
-const propagateForeignKeys = (tKey, row, foreignKeyPropagations, opts = {}) => {
-  const childRows = Array.isArray(row[tKey]) ? row[tKey] : [row[tKey]]
-
-  for (const childRow of childRows) {
-    if (!childRow) return
-
-    for (const foreignKeyPropagation of foreignKeyPropagations) {
-      if (foreignKeyPropagation.fillChild) {
-        _generateParentField(foreignKeyPropagation, row)
-        if (opts.onlyWriteCompositionEffective && !foreignKeyPropagations._element._isCompositionEffective) {
-          delete row[tKey]
-        } else {
-          _propagateToChid(foreignKeyPropagation, row, childRow)
-        }
-      } else {
-        _generateChildField(foreignKeyPropagation, childRow)
-        _propagateToParent(foreignKeyPropagation, childRow, row)
-      }
-    }
-  }
-}
-
-const _getSubOns = on => {
+const _getSubOns = element => {
   // this only works for on conds with `and`, once we support `or` this needs to be adjusted
-  const newOn = on.filter(e => e !== '(' && e !== ')')
+  const newOn = element.on ? element.on.filter(e => e !== '(' && e !== ')') : []
   const subOns = []
   let currArr = []
 
@@ -108,8 +21,6 @@ const _getSubOns = on => {
   return subOns
 }
 
-const _autoGenerate = el => el && el.type === 'cds.UUID' && el.key
-
 const _parentFieldsFromSimpleOnCond = (element, subOn) => {
   const idxChildField = subOn.findIndex(o => o.ref && o.ref[0] === element.name)
   if (idxChildField === -1 || subOn[1] !== '=') return
@@ -124,26 +35,20 @@ const _parentFieldsFromSimpleOnCond = (element, subOn) => {
     if (idxChildInParent > -1) parentRef.splice(idxChildInParent, 1)
     parentRef = [parentRef.join('_')]
   }
+  const parentElement = parentRef && element.parent.elements[parentRef[0]]
 
   if (!childElement) {
     // update on view with key in parent
-
-    return [
-      {
-        fillChild: false,
-        childFieldName,
-        parentFieldName: parentRef[0],
-        autoGenerate: _autoGenerate(element.parent.elements[parentRef[0]])
-      }
-    ]
+    return [{ fillChild: false, parentElement, childElement }]
   }
 
-  if (!childElement.on && parentRef && parentRef.length === 1) {
-    return _foreignKeyPropagationsFromToManyOn(element, parentRef, childFieldName)
+  if (!childElement.on) {
+    if (element._isSelfManaged) return _foreignKeyPropagationsFromToManyOn(element, childFieldName)
+    if (parentElement) return [{ fillChild: true, parentElement, childElement }]
   }
 
   if ('val' in subOn[idxParentField]) {
-    return _foreignKeyPropagationsFromStaticOn(childFieldName, idxParentField, subOn)
+    return [{ fillChild: true, parentFieldValue: subOn[idxParentField].val, childElement }]
   }
 
   if (childElement._isAssociationStrict && childElement.on) {
@@ -151,40 +56,19 @@ const _parentFieldsFromSimpleOnCond = (element, subOn) => {
   }
 }
 
-const _foreignKeyPropagationsFromStaticOn = (childFieldName, idxParentField, subOn) => {
-  if (childFieldName) {
-    return [{ fillChild: true, parentFieldValue: subOn[idxParentField].val, childFieldName }]
-  }
-}
-
-const _foreignKeyPropagationsFromToManyOn = (element, parentRef, childFieldName) => {
-  const parentFieldName = parentRef[0]
-  if (parentFieldName === '$self') {
-    const foreignKeys = _foreignKeysForTarget(element, childFieldName)
-
-    // REVISIT foreignKeys is empty if we have deep operations where a sub element is annotated with persistence skip
-    if (foreignKeys && foreignKeys.length) {
-      const parentKeys = _parentKeys(element)
-
-      return resolvedKeys(parentKeys, foreignKeys, true)
-    }
-
-    return []
+const _foreignKeyPropagationsFromToManyOn = (element, childFieldName) => {
+  const foreignKeys = _foreignKeysForTarget(element, childFieldName)
+  // REVISIT foreignKeys is empty if we have deep operations where a sub element is annotated with persistence skip
+  if (foreignKeys && foreignKeys.length) {
+    const parentKeys = _parentKeys(element)
+    return _resolvedKeys(parentKeys, foreignKeys, true)
   }
-
-  return [
-    {
-      fillChild: true,
-      childFieldName,
-      parentFieldName,
-      autoGenerate: _autoGenerate(element.parent.elements[parentFieldName])
-    }
-  ]
+  return []
 }
 
 const _foreignKeyPropagationsFromCustomBacklink = (element, childElement) => {
   const foreignKeyPropagations = []
-  const subOns = _getSubOns(childElement.on)
+  const subOns = _getSubOns(childElement)
 
   for (const subOn of subOns) {
     if (subOn[1] === '=') {
@@ -192,20 +76,26 @@ const _foreignKeyPropagationsFromCustomBacklink = (element, childElement) => {
       const otherFieldIdx = parentFieldIdx === 0 ? 2 : 0
       const otherField = subOn[otherFieldIdx]
 
-      if (otherField.ref && otherField.ref.length === 1) {
+      if (parentFieldIdx === -1 && subOn[otherFieldIdx === 0 ? 2 : 0].val !== undefined) {
+        const parentField = subOn[otherFieldIdx === 0 ? 2 : 0]
+        foreignKeyPropagations.push({
+          fillChild: false,
+          parentFieldValue: parentField.val,
+          childElement: element._target.elements[otherField.ref[0]]
+        })
+      } else if (otherField.ref && otherField.ref.length === 1) {
         const parentFieldName = subOn[parentFieldIdx].ref[1]
         foreignKeyPropagations.push({
           fillChild: true,
-          parentFieldName,
-          childFieldName: otherField.ref[0],
-          autoGenerate: _autoGenerate(element.parent.elements[parentFieldName])
+          parentElement: element.parent.elements[parentFieldName],
+          childElement: element._target.elements[otherField.ref[0]]
         })
       } else if (otherField.val !== undefined) {
         const parentFieldName = subOn[parentFieldIdx] && subOn[parentFieldIdx].ref[1]
         const parentField = subOn[otherFieldIdx === 2 ? 0 : 2]
         foreignKeyPropagations.push({
           fillChild: true,
-          parentFieldName,
+          parentElement: element.parent.elements[parentFieldName],
           parentFieldValue: parentField.val,
           childFieldValue: otherField.val
         })
@@ -216,8 +106,8 @@ const _foreignKeyPropagationsFromCustomBacklink = (element, childElement) => {
   return foreignKeyPropagations
 }
 
-const _foreignKeyPropagationsFromOn = (element, on) => {
-  const subOns = _getSubOns(on)
+const _foreignKeyPropagationsFromOn = element => {
+  const subOns = _getSubOns(element)
   const foreignKeyPropagations = []
 
   for (const subOn of subOns) {
@@ -265,10 +155,9 @@ const _resolve4struct = (others, struct, fkps, fillChild, childIsStruct, i) => {
 
       // push propagation
       fkps.push({
-        childFieldName: childIsStruct ? current.name : other.name,
-        parentFieldName: childIsStruct ? other.name : current.name,
+        childElement: childIsStruct ? current : other,
+        parentElement: childIsStruct ? other : current,
         fillChild,
-        autoGenerate: _autoGenerate(other),
         prefix,
         deep: !fillChild && _resolveTargetForeignKey(childIsStruct ? current : other)
       })
@@ -285,11 +174,11 @@ const _resolveTargetForeignKey = targetKey => {
   const targetName = targetKey['@odata.foreignKey4']
   if (!targetName) return
   const _foreignKeyProps = foreignKeyPropagations(targetKey.parent.elements[targetName])
-  const propagation = _foreignKeyProps.find(_fkp => targetKey.name === _fkp.parentFieldName)
+  const propagation = _foreignKeyProps.find(_fkp => _fkp.parentElement && targetKey.name === _fkp.parentElement.name)
   return { targetName, propagation }
 }
 
-const resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
+const _resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
   const foreignKeyPropagations = []
 
   for (let i = 0; i < foreignKeys.length; i++) {
@@ -302,9 +191,8 @@ const resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
     } else {
       foreignKeyPropagations.push({
         fillChild,
-        childFieldName: tk.name,
-        autoGenerate: _autoGenerate(tk),
-        parentFieldName: fk.name,
+        parentElement: fk,
+        childElement: tk,
         // needed only for child -> parent propagation since template loops in other direction
         deep: !fillChild && _resolveTargetForeignKey(tk)
       })
@@ -314,32 +202,23 @@ const resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
   return foreignKeyPropagations
 }
 
-const _foreignKeyPropagations = element => {
+const foreignKeyPropagations = element => {
   if (element.is2many && element.on) {
-    return _foreignKeyPropagationsFromOn(element, element.on)
+    return _foreignKeyPropagationsFromOn(element)
   }
-
   if (element.is2one) {
     if (!element.on) {
       const foreignKeys = _foreignKeys(element)
-
       if (foreignKeys) {
         const targetKeys = _targetKeys(element)
-        return resolvedKeys(foreignKeys, targetKeys)
+        return _resolvedKeys(foreignKeys, targetKeys)
       }
-
-      return []
     } else {
       // It's a link through a backlink
-      return _foreignKeyPropagationsFromOn(element, element.on)
+      return _foreignKeyPropagationsFromOn(element)
     }
   }
-}
-
-const foreignKeyPropagations = element => {
-  const foreignKeyProps = _foreignKeyPropagations(element)
-  if (foreignKeyProps) foreignKeyProps._element = element
-  return foreignKeyProps
+  return []
 }
 
 const _foreignKeys = csnElement => {
@@ -365,20 +244,6 @@ const _parentKeys = csnElement => {
   )
 }
 
-const _structPrefix = csnElement => {
-  if (csnElement.parent && csnElement.parent._isStructured) {
-    const prefix = _structPrefix(csnElement.parent)
-    if (!prefix) return csnElement.parent.name + '_'
-    return prefix + csnElement.parent.name + '_'
-  }
-
-  return ''
-}
-
 module.exports = {
-  foreignKeyPropagations,
-  propagateForeignKeys,
-  _foreignKeys,
-  _targetKeys,
-  _structPrefix
+  foreignKeyPropagations
 }

package/libx/_runtime/common/utils/generateOnCond.js

@@ -1,26 +1,23 @@
-const { foreignKeyPropagations } = require('./foreignKeyPropagations')
-const { _structPrefix } = require('./foreignKeyPropagations')
-
 const _toRef = (alias, column) => {
   if (Array.isArray(column)) column = column.join('_')
   return { ref: alias ? [alias, column] : [column] }
 }
 
-const _adaptOnConditionElements = (onCond, associationName, selectAlias, joinAlias) => {
+const _adaptRefs = (onCond, path, { select, join }) => {
   const adaptedOnCondition = onCond.map(el => {
     const ref = el.ref
 
     if (ref) {
-      if (ref[0] === associationName.join('_') && ref[1]) {
-        return _toRef(selectAlias, ref.slice(1))
+      if (ref[0] === path.join('_') && ref[1]) {
+        return _toRef(select, ref.slice(1))
       }
 
       // no alias for special $user of canonical localized association
-      if (ref[0] === '$user' && associationName[0] === 'localized') {
+      if (ref[0] === '$user' && path[0] === 'localized') {
         return _toRef(undefined, ref.slice(0))
       }
 
-      return _toRef(joinAlias, ref.slice(0))
+      return _toRef(join, ref.slice(0))
     }
 
     return el
@@ -29,8 +26,7 @@ const _adaptOnConditionElements = (onCond, associationName, selectAlias, joinAli
   return adaptedOnCondition
 }
 
-const _args = (csnElement, options) => {
-  const { associationNames, csn, aliases } = options
+const _args = (csnElement, path, aliases) => {
   const onCond = csnElement.on
 
   if (!onCond || !onCond.length) {
@@ -41,86 +37,60 @@ const _args = (csnElement, options) => {
     return onCond
   }
 
-  if ((onCond[0].ref && onCond[0].ref[0] === '$self') || (onCond[2].ref && onCond[2].ref[0] === '$self')) {
-    const target =
-      onCond[0].ref[0] === '$self' ? onCond[2].ref[onCond[2].ref.length - 1] : onCond[0].ref[onCond[0].ref.length - 1]
-
-    const oc = getOnCondNew(csn.definitions[csnElement.target].elements[target], {
-      associationNames: target,
-      csn,
-      // revert join and select aliases because of backlink
-      aliases: { select: aliases.join, join: aliases.select }
-    })
-
-    if (onCond.some(ele => ele === 'and')) {
-      const and = _adaptOnConditionElements(
-        onCond.slice(onCond.findIndex(ele => ele === 'and') + 1),
-        associationNames,
-        aliases.select,
-        aliases.join
-      )
-      oc.push('and', ...and)
-    }
+  if (!csnElement._isSelfManaged) return _adaptRefs(onCond, path, aliases)
+
+  // revert join and select aliases because of backlink
+  const oc = _newOnConditions(csnElement._backlink, [csnElement._backlink.name], {
+    select: aliases.join,
+    join: aliases.select
+  })
 
-    return oc
+  if (onCond.some(e => e === 'and')) {
+    // managed with ON-conditions must contain `$self`, which we replace with `oc`
+    const onCondWithouSelf = _adaptRefs(_onCondWithout$self(onCond), path, aliases)
+    oc.push('and', ...onCondWithouSelf)
   }
 
-  return _adaptOnConditionElements(onCond, associationNames, aliases.select, aliases.join)
+  return oc
 }
 
-const _foreignToOn = (csnElement, options) => {
-  const { aliases } = options
-  const on = []
-  const foreignKeys = foreignKeyPropagations(csnElement)
+const _isSelfRef = e => e && e.ref && e.ref[0] === '$self'
 
-  // for external services, there might be no foreign keys
-  if (!foreignKeys) return on
+const _onCondWithout$self = onCond => {
+  const onCondWithoutSelf = [...onCond]
+  const selfIndex = onCondWithoutSelf.findIndex((e, i, on) => {
+    if (e === 'and') return _isSelfRef(on[i + 1]) || _isSelfRef(on[i + 3])
+    return on[i + 1] === '=' && (_isSelfRef(e) || _isSelfRef(on[i + 2]))
+  })
+  onCondWithoutSelf.splice(selfIndex, 4)
+  return onCondWithoutSelf
+}
 
-  for (const key of foreignKeys) {
+const _foreignToOn = (csnElement, path, { select, join }) => {
+  // this is only for 2one managed w/o ON-conditions i.e. no static values are possible
+  const on = []
+  for (const key of csnElement._foreignKeys) {
     if (on.length !== 0) {
       on.push('and')
     }
-
-    // TODO static values possible here?
-
-    const ref1 = _toRef(aliases.select, key.prefix ? `${key.prefix}_${key.childFieldName}` : key.childFieldName)
-    const structPrefix = _structPrefix(csnElement)
-    const ref2 = _toRef(aliases.join, `${structPrefix}${key.parentFieldName}`)
+    const ref1 = _toRef(select, key.prefix ? `${key.prefix}_${key.childElement.name}` : key.childElement.name)
+    const structPrefix = path.length > 1 ? path.slice(0, -1) : []
+    const ref2 = _toRef(join, [...structPrefix, key.parentElement.name])
     on.push(ref1, '=', ref2)
   }
-
   return on
 }
 
-/**
- * Gets the `ON` conditions in CQN format based on the CSN.
- *
- * @param {object} csnElement
- * @param {import('../../types/api').ONConditionOptions} [options]
- * @returns {Array}
- * @private
- */
-function getOnCondNew(csnElement, options) {
-  const defaultOptions = {
-    aliases: {},
-    resolveView: true
-  }
-  options = { ...defaultOptions, ...options }
-  const { associationNames } = options
-
-  if (!Array.isArray(associationNames)) {
-    options.associationNames = [associationNames]
-  }
-
+const _newOnConditions = (csnElement, path, aliases) => {
   if (csnElement.keys) {
-    return _foreignToOn(csnElement, options)
+    return _foreignToOn(csnElement, path, aliases)
   }
 
-  return _args(csnElement, options)
+  return _args(csnElement, path, aliases)
 }
 
-const getOnCond = (...args) => {
-  return ['(', ...getOnCondNew(...args), ')']
+const getOnCond = (csnElement, path = [], aliases = { select: '', join: '' }) => {
+  return ['(', ..._newOnConditions(csnElement, path, aliases), ')']
 }
 
 module.exports = {

package/libx/_runtime/common/utils/{enrichWithKeysFromWhere.js → keys.js}

@@ -1,8 +1,23 @@
-const { getOnCondElements } = require('./backlinks')
+const { where2obj } = require('./cqn')
+
+function _getOnCondElements(onCond, onCondElements = []) {
+  const andIndex = onCond.indexOf('and')
+  const entityKey = onCond[2].ref && onCond[2].ref.join('.')
+  const entityVal = onCond[2].val
+  const targetKey = onCond[0].ref && onCond[0].ref.join('.')
+  const targetVal = onCond[0].val
+  onCondElements.push({ entityKey, targetKey, entityVal, targetVal })
+
+  if (andIndex !== -1) {
+    _getOnCondElements(onCond.slice(andIndex + 1), onCondElements)
+  }
+  return onCondElements
+}
 
 function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName) {
   if (where) {
-    const whereCopy = JSON.parse(JSON.stringify(where)) // copy where else query will be modified
+    // copy where else query will be modified
+    const whereCopy = JSON.parse(JSON.stringify(where))
     if (newWhere.length > 0) newWhere.push('and')
     newWhere.push(...whereCopy)
   }
@@ -14,7 +29,7 @@ function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName)
   })
 }
 
-const _buildWhereForNavigations = (ref, newWhere, model, target) => {
+function _buildWhereForNavigations(ref, newWhere, model, target) {
   const currentRef = ref[0]
   const nextRef = ref[1]
 
@@ -24,7 +39,7 @@ const _buildWhereForNavigations = (ref, newWhere, model, target) => {
 
     if (!navigationElement || !navigationElement.on) return
 
-    const nextKeys = getOnCondElements(navigationElement.on)
+    const nextKeys = _getOnCondElements(navigationElement.on)
     for (const key of nextKeys) {
       const keyName = key.targetKey.replace(navigationElement.name + '.', '')
       const targetKeyElement = navigationElement._target.elements[keyName]
@@ -55,37 +70,23 @@ function _getWhereFromUpdate(query, target, model) {
   return query.UPDATE.where
 }
 
-function _addKeysFromWhereToData(where, target, data) {
-  const whereLength = where.length
-  for (let i = 0; i < whereLength; i++) {
-    const whereEl = where[i]
-    const colName = whereEl.ref && whereEl.ref[whereEl.ref.length - 1]
-    const colEl = colName && target.elements[colName]
-    if (colEl && colEl.key) {
-      const opWhere = where[i + 1]
-      const valWhere = where[i + 2]
-      if (opWhere === '=' && valWhere && 'val' in valWhere) {
-        data[colName] = valWhere.val
-      }
-    }
-  }
-}
-
 // params: data, req, service/tx
-module.exports = (data, { query, target }, { model }) => {
+function enrichDataWithKeysFromWhere(data, { query, target }, { model }) {
   if (query.INSERT) {
     const where = _getWhereFromInsert(query, target, model)
     if (!where || !where.length) return
-
     if (!Array.isArray(data)) data = [data]
-
-    for (const d of data) {
-      _addKeysFromWhereToData(where, target, d)
-    }
+    for (const d of data) Object.assign(d, where2obj(where, target))
   } else if (query.UPDATE) {
     const where = _getWhereFromUpdate(query, target, model)
     if (!where || !where.length) return
-    if (!data) data = query.UPDATE.data = {} // REVISIT: We should not expect data to be present always!
-    _addKeysFromWhereToData(where, target, data)
+    // REVISIT: We should not expect data to be present always!
+    if (!data) data = query.UPDATE.data = {}
+    Object.assign(data, where2obj(where, target))
   }
 }
+
+module.exports = {
+  where2obj,
+  enrichDataWithKeysFromWhere
+}

package/libx/_runtime/common/utils/postProcessing.js

@@ -64,6 +64,9 @@ const handleAliasInResult = (columns, result) => {
 // REVISIT: todo renaming for deep operations
 const postProcess = (query, result, service, onlySelectAliases = false) => {
   if (query.SELECT) {
+    if (query.SELECT.columns && query.SELECT.columns.find(col => col.func === 'count' && col.as === '$count')) {
+      return [{ $count: result }]
+    }
     handleAliasInResult(query.SELECT.columns, result)
 
     if (!onlySelectAliases) {

package/libx/_runtime/common/utils/propagateForeignKeys.js

@@ -0,0 +1,84 @@
+const cds = require('../../cds')
+
+const _generateParentField = ({ parentElement }, row) => {
+  if (_autoGenerate(parentElement) && !row[parentElement.name]) {
+    row[parentElement.name] = cds.utils.uuid()
+  }
+}
+
+const _generateChildField = ({ deep, childElement }, childRow) => {
+  if (deep) {
+    _generateChildField(deep.propagation, childRow[deep.targetName])
+  } else if (_autoGenerate(childElement) && childRow && !childRow[childElement.name]) {
+    childRow[childElement.name] = cds.utils.uuid()
+  }
+}
+
+const _autoGenerate = e => e && e.type === 'cds.UUID' && e.key
+
+const _getNestedVal = (row, prefix) => {
+  let val = row
+  const splitted = prefix.split('_')
+  let k = ''
+
+  while (splitted.length > 0) {
+    k += splitted.shift()
+    if (k in val) {
+      val = val[k]
+      k = ''
+    } else {
+      k += '_'
+    }
+  }
+
+  return val
+}
+
+const _propagateToChid = ({ parentElement, childElement, prefix, parentFieldValue }, row, childRow) => {
+  if (!childElement) return
+  if (parentElement) {
+    if (prefix) {
+      const nested = _getNestedVal(row, prefix)
+      childRow[childElement.name] = nested[parentElement.name]
+    } else {
+      childRow[childElement.name] = row[parentElement.name]
+    }
+  } else if (parentFieldValue !== undefined) {
+    childRow[childElement.name] = parentFieldValue
+  }
+}
+
+const _propagateToParent = ({ parentElement, childElement, deep }, childRow, row) => {
+  if (deep) {
+    _propagateToParent(deep.propagation, childRow[deep.targetName], childRow)
+  }
+  if (parentElement && childElement && childRow && Object.prototype.hasOwnProperty.call(childRow, childElement.name)) {
+    row[parentElement.name] = childRow[childElement.name]
+  }
+}
+
+const propagateForeignKeys = (tKey, row, foreignKeyPropagations, isCompositionEffective) => {
+  const childRows = Array.isArray(row[tKey]) ? row[tKey] : [row[tKey]]
+
+  for (const childRow of childRows) {
+    if (!childRow) return
+
+    for (const foreignKeyPropagation of foreignKeyPropagations) {
+      if (foreignKeyPropagation.fillChild) {
+        _generateParentField(foreignKeyPropagation, row)
+        if (!isCompositionEffective) {
+          delete row[tKey]
+        } else {
+          _propagateToChid(foreignKeyPropagation, row, childRow)
+        }
+      } else {
+        _generateChildField(foreignKeyPropagation, childRow)
+        _propagateToParent(foreignKeyPropagation, childRow, row)
+      }
+    }
+  }
+}
+
+module.exports = {
+  propagateForeignKeys
+}

package/libx/_runtime/common/utils/resolveStructured.js

@@ -22,7 +22,7 @@ const _flattenProps = (subElement, structName, structProperties, structElement,
 
 const _resolveStructured = ({ structName, structProperties }, subElements, asRef = true) => {
   if (!subElements) {
-    return
+    return []
   }
 
   // only add from structProperties