@sap/cds 5.7.5 → 5.8.2

package/libx/_runtime/common/generic/auth.js

@@ -5,7 +5,7 @@
 const cds = require('../../cds')
 const { SELECT } = cds.ql
 
-const { getRequiresAsArray } = require('../utils/auth')
+const { getRequiresAsArray } = require('../../auth/utils')
 const { cqn2cqn4sql } = require('../utils/cqn2cqn4sql')
 const { isActiveEntityRequested, removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { ensureNoDraftsSuffix } = require('../../fiori/utils/handler')
@@ -226,88 +226,6 @@ const _getMergedWhere = restricts => {
   return xprs
 }
 
-const _findTableName = (ref, aliases) => {
-  const maxLength = Math.max(...aliases.map(alias => alias.length))
-  let name = ''
-  for (let i = 0; i < ref.length; i++) {
-    name += name.length !== 0 ? `.${ref[i]}` : ref[i]
-
-    if (name >= maxLength) {
-      break
-    }
-
-    const aliasIndex = aliases.indexOf(name)
-    if (aliasIndex !== -1) {
-      return { refIndex: i, aliasIndex: aliasIndex, name: name }
-    }
-  }
-
-  return { refIndex: -1 }
-}
-
-const _getTableForColumn = (col, aliases, model) => {
-  for (let i = 0; i < aliases.length; i++) {
-    const index = aliases.length - i - 1
-    const alias = aliases[index]
-    if (Object.keys(model.definitions[alias].elements).includes(col)) {
-      return { index, table: alias.replace(/\./g, '_') }
-    }
-  }
-
-  return { index: -1 }
-}
-
-const _adaptTableName = (ref, index, name) => {
-  const tableName = name.replace(/\./g, '_')
-  ref.splice(0, index + 1, tableName)
-}
-
-const _ensureTableAlias = (ref, aliases, targetFrom, model, hasExpand) => {
-  const nameObj = _findTableName(ref, aliases)
-  if (nameObj.refIndex === -1) {
-    const { index, table } = _getTableForColumn(ref[0], aliases, model)
-    if (index !== -1) {
-      nameObj.aliasIndex = index
-      if (table === targetFrom.name && targetFrom.as) {
-        ref.unshift(targetFrom.as)
-      } else {
-        ref.unshift(table)
-      }
-    }
-  } else {
-    _adaptTableName(ref, nameObj.refIndex, nameObj.name)
-  }
-}
-
-const _enhanceAnnotationSubSelect = (select, model, targetName, targetFrom, hasExpand) => {
-  if (select.where) {
-    for (const v of select.where) {
-      if (v.ref && select.from.ref) {
-        _ensureTableAlias(v.ref, [targetName, select.from.ref[0]], targetFrom, model, hasExpand)
-      }
-    }
-  }
-}
-
-// Add alias symbols to refs if needed and mark ref (for expand) and SELECT.from (for draft)
-const _enhanceAnnotationWhere = (query, where, model) => {
-  const cqn2cqn4sqlOptions = { suppressSearch: true }
-  query = cqn2cqn4sql(query, model, cqn2cqn4sqlOptions)
-  const hasExpand = query.SELECT && query.SELECT.columns && query.SELECT.columns.some(col => col.expand)
-  const targetFrom = query.SELECT
-    ? { name: query.SELECT.from.ref[0].replace(/\./g, '_'), as: query.SELECT.from.as }
-    : {}
-  for (const w of where) {
-    if (w.ref) {
-      // REVISIT: can this case be removed permanently?
-      // _ensureTableAlias(w.ref, [query._target.name], targetFrom, model, hasExpand)
-    } else if (w.SELECT) {
-      _enhanceAnnotationSubSelect(w.SELECT, model, query._target.name, targetFrom, hasExpand)
-      w.SELECT.__targetFrom = targetFrom
-    }
-  }
-}
-
 const _getApplicables = (restricts, req) => {
   return restricts.filter(restrict => {
     const event = DRAFT2CRUD[req.event] || req.event
@@ -419,9 +337,26 @@ const _addRestrictionsToRead = async (req, model, resolvedApplicables) => {
 
   const restrictionForTarget = _getRestrictionForTarget(resolvedApplicables, req.target)
   if (restrictionForTarget) {
+    // adjust free subselects, if necessary
+    if (resolvedApplicables.some(ra => ra.where.match(/\s*exists\s*\(\s*select\s*1\s*/i))) {
+      for (const ele of restrictionForTarget) {
+        if (typeof ele !== 'object' || !ele.SELECT || !ele.SELECT.where) continue
+        for (const w of ele.SELECT.where) {
+          if (w.ref && w.ref.length > 2) {
+            let path = w.ref[0]
+            if (!model.definitions[path]) continue
+            let i = 1
+            for (; i < w.ref.length; i++) {
+              if (model.definitions[`${path}.${w.ref[i]}`]) path += `.${w.ref[i]}`
+              else break
+            }
+            w.ref = [path, ...w.ref.slice(i)]
+          }
+        }
+      }
+    }
+    // apply restriction
     req.query.where(restrictionForTarget)
-    // REVISIT: remove with cds^6
-    _enhanceAnnotationWhere(req.query, restrictionForTarget, model)
   }
 }
 

package/libx/_runtime/common/generic/crud.js

@@ -4,6 +4,7 @@ const { SELECT } = cds.ql
 const getTemplate = require('../utils/template')
 const templateProcessor = require('../utils/templateProcessor')
 const replaceManagedData = require('../utils/dollar')
+const { deepCopyArray } = require('../utils/copy')
 
 const onlyKeysRemain = require('../utils/onlyKeysRemain')
 
@@ -67,6 +68,7 @@ const _updateReqData = (req, that) => {
 }
 
 module.exports = cds.service.impl(function () {
+  // eslint-disable-next-line complexity
   this.on(['CREATE', 'READ', 'UPDATE', 'DELETE'], '*', async function (req) {
     if (typeof req.query !== 'string' && req.target && req.target._hasPersistenceSkip) {
       req.reject(501, 'PERSISTENCE_SKIP_NO_GENERIC_CRUD', [req.target.name])
@@ -77,6 +79,19 @@ module.exports = cds.service.impl(function () {
 
     let result
 
+    // validate that all elements in path exist on db, if necessary
+    // - INSERT has no where clause to do this in one roundtrip
+    // - SELECT returns [] -> really empty collection or invalid path?
+    let pathExistsQuery
+    const { ref } = (req.query.INSERT && req.query.INSERT.into) || (req.query.SELECT && req.query.SELECT.from) || {}
+    // REVISIT: why is copy necessary?
+    if (ref && ref.length > 1) pathExistsQuery = SELECT(1).from({ ref: deepCopyArray(ref.slice(0, -1)) })
+
+    if (req.event === 'CREATE' && pathExistsQuery) {
+      const res = await pathExistsQuery
+      if (res.length === 0) req.reject(404)
+    }
+
     // no changes, no op (otherwise, @cds.on.update gets new values), but we need to check existence
     if (req.event === 'UPDATE' && onlyKeysRemain(req)) {
       if (await _targetEntityDoesNotExist(req)) req.reject(404)
@@ -95,7 +110,13 @@ module.exports = cds.service.impl(function () {
       result = await cds.tx(req).run(req.query, req.data)
     }
 
-    if (req.event === 'READ') return result
+    if (req.event === 'READ') {
+      if ((result == null || result.length === 0) && pathExistsQuery) {
+        const res = await pathExistsQuery
+        if (res.length === 0) req.reject(404)
+      }
+      return result
+    }
 
     if (req.event === 'DELETE') {
       if (result === 0) req.reject(404)

package/libx/_runtime/common/i18n/messages.properties

@@ -55,6 +55,7 @@ NON_WRITABLE_VIEW={0} on views with join and/or union is not supported
 # db
 NO_DATABASE_CONNECTION=No database connection
 ENTITY_ALREADY_EXISTS=Entity already exists
+ENTITY_LOCKED=Entity locked
 UNIQUE_CONSTRAINT_VIOLATION=Unique constraint violation
 FK_CONSTRAINT_VIOLATION=Foreign key constraint violation
 
@@ -72,8 +73,8 @@ ENTITY_IS_NOT_CRUD=Entity "{0}" is not {1}
 ENTITY_IS_NOT_CRUD_VIA_NAVIGATION=Entity "{0}" is not {1} via association "{2}"
 ENTITY_IS_AUTOEXPOSED=Entity "{0}" is not explicitely exposed as part of the service
 EXPAND_IS_RESTRICTED=Navigation property "{0}" is not allowed for expand operation
-
 EXPAND_COUNT_UNSUPPORTED="$count" is not supported for expand operation
+ORDERBY_LAMBDA_UNSUPPORTED="$orderby" does not support lambda
 
 # rest protocol adapter
 INVALID_RESOURCE="{0}" is not a valid resource

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

@@ -52,12 +52,8 @@ function targetFromPath(path, model) {
         ? definitions[current.elements[r.id].target]
         : definitions[r.id] || definitions[r.id.replace(/_drafts$/, '')]
     } else {
-      const next = current.elements[r]
-      if (next.isAssociation) {
-        current = definitions[next.target]
-      } else {
-        current = next
-      }
+      const next = current ? current.elements[r] : definitions[r]
+      current = next.isAssociation ? definitions[next.target] : next
     }
   }
   return current

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

@@ -13,54 +13,10 @@ const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
 const { addToWhere } = require('../../common/utils/cqn')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { addRefToWhereIfNecessary } = require('../../../odata/afterburner')
+const { addAliasToExpression, PARENT_ALIAS, FOREIGN_ALIAS } = require('../../db/utils/generateAliases')
 
-const PARENT_ALIAS = '_parent_'
-const PARENT_ALIAS_REGEX = new RegExp('^' + PARENT_ALIAS + '\\d*$')
-const FOREIGN_ALIAS = '_foreign_'
 const OPERATIONS = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in']
 
-// special case in lambda functions
-const _addParentAlias = (where, alias) => {
-  where.forEach(e => {
-    if (e.ref && e.ref[0].match(PARENT_ALIAS_REGEX)) {
-      e.ref[0] = alias
-    }
-  })
-}
-
-const _addAliasToElement = (e, alias) => {
-  if (e.ref) {
-    return { ref: [alias, ...e.ref] }
-  }
-
-  if (e.list) {
-    return { list: e.list.map(arg => _addAliasToElement(arg, alias)) }
-  }
-
-  if (e.func) {
-    const args = e.args.map(arg => _addAliasToElement(arg, alias))
-    return { ...e, args }
-  }
-
-  if (e.SELECT && e.SELECT.where) {
-    _addParentAlias(e.SELECT.where, alias)
-  }
-
-  if (e.xpr) {
-    return { xpr: e.xpr.map(e1 => _addAliasToElement(e1, alias)) }
-  }
-
-  return e
-}
-
-const _addAliasToExpression = (expression, alias) => {
-  if (!alias) {
-    return expression
-  }
-
-  return expression.map(e => _addAliasToElement(e, alias))
-}
-
 const _elementFromRef = (name, entity) => {
   if (!entity) return
 
@@ -112,7 +68,7 @@ const convertPathExpressionToWhere = (fromClause, model, options) => {
     const currentSelect = SELECT.from(`${currentEntityName} as ${tableAlias}`)
 
     if (fromClause.ref[i].where) {
-      currentSelect.where(_addAliasToExpression(fromClause.ref[i].where, tableAlias))
+      currentSelect.where(addAliasToExpression(fromClause.ref[i].where, tableAlias))
     }
 
     // REVISIT: Only args in last segment are handled, intermediate ones are ignored
@@ -326,35 +282,15 @@ const _createWindowCQN = (SELECT, model) => {
   delete SELECT.groupBy
 }
 
-const _isAny = element => {
-  return Array.isArray(element.ref) && element.ref.slice(-1)[0].id
+const _unshiftRefsWithNavigation = nav => el => {
+  if (el.ref) return { ref: [...nav, ...el.ref] }
+  if (el.xpr) return { xpr: el.xpr.map(_unshiftRefsWithNavigation(nav)) }
+  return el
 }
 
-const _isAll = element => {
-  const last = Array.isArray(element.ref) && element.ref.slice(-1)[0]
-  return last && last.id && last.where && last.where[0] === 'not' && last.where[1].xpr
-}
-
-// eslint-disable-next-line complexity
-const _getWhereExistsSubSelect = (cqn, where, index, model, options) => {
-  const _unshiftRefsWithNavigation = nav => el => {
-    if (el.ref) return { ref: [...nav, ...el.ref] }
-    if (el.xpr) return { xpr: el.xpr.map(_unshiftRefsWithNavigation(nav)) }
-    return el
-  }
-
-  if (!options.lambdaIteration) options.lambdaIteration = 1
-  const outerAlias =
-    (cqn.SELECT.from.ref && cqn.SELECT.from.as) ||
-    (cqn.SELECT.from.args && cqn.SELECT.from.args[0].ref && cqn.SELECT.from.args[0].as) ||
-    PARENT_ALIAS + options.lambdaIteration
-  const innerAlias = FOREIGN_ALIAS + options.lambdaIteration
-  cqn.SELECT.from.as = outerAlias
-  const ref = cqn.SELECT.from.ref || (cqn.SELECT.from.args && cqn.SELECT.from.args[0].ref)
-  const queryTarget = getEntityFromPath(getPathFromRef(ref), model)
-
-  let nav = where[index].ref.map(el => (el.id ? el.id : el))
-  const last = where[index].ref.slice(-1)[0]
+const _getWhereExistsSubSelect = (queryTarget, outerAlias, innerAlias, ref, model, options) => {
+  let nav = ref.map(el => (el.id ? el.id : el))
+  const last = ref.slice(-1)[0]
   const navName = queryTarget.elements[nav[0]] ? nav[0] : nav[nav.length - 1]
   const navElement = queryTarget.elements[navName]
 
@@ -381,17 +317,24 @@ const _getWhereExistsSubSelect = (cqn, where, index, model, options) => {
       : last.where
     : undefined
 
+  if (!innerAlias && !outerAlias) {
+    innerAlias = navElement.target
+    outerAlias = navElement.parent.name
+  }
+
   const subSelect = SELECT.from({ ref: [navElement.target], as: innerAlias })
   if (condition) {
     if (subSelect.SELECT.from.as) {
       for (let i = 0; i < condition.length; i++) {
+        if (!condition[i].ref) continue
         if (
-          condition[i].ref &&
           condition[i].ref.length > 1 &&
           condition[i].ref.every(r => typeof r === 'string') &&
           condition[i].ref[0] === navName
         ) {
           condition[i].ref[0] = subSelect.SELECT.from.as
+        } else if (condition[i].ref.length === 1) {
+          condition[i].ref.unshift(subSelect.SELECT.from.as)
         }
       }
     }
@@ -446,42 +389,9 @@ const _ensureExpandedNestedWhereExists = ({ ref }, aliases) => {
   return { ref: [acc] }
 }
 
-const _convertWhereExists = (where, cqn, model, options) => {
-  for (let i = 0; i < where.length; i++) {
-    const element = where[i]
-
-    // ensure where exists are fully expanded
-    if (
-      (element === 'exists' && where[i + 1].ref && where[i > 1 ? i - 1 : 0] !== 'not') ||
-      (element === 'not' && where[i + 1] === 'exists' && where[i + 2].ref)
-    ) {
-      const offset = element === 'not' ? 2 : 1
-      const aliases = cqn.SELECT.from.as
-        ? [cqn.SELECT.from.as]
-        : cqn.SELECT.from.join
-        ? cqn.SELECT.from.args.map(arg => arg.as)
-        : []
-      where[i + offset] = _ensureExpandedNestedWhereExists(where[i + offset], aliases)
-    }
-
-    if (element.xpr) {
-      _convertWhereExists(element.xpr, cqn, model, options) // > recursing into nested {xpr}
-    } else if (element === 'exists' && _isAny(where[i + 1])) {
-      where[i + 1] = _getWhereExistsSubSelect(cqn, where, i + 1, model, options)
-    } else if (element === 'not' && where[i + 1] === 'exists' && _isAll(where[i + 2])) {
-      where[i + 2] = _getWhereExistsSubSelect(cqn, where, i + 2, model, options)
-    }
-  }
-}
-
-const convertWhereExists = (cqn, model, options) => {
-  if (cqn.SELECT.where) _convertWhereExists(cqn.SELECT.where, cqn, model, options)
-}
-
 const _getRefIndex = (where, index) => {
   if (
     where[index - 1].ref &&
-    // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called there
     where[index - 1].ref[where[index - 1].ref.length - 1] !== 'InProcessByUser' &&
     where[index + 1].val !== undefined &&
     where[index + 1].val !== null &&
@@ -491,7 +401,6 @@ const _getRefIndex = (where, index) => {
   }
   if (
     where[index + 1].ref &&
-    // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called there
     where[index + 1].ref[where[index + 1].ref.length - 1] !== 'InProcessByUser' &&
     where[index - 1].val !== undefined &&
     where[index - 1].val !== null &&
@@ -501,6 +410,77 @@ const _getRefIndex = (where, index) => {
   }
 }
 
+const _convertWhereExistsColumn = (column, model, options, queryTarget) => {
+  const lambdaIteration = options.lambdaIteration
+  if (typeof column === 'object') {
+    if (column.SELECT) {
+      convertWhereExists(column.SELECT, model, options)
+      options.lambdaIteration = lambdaIteration
+    } else if (column.where) {
+      convertWhereExists(column, model, options, queryTarget)
+      options.lambdaIteration = lambdaIteration
+    }
+  }
+}
+
+// eslint-disable-next-line complexity
+const convertWhereExists = (query, model, options, currentTarget) => {
+  const { where, columns, expand } = query
+  let innerAlias, outerAlias, queryTarget
+  const { ref, as } =
+    (query.ref && query) ||
+    (query.from &&
+      ((query.from.ref && query.from) || (query.from.args && query.from.args[0].ref && query.from.args[0]))) ||
+    {}
+  if (!ref) return
+
+  if (!options.lambdaIteration) options.lambdaIteration = 1
+  const lambdaIteration = options.lambdaIteration
+  if (!currentTarget) {
+    queryTarget = getEntityFromPath(getPathFromRef(ref), model)
+    outerAlias = as || PARENT_ALIAS + lambdaIteration
+    innerAlias = FOREIGN_ALIAS + lambdaIteration
+  } else {
+    const element = currentTarget.elements[ref]
+    if (element && element.isAssociation) {
+      queryTarget = element._target
+    }
+  }
+
+  if (where) {
+    for (let i = 0; i < where.length; i++) {
+      const element = where[i]
+
+      // ensure where exists are fully expanded
+      if (element === 'exists' && where[i + 1].ref) {
+        const ref = query.from || query
+        const aliases = ref.as ? [ref.as] : ref.join ? ref.args.map(arg => arg.as) : []
+        where[i + 1] = _ensureExpandedNestedWhereExists(where[i + 1], aliases)
+      }
+
+      if (element.xpr) {
+        convertWhereExists({ ...query, where: element.xpr }, model, options) // > recursing into nested {xpr}
+      } else if (element === 'exists' && where[i + 1].ref) {
+        if (query.from) {
+          query.from.as = outerAlias
+        }
+        where[i + 1] = _getWhereExistsSubSelect(queryTarget, outerAlias, innerAlias, where[i + 1].ref, model, options)
+        i += 1
+      } else if (element.SELECT) {
+        convertWhereExists(element.SELECT, model, options)
+      }
+      options.lambdaIteration = lambdaIteration
+    }
+  }
+
+  if (columns) {
+    columns.forEach(column => _convertWhereExistsColumn(column, model, options, queryTarget))
+  }
+  if (expand && expand !== '*') {
+    expand.forEach(column => _convertWhereExistsColumn(column, model, options, queryTarget))
+  }
+}
+
 const _convertNotEqual = (container, partName = 'where') => {
   const where = container[partName]
 
@@ -668,7 +648,7 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
   if (alias) {
     SELECT.from.as = alias
     if (SELECT.where && alias !== prevAlias) {
-      SELECT.where = _addAliasToExpression(SELECT.where, alias)
+      SELECT.where = addAliasToExpression(SELECT.where, alias)
     }
   }
   if (columns) {
@@ -691,7 +671,7 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
   }
   // TODO: REVISIT: We need to add alias to subselect in .where, .columns, .from, ... etc
   if (where) {
-    if (options.isDraft) {
+    if (options._4fiori) {
       addToWhere({ SELECT }, where)
     } else {
       addToWhere({ SELECT }, removeIsActiveEntityRecursively(where))
@@ -703,8 +683,7 @@ const _convertPathExpression = (SELECT, model, options = {}) => {
 const _convertSelect = (query, model, _options) => {
   const options = Object.assign(
     {
-      isDB: _options.service instanceof cds.DatabaseService,
-      isDraft: _options.draft,
+      _4db: _options.service instanceof cds.DatabaseService,
       isStreaming: query._streaming
     },
     _options
@@ -720,7 +699,7 @@ const _convertSelect = (query, model, _options) => {
   if (cds.env.features.odata_new_parser) _flattenCQN(query)
 
   // lambda functions
-  convertWhereExists(query, model, options)
+  convertWhereExists(query.SELECT, model, options)
 
   // add 'or is null' in case of '!='
   if (query.SELECT._4odata) {
@@ -729,7 +708,7 @@ const _convertSelect = (query, model, _options) => {
   }
 
   _convertPathExpression(query.SELECT, model, options)
-  rewriteAsterisks(query, model, options.isDB, options.isDraft)
+  rewriteAsterisks(query, model, options)
   if (query.SELECT.where && _isCountNavigation(query.SELECT.where)) {
     _convertCountNavigation(query.SELECT, model)
   }
@@ -780,12 +759,6 @@ const _convertInsert = (query, model, options) => {
 
   const resolvedView = resolveView(insert, model, cds.db)
 
-  if (query.INSERT.into.ref && query.INSERT.into.ref.length > 1) {
-    const copyFrom = [...query.INSERT.into.ref]
-    copyFrom.pop()
-    resolvedView._validationQuery = _convertSelect(SELECT.from({ ref: copyFrom }).columns([1]), model, options)
-  }
-
   return resolvedView
 }
 
@@ -831,7 +804,7 @@ const _convertDelete = (query, model, options) => {
 
   if (alias) deleet.DELETE.from = { ref: [target], as: alias }
   if (where) deleet.where(where)
-  if (query.DELETE.where) deleet.where(_addAliasToExpression(query.DELETE.where, alias))
+  if (query.DELETE.where) deleet.where(addAliasToExpression(query.DELETE.where, alias))
 
   const targetEntity = model.definitions[target]
   if (!targetEntity) return deleet
@@ -868,7 +841,7 @@ const _convertUpdate = (query, model, options) => {
 
   if (alias) update.UPDATE.entity = { ref: [target], as: alias }
   if (where) update.where(where)
-  if (query.UPDATE.where) update.where(_addAliasToExpression(query.UPDATE.where, alias))
+  if (query.UPDATE.where) update.where(addAliasToExpression(query.UPDATE.where, alias))
 
   const targetEntity = model.definitions[target]
   if (!targetEntity) return update

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

@@ -6,17 +6,27 @@ const getEtagElement = entity => {
   return Object.values(entity.elements).find(element => element['@odata.etag'])
 }
 
-const _getUps = (entity, model) => {
+const getComp2oneParents = (entity, model) => {
+  if (!entity) return []
+  if (entity.own('__comp2oneParents')) return entity.__comp2oneParents
+  const invalidationFn = element => !(element.is2one && element._isCompositionEffective)
+  const comp2oneParents = _getUps(entity, model, invalidationFn)
+  return entity.set('__comp2oneParents', comp2oneParents)
+}
+
+const _getUps = (entity, model, invalidationFn) => {
+  if (entity.own('__parents')) return entity.__parents
   const ups = []
   for (const def of Object.values(model.definitions)) {
     if (def.kind !== 'entity' || !def.associations) continue
     for (const element of Object.values(def.associations)) {
       if (element.target !== entity.name || element._isBacklink) continue
       if (element.name === 'SiblingEntity') continue
+      if (invalidationFn && invalidationFn(element)) continue
       ups.push(element)
     }
   }
-  return ups
+  return entity.set('__parents', ups)
 }
 
 const _ifDataSubject = (entity, role) => {
@@ -40,7 +50,7 @@ const _getDataSubjectUp = (role, model, entity, prev, next, result) => {
 }
 
 const _getDataSubjectDown = (role, entity, prev, next) => {
-  const associations = Object.values(entity.associations).filter(e => !e._isBacklink)
+  const associations = Object.values(entity.associations || {}).filter(e => !e._isBacklink)
   for (const element of associations) {
     const me = { entity, relative: entity, element }
     if (_ifDataSubject(element._target, role)) {
@@ -69,8 +79,20 @@ const getDataSubject = (entity, model, role) => {
   return entity.set(hash, dataSubject)
 }
 
-const _resolve = (name, model, namespace) =>
-  model.entities(namespace)[name] || model.definitions[`${namespace}.${name}`]
+const _findInModel = (name, model, namespace) => {
+  return model.entities(namespace)[name] || model.definitions[`${namespace}.${name}`]
+}
+
+const _resolve = (name, model, namespace) => {
+  const resolved = _findInModel(name, model, namespace)
+  // the edm name has an additional suffix 'Parameters' in case of views with parameters
+  if (!resolved && name.endsWith('Parameters')) {
+    const viewWithParam = _findInModel(name.replace(/Parameters$/, ''), model, namespace)
+    if (!viewWithParam || !viewWithParam.params) return
+    return viewWithParam
+  }
+  return resolved
+}
 
 const _findRootEntity = (model, edmName, namespace) => {
   const parts = edmName.split('_')
@@ -189,5 +211,6 @@ module.exports = {
   getElementDeep,
   isRootEntity,
   getDataSubject,
-  alias2ref
+  alias2ref,
+  getComp2oneParents
 }

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

@@ -178,12 +178,32 @@ const _resolveTargetForeignKey = targetKey => {
   return { targetName, propagation }
 }
 
+const _resolveColumnsFromQuery = query => {
+  if (query && query.SET) return _resolveColumnsFromQuery(query.SET.args[0])
+  if (query && query.SELECT && query.SELECT.columns) return query.SELECT.columns
+  return []
+}
+
 const _resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
   const foreignKeyPropagations = []
 
   for (let i = 0; i < foreignKeys.length; i++) {
     const fk = foreignKeys[i]
-    const tk = targetKeys[i]
+    let tk
+
+    /*
+     * REVISIT: poor man's look-up of target key with fallback to targetKeys[i]
+     * Look at elements, then try to find it in query and resolve recursively until you have the full path.
+     * Once you have the full path, you can find it in the target entity.
+     * NOTE: There can be projections upon projections and renamings in every projection. -> not yet covered!!!
+     */
+    const tkCol = _resolveColumnsFromQuery(targetKeys[i].parent.query).find(
+      c => c.ref && `${fk['@odata.foreignKey4']}_${c.ref.join('_')}` === fk.name
+    )
+    tk = tkCol && targetKeys.find(tk => tk.name === (tkCol.as ? tkCol.as : tkCol.ref.join('_')))
+    // with composition of aspects, the lookup fails -> we need this final fallback
+    if (!tk) tk = targetKeys[i]
+
     if (fk._isStructured) {
       i += _resolve4struct(targetKeys, fk, foreignKeyPropagations, fillChild, false, i)
     } else if (tk._isStructured) {

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

@@ -1,4 +1,5 @@
 const { where2obj } = require('./cqn')
+const { deepCopyArray } = require('./copy')
 
 function _getOnCondElements(onCond, onCondElements = []) {
   const andIndex = onCond.indexOf('and')
@@ -17,7 +18,7 @@ function _getOnCondElements(onCond, onCondElements = []) {
 function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName) {
   if (where) {
     // copy where else query will be modified
-    const whereCopy = JSON.parse(JSON.stringify(where))
+    const whereCopy = deepCopyArray(where)
     if (newWhere.length > 0) newWhere.push('and')
     newWhere.push(...whereCopy)
   }

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

@@ -24,7 +24,7 @@ const getEntityFromPath = (path, model) => {
   while (segments.length) {
     const segment = segments.shift()
     current = current.elements[segment.id || segment]
-    if (current.target) current = model.definitions[current.target]
+    if (current && current.target) current = model.definitions[current.target]
   }
   return current
 }