@sap/cds 5.6.1 → 5.7.1

package/libx/_runtime/db/generic/integrity.js

@@ -1,32 +1,375 @@
 const cds = require('../../cds')
 const { SELECT } = cds.ql
 
+const crypto = require('crypto')
+
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
-const { getDependents } = require('../../common/utils/csn')
+const { all, resolve } = require('../../common/utils/thenable')
+const { assertError } = require('../../cds-services/util/assert')
+const { processDeepAsync } = require('../../cds-services/util/dataProcessUtils')
+
+const ASSERT_REFERENCE_INTEGRITY = 'ASSERT_REFERENCE_INTEGRITY'
+const ASSERT_INTEGRITY_ANNOTATION = '@assert.integrity'
+
+const CRUD = { CREATE: 1, READ: 1, UPDATE: 1, DELETE: 1 }
+const C_UD = { CREATE: 1, INSERT: 1, UPDATE: 1, DELETE: 1 }
 
-const CRUD = {
-  CREATE: 1,
-  READ: 1,
-  UPDATE: 1,
-  DELETE: 1
+/*
+ * UTILS
+ */
+
+const _requiresRuntimeCheck = def => {
+  const val = String(def['@assert.integrity']).toLowerCase()
+  if (val === 'rt') return true
+  if (val === 'db' || val === 'false') return false
+  if (val === 'true') {
+    const { assert_integrity_type: ait } = cds.env.features
+    if (ait && ait.match(/rt/i)) return true
+  }
 }
 
-const _skipIntegrityCheck = (req, tx) => {
-  // REVISIT: remove skipIntegrity after grace period
-  if (
-    (cds.env.features && cds.env.features.assert_integrity === false) ||
-    (cds.env.runtime && cds.env.runtime.skipIntegrity)
-  ) {
-    return true
+const _runtimeShallCheckIntegrityFor = (assoc, inclComps) => {
+  const { parent } = assoc
+
+  // disqualifications
+  if (!assoc._isAssociationStrict && !inclComps) return
+  if (!assoc.is2one) return
+  if (assoc.on) return
+  if (assoc._isCompositionBacklink) return
+  if (parent['@cds.persistence.skip']) return
+
+  // check @assert.integrity bottom-up and break on value (i.e., lowest spec wins)
+  if ('@assert.integrity' in assoc) {
+    const val = _requiresRuntimeCheck(assoc)
+    if (val !== undefined) return val
+  }
+  if ('@assert.integrity' in parent) {
+    const val = _requiresRuntimeCheck(parent)
+    if (val !== undefined) return val
+  }
+  if (parent._service && '@assert.integrity' in parent._service) {
+    const val = _requiresRuntimeCheck(parent._service)
+    if (val !== undefined) return val
   }
 
-  if (!tx.model) return true
+  // here, no disqualification and no @assert.integrity specified -> global setting
+  const { assert_integrity: ai, assert_integrity_type: ait } = cds.env.features
+  if (typeof ai === 'string' && ai.match(/individual/i)) return false
+  if (ait && ait.match(/db/i)) return false
+  return true
+}
+
+/*
+ * this modifies the csn on purpose for caching effect!
+ * doing as aspect is difficult due to no global definitons per tenant
+ */
+const _getDependents = (entity, model) => {
+  if (entity.own('__dependents')) return entity.__dependents
+
+  /** @type {Array|boolean} */
+  let dependents = []
+  for (const def of Object.values(model.definitions)) {
+    if (def.kind !== 'entity') continue
+    if (!def.associations) continue
+
+    for (const assoc of Object.values(def.associations)) {
+      if (assoc.target !== entity.name) continue
+
+      if (_runtimeShallCheckIntegrityFor(assoc)) {
+        dependents.push({ /* element: assoc, */ parent: assoc.parent, target: model.definitions[assoc.target] })
+      }
+    }
+  }
+
+  if (dependents.length === 0) dependents = false
+  return entity.set('__dependents', dependents)
+}
+
+const _getElement = (entity, ref) => {
+  if (ref.length > 1) return _getElement(entity.elements[ref[0]], ref.slice(1))
+  return entity.elements[ref[0]]
+}
+
+const _getFullForeignKeyName = (elementName, foreignKeyName) => `${elementName}_${foreignKeyName}`
+
+const _getDataFromRef = (row, ref) => {
+  if (row === undefined) return
+  if (ref.length > 1) return _getDataFromRef(row[ref[0]], ref.slice(1))
+  return row[ref[0]]
+}
 
+const _foreignKeyReducer = (key, foreignKeyName, row, element, ref) => {
+  const fullForeignKeyName = _getFullForeignKeyName(element.name, foreignKeyName)
+
+  if (ref.length > 1) {
+    // ref includes assoc name, so we need to replace it by foreign key name
+    const refWithFlatForeignKey = [...ref.slice(0, ref.length - 1), fullForeignKeyName]
+    key[foreignKeyName] = _getDataFromRef(row, refWithFlatForeignKey)
+  } else {
+    key[foreignKeyName] = Object.prototype.hasOwnProperty.call(row, fullForeignKeyName) ? row[fullForeignKeyName] : null
+  }
+
+  return key
+}
+
+const _buildForeignKey = (element, row, ref) => {
+  let foreignKey
+
+  if (element.keys) {
+    foreignKey = element.keys
+      .map(obj => obj.ref[obj.ref.length - 1])
+      .reduce((key, foreignKeyName) => {
+        return _foreignKeyReducer(key, foreignKeyName, row, element, ref)
+      }, {})
+  }
+
+  return foreignKey
+}
+
+const _checkExists = (entity, data, req, run) => {
+  if (!Array.isArray(data)) {
+    return _checkExists(entity, [data], req, run).then(result => {
+      return result[0]
+    })
+  }
+
+  const where = data.map(row => {
+    return Object.keys(entity.keys).reduce((where, name) => {
+      if (row[name] !== undefined && row[name] !== null) {
+        if (where.length > 0) {
+          where.push('and')
+        }
+        where.push({ ref: [name] }, '=', { val: row[name] })
+      }
+
+      return where
+    }, [])
+  })
+  return _checkExistsWhere(entity, where, run)
+}
+
+const _checkCreateUpdate = (result, ref, rootEntity, checks, data, req, run) => {
+  const resolvedElement = _getElement(rootEntity, ref)
+
+  // REVISIT: incl comps?!
+  if (!_runtimeShallCheckIntegrityFor(resolvedElement /* true */)) return result
+
+  // REVISIT: reduce should only be used to build object from array, not for loops!
+  return data.reduce((result, row) => {
+    const foreignKey = _buildForeignKey(resolvedElement, row, ref)
+    if (foreignKey === undefined || Object.values(foreignKey).every(v => v === null)) return result
+
+    // REVISIT: if incl comps, skip check if target is in payload
+    // if (resolvedElement.isComposition && resolvedElement.is2one && row[resolvedElement.name]) return result
+
+    checks.push(
+      _checkExists(resolvedElement._target, foreignKey, req, run).then(exists => {
+        if (!exists) {
+          result.push(assertError(ASSERT_REFERENCE_INTEGRITY, resolvedElement, foreignKey))
+        }
+      })
+    )
+
+    return result
+  }, result)
+}
+
+const _buildWhereDelete = (result, key, element, data) => {
+  return data
+    .map(d => {
+      return Object.keys(d).reduce((result, name) => {
+        if (key.ref[0] === name) {
+          if (result.length > 0) {
+            result.push('and')
+          }
+          result.push({ ref: [_getFullForeignKeyName(element.name, key.ref[0])] }, '=', { val: d[name] })
+        }
+
+        return result
+      }, result)
+    })
+    .reduce((accumulatedWhere, currentWhere, i) => {
+      if (i > 0) accumulatedWhere.push('or')
+      accumulatedWhere.push(...currentWhere)
+      return accumulatedWhere
+    }, [])
+}
+
+const _checkExistsWhere = (entity, whereList, run) => {
+  const checks = whereList.map(where => {
+    if (where.length === 0) return true
+
+    const query = {
+      SELECT: {
+        columns: [{ val: 1, as: '_exists' }],
+        from: { ref: [entity.name || entity] },
+        where: where,
+        limit: { rows: { val: 1 } }
+      }
+    }
+
+    if (cds.context) {
+      const hash = crypto.createHash('sha1').update(JSON.stringify(query)).digest('base64') // fastest hash
+      if (!cds.context.__alreadyExecutedIntegrityChecks) cds.context.__alreadyExecutedIntegrityChecks = new Map()
+
+      if (cds.context.__alreadyExecutedIntegrityChecks.has(hash)) {
+        return cds.context.__alreadyExecutedIntegrityChecks.get(hash)
+      }
+
+      const promise = run(query).then(exists => exists.length !== 0)
+
+      // we store the promise object in the map, it won't get executed twice when calling await Promise.all([promise, promise])
+      cds.context.__alreadyExecutedIntegrityChecks.set(hash, promise)
+      return promise
+    }
+
+    return run(query).then(exists => exists.length !== 0)
+  })
+
+  return all(checks)
+}
+
+const _checkDelete = (result, key, entity, checks, req, csn, run, data) => {
+  const elements = csn.definitions[key].elements
+  const source = csn.definitions[key].name
+
+  const dependents = _getDependents(req.target, csn) || []
+
+  const sourceDependent = dependents.find(dep => dep.parent.name === source)
+  if (!sourceDependent) return result
+
+  return Object.keys(elements).reduce((result, assoc) => {
+    if (!elements[assoc].target || !elements[assoc].keys) return result
+
+    const targetDependent = dependents.find(dep => dep.target.name === elements[assoc].target)
+    if (!targetDependent) return result
+
+    const where = elements[assoc].keys.reduce((buildWhere, key) => {
+      return _buildWhereDelete(buildWhere, key, elements[assoc], data)
+    }, [])
+    checks.push(
+      _checkExistsWhere(source, [where], run).then(exists => {
+        if (exists.includes(true)) {
+          result.push(assertError(ASSERT_REFERENCE_INTEGRITY, elements[assoc], req.data))
+        }
+      })
+    )
+    return result
+  }, result)
+}
+
+function _filterStructured(element, structuredAssocs, prefix) {
+  const elements = element.elements
+  for (const subElement in elements) {
+    if (_filterAssocs(elements[subElement], structuredAssocs, prefix)) {
+      structuredAssocs.push([...prefix, elements[subElement].name])
+    }
+  }
+}
+
+const _filterAssocs = (element, structuredAssocs, prefix = []) => {
+  if (element.elements) {
+    _filterStructured(element, structuredAssocs, [...prefix, element.name])
+  }
+
+  return (
+    // element._isAssociationStrict && // > comps handled by deep crud logic
+    element.isAssociation &&
+    !element.virtual &&
+    !element.abstract &&
+    element[ASSERT_INTEGRITY_ANNOTATION] !== false &&
+    !element._target._hasPersistenceSkip
+  )
+}
+
+const _checkReferenceIntegrity = (entity, data, req, csn, run) => {
+  const service = entity._service
+  if (entity[ASSERT_INTEGRITY_ANNOTATION] === false || (service && service[ASSERT_INTEGRITY_ANNOTATION] === false)) {
+    return
+  }
+
+  if (!Array.isArray(data)) data = [data]
+
+  const checks = []
+  let result
+  if (req.event === 'CREATE' || req.event === 'UPDATE') {
+    const structuredAssocRefs = []
+    const associationRefs = Object.keys(entity.elements)
+      .filter(elementName => _filterAssocs(entity.elements[elementName], structuredAssocRefs))
+      .map(name => [name])
+    result = [...associationRefs, ...structuredAssocRefs].reduce((createUpdateResult, ref) => {
+      return _checkCreateUpdate(createUpdateResult, ref, entity, checks, data, req, run)
+    }, [])
+  }
+  if (req.event === 'DELETE') {
+    // we are only interested in table-level references not all derived ones on view levels
+    // TODO: why?
+    while (entity.query && entity.query._target) {
+      entity = csn.definitions[entity.query._target.name]
+    }
+
+    result = Object.keys(csn.definitions)
+      .filter(
+        key =>
+          !csn.definitions[key]['@cds.persistence.skip'] &&
+          csn.definitions[key].elements !== undefined &&
+          // skip check for events, aspects and localized tables
+          csn.definitions[key].kind !== 'event' &&
+          csn.definitions[key].kind !== 'aspect' &&
+          csn.definitions[key].kind !== 'type' &&
+          !csn.definitions[key].name.startsWith('localized.')
+      )
+      .reduce((deleteResult, key) => {
+        return _checkDelete(deleteResult, key, entity, checks, req, csn, run, data)
+      }, [])
+  }
+
+  if (checks.length) {
+    return Promise.all(checks).then(() => {
+      return result
+    })
+  }
+
+  return resolve(result || [])
+}
+
+const _checkIntegrityWrapper = (req, csn, run) => async (data, entity) => {
+  const errors = await _checkReferenceIntegrity(entity, data, req, csn, run)
+  if (errors && errors.length !== 0) for (const err of errors) req.error(err)
+}
+
+const _isUncheckableInsert = query => query.INSERT && (query.INSERT.rows || query.INSERT.values || query.INSERT.as)
+
+const _checkIntegrityUtil = async (req, csn, run) => {
+  if (!run) return
+  if (typeof req.query === 'string' || req.target._unresolved) return
+  if (_isUncheckableInsert(req.query)) return
+
+  // REVISIT: integrity check needs context.data
+  if (Object.keys(req.data).length === 0) {
+    // REVISIT: We may need to double-check re req.data being undefined or empty
+    if (req.query.DELETE) {
+      req.data = req._beforeDeleteData || {}
+    } else if (req.context && req.context.data && Object.keys(req.context.data).length > 0) {
+      req.data = req.context.data
+    }
+  }
+  if (Object.keys(req.data).length === 0) return
+
+  await processDeepAsync(_checkIntegrityWrapper(req, csn, run), req.data, req.target, false, true)
+}
+
+/*
+ * HANDLERS
+ */
+
+const _skipIntegrityCheck = (req, tx) => {
+  if (cds.env.features.assert_integrity === false) return true
+  if (!tx.model) return true
   if (req.event in CRUD) {
     if (typeof req.query === 'string') return true
     if (!req.target || req.target._unresolved) return true
   }
-
   return false
 }
 
@@ -45,18 +388,18 @@ async function beforeDelete(req) {
   if (!target) return
 
   // only if target has dependents (i.e., is the target of a managed to one association)
-  const dependents = getDependents(target, this.model)
+  const dependents = _getDependents(target, this.model)
   if (!dependents) return
 
   const keys = Object.keys(target.keys).filter(k => _isPrimitiveKey(target.elements[k]) && k !== 'IsActiveEntity')
-  let select = SELECT(keys).from(req.target.name)
+  let selectQuery = SELECT(keys).from(req.target.name)
+
   if (req.query.DELETE.where) {
-    select = select.where(req.query.DELETE.where)
+    selectQuery = selectQuery.where(req.query.DELETE.where)
   }
 
-  select = cqn2cqn4sql(select, this.model, { service: this })
-
-  req._beforeDeleteData = await this._read(this.model, this.dbc, select, req.context || req)
+  selectQuery = cqn2cqn4sql(selectQuery, this.model, { service: this })
+  req._beforeDeleteData = await this._read(this.model, this.dbc, selectQuery, req.context || req)
 }
 
 beforeDelete._initial = true
@@ -64,9 +407,6 @@ beforeDelete._initial = true
 /*
  * perform check
  */
-const { checkIntegrityUtil } = require('../../cds-services/services/utils/handlerUtils')
-const C_UD = { CREATE: 1, INSERT: 1, UPDATE: 1, DELETE: 1 }
-
 const _performCheck = async (req, cur, csn, run) => {
   const prev = (cur.errors && cur.errors.length) || 0
 
@@ -74,11 +414,11 @@ const _performCheck = async (req, cur, csn, run) => {
     for (const each of cur.query) {
       const r = { query: each, target: each._target, event: each.cmd === 'INSERT' ? 'CREATE' : each.cmd }
       Object.setPrototypeOf(r, cur)
-      await checkIntegrityUtil(r, csn, run)
+      await _checkIntegrityUtil(r, csn, run)
       if (r.errors && r.errors.length) r.errors.forEach(e => req.error(e))
     }
   } else {
-    await checkIntegrityUtil(cur, csn, run)
+    await _checkIntegrityUtil(cur, csn, run)
   }
 
   // only additional errors
@@ -99,6 +439,7 @@ function performCheck(req) {
     if (Array.isArray(r.query)) return r.query.some(q => q.cmd in C_UD)
     return r.query && r.query.cmd in C_UD
   })
+
   if (relevant.length === 0) return
 
   return Promise.all(

package/libx/_runtime/db/generic/virtual.js

@@ -3,11 +3,18 @@
  */
 
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { getEntityNameFromCQN } = require('../../common/utils/entityFromCqn')
 
-const _convert = (columns, target, model) => {
+const _getElement = (ref, target, alias) =>
+  alias
+    ? (ref[0] === alias && target.elements[ref[1]]) || target.elements[ref[0]]
+    : target.elements[ref[0]] || target.elements[ref[1]]
+
+const _convert = (columns, target, model, alias) => {
   if (!target) return
   for (const col of columns) {
-    const element = col.ref && target.elements[col.ref[col.ref.length - 1]]
+    if (!col.ref) continue
+    const element = _getElement(col.ref, target, alias)
     if (element) {
       if (element.virtual) {
         col.as = col.as || col.ref[col.ref.length - 1]
@@ -21,22 +28,53 @@ const _convert = (columns, target, model) => {
   }
 }
 
-const convertVirtuals = function (req, _model) {
-  const model = this.model || _model
-  // target.name ensures it is not a union or join
-  if (typeof req.query === 'string' || !req.target || typeof req.target.name !== 'string' || !model) return
-  const target = (!req.target._unresolved && req.target) || model.definitions[ensureNoDraftsSuffix(req.target.name)]
-  const columns = (req.query && req.query.SELECT && req.query.SELECT.columns) || []
-  _convert(columns, target, model)
-  if (req.query.SELECT.from && req.query.SELECT.from.SET) {
-    for (const arg of req.query.SELECT.from.SET.args) {
-      const target = model.definitions[ensureNoDraftsSuffix(arg._target.name)]
+const _convert4ref = (query, model) => {
+  const { entityName, alias } = getEntityNameFromCQN(query)
+  const columns = query.SELECT.columns || []
+  const target = entityName && model.definitions[ensureNoDraftsSuffix(entityName)]
+  if (target) _convert(columns, target, model, alias)
+}
+
+const _convert4union = (SELECT, model) => {
+  for (const arg of SELECT.from.SET.args) {
+    const { entityName, alias } = getEntityNameFromCQN(arg)
+    const target = entityName && model.definitions[ensureNoDraftsSuffix(entityName)]
+    if (target) {
       const columns = (arg.SELECT && arg.SELECT.columns) || []
-      _convert(columns, target, model, true)
+      _convert(columns, target, model, alias)
+    }
+  }
+}
+
+const _convert4join = (SELECT, model) => {
+  const columns = SELECT.columns || []
+  for (const arg of SELECT.from.args) {
+    const { entityName, alias } = getEntityNameFromCQN(arg)
+    const target = entityName && model.definitions[ensureNoDraftsSuffix(entityName)]
+    if (target) {
+      _convert(columns, target, model, alias)
     }
   }
 }
 
+// REVISIT: Refactor to have a generic 'columns processor'
+const _convertViruals = (query, model) => {
+  if (!query.SELECT.from) return
+  if (query.SELECT.from.SET) return _convert4union(query.SELECT, model)
+  if (query.SELECT.from.args) return _convert4join(query.SELECT, model)
+  if (query.SELECT.from.SELECT) {
+    _convert4ref(query, model)
+    return _convertViruals(query.SELECT.from, model)
+  }
+  return _convert4ref(query, model)
+}
+
+const convertVirtuals = function (req, _model) {
+  const model = this.model || _model
+  if (!model) return
+  if (req.query.SELECT) _convertViruals(req.query, model)
+}
+
 convertVirtuals._initial = true
 
 module.exports = {

package/libx/_runtime/db/query/update.js

@@ -26,11 +26,13 @@ const _getFilteredCqns = (cqns, model) => {
     let moreThanManaged = Object.keys(cqn.UPDATE.data).some(
       k => entity.elements[k]['@cds.on.update'] === undefined || !cqn.UPDATE.data[k].startsWith('$')
     )
+
     if (moreThanManaged) continue
 
     // REVISIT: remove feature flag update_header_item after grace period of at least two months (> April release)
     if (cds.env.features.update_header_item !== false) {
       const comps = Object.values(entity.associations || {}).filter(assoc => assoc._isCompositionEffective)
+
       for (const comp of comps) {
         if (_includesCompositionTarget(cqns, comp.target)) {
           moreThanManaged = true
@@ -38,6 +40,7 @@ const _getFilteredCqns = (cqns, model) => {
         }
       }
     }
+
     if (moreThanManaged) continue
 
     // remove current cqn
@@ -54,11 +57,12 @@ const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query,
   if (hasDeepUpdate(model && model.definitions, query)) {
     // REVISIT: _activeData gets set in case of draftActivate for performance, but this is a layer violation
     let selectData = req._ && req._.query && req._.query._activeData
-    if (!selectData) {
+
+    if (selectData) {
+      selectData = [selectData]
+    } else {
       // REVISIT: avoid additional read
       selectData = await selectDeepUpdateData(model && model.definitions, query, req, false, false, cds.db)
-    } else {
-      selectData = [selectData]
     }
 
     let cqns = getDeepUpdateCQNs(model && model.definitions, query, selectData)
@@ -71,9 +75,11 @@ const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query,
     cqns = _getFilteredCqns(getFlatArray(cqns), model)
 
     if (cqns.length === 0) return 0
+
     const results = await processCQNs(executeUpdateCQN, cqns, model, dbc, user, locale, isoTs, chunks)
     // return number of affected rows of "root cqn", if an update, 1 otherwise (as not update of root but its children)
     if (cqns[0].UPDATE) return results[0]
+
     return 1
   }
 

package/libx/_runtime/db/sql-builder/ExpressionBuilder.js

@@ -87,15 +87,9 @@ class ExpressionBuilder extends BaseBuilder {
   }
 
   _isStructured(op1, comp, op2) {
-    if (op1.ref && comp === '=' && op2.val && typeof op2.val === 'object') {
-      return true
-    }
+    if (op1.ref && comp === '=' && op2.val && typeof op2.val === 'object' && !(op2.val instanceof Buffer)) return true
     // also check reverse
-    if (op1.val && typeof op1.val === 'object' && comp === '=' && op2.ref) {
-      return true
-    }
-
-    return false
+    if (op1.val && typeof op1.val === 'object' && comp === '=' && op2.ref && !(op1.val instanceof Buffer)) return true
   }
 
   _expressionObjectsToSQL(objects) {
@@ -120,6 +114,7 @@ class ExpressionBuilder extends BaseBuilder {
           i += 3
           continue
         }
+
         this._expressionElementToSQL(objects[i])
         i++
       }
@@ -239,7 +234,7 @@ class ExpressionBuilder extends BaseBuilder {
     }
 
     if (Array.isArray(values.list)) {
-      this._addToOutputObj(new this.ReferenceBuilder(reference, this._options, this._csn).build(), false)
+      this._expressionElementToSQL(reference)
       this._outputObj.sql.push(operator)
       this._addListToOutputObj(values.list)
       return true
@@ -283,6 +278,10 @@ class ExpressionBuilder extends BaseBuilder {
     )
   }
 
+  /**
+   * This method is overridden in sqlite Expression Builder in order to add the required "VALUES" keyword if needed
+   * Make sure to adapt the overridden function as well, if adapting this.
+   */
   _addListToOutputObj(list) {
     this._outputObj.sql.push('(')
 

package/libx/_runtime/{common → db}/utils/propagateForeignKeys.js

@@ -1,5 +1,7 @@
 const cds = require('../../cds')
 
+const _autoGenerate = e => e && e.type === 'cds.UUID' && e.key
+
 const _generateParentField = ({ parentElement }, row) => {
   if (_autoGenerate(parentElement) && !row[parentElement.name]) {
     row[parentElement.name] = cds.utils.uuid()
@@ -14,8 +16,6 @@ const _generateChildField = ({ deep, childElement }, childRow) => {
   }
 }
 
-const _autoGenerate = e => e && e.type === 'cds.UUID' && e.key
-
 const _getNestedVal = (row, prefix) => {
   let val = row
   const splitted = prefix.split('_')
@@ -52,12 +52,12 @@ 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)) {
+  if (parentElement && childElement && childRow && childElement.name in childRow) {
     row[parentElement.name] = childRow[childElement.name]
   }
 }
 
-const propagateForeignKeys = (tKey, row, foreignKeyPropagations, isCompositionEffective) => {
+module.exports = (tKey, row, foreignKeyPropagations, isCompositionEffective) => {
   const childRows = Array.isArray(row[tKey]) ? row[tKey] : [row[tKey]]
 
   for (const childRow of childRows) {
@@ -65,12 +65,13 @@ const propagateForeignKeys = (tKey, row, foreignKeyPropagations, isCompositionEf
 
     for (const foreignKeyPropagation of foreignKeyPropagations) {
       if (foreignKeyPropagation.fillChild) {
-        _generateParentField(foreignKeyPropagation, row)
-        if (!isCompositionEffective) {
-          delete row[tKey]
-        } else {
-          _propagateToChid(foreignKeyPropagation, row, childRow)
-        }
+        // propagate or generate in parent
+        const pk = foreignKeyPropagation.parentElement && foreignKeyPropagation.parentElement.name
+        if (pk && !(pk in row)) _propagateToParent(foreignKeyPropagation, childRow, row)
+        if (!(pk in row)) _generateParentField(foreignKeyPropagation, row)
+
+        if (!isCompositionEffective) delete row[tKey]
+        else _propagateToChid(foreignKeyPropagation, row, childRow)
       } else {
         _generateChildField(foreignKeyPropagation, childRow)
         _propagateToParent(foreignKeyPropagation, childRow, row)
@@ -78,7 +79,3 @@ const propagateForeignKeys = (tKey, row, foreignKeyPropagations, isCompositionEf
     }
   }
 }
-
-module.exports = {
-  propagateForeignKeys
-}