@sap/cds 5.5.2 → 5.6.0

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

@@ -1,41 +1,21 @@
 const cds = require('../../cds')
 const { SELECT, INSERT, DELETE, UPDATE } = cds.ql
 
-const { getOnCond } = require('./generateOnCond')
 const { resolveView } = require('./resolveView')
 const { ensureNoDraftsSuffix } = require('./draft')
 const { flattenStructuredSelect } = require('./structured')
-const { foreignKeyPropagations } = require('./foreignKeyPropagations')
 const search2cqn4sql = require('./search2cqn4sql')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 const getError = require('../../common/error')
+const { rewriteAsterisks } = require('./rewriteAsterisks')
 const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
+const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 
 const PARENT_ALIAS = '_parent_'
 const PARENT_ALIAS_REGEX = new RegExp('^' + PARENT_ALIAS + '\\d*$')
 const FOREIGN_ALIAS = '_foreign_'
 const OPERATIONS = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in']
 
-const _addOnCondToWhere = (cqn, entity, navigation, tableAlias, identifier, csn, prefix) => {
-  const onConditionOptions = {
-    associationNames: [...prefix, navigation],
-    csn: csn,
-    aliases: {
-      select: tableAlias,
-      join: identifier
-    }
-  }
-
-  let element = csn.definitions[entity]
-  for (let i = 0; i < onConditionOptions.associationNames.length; i++) {
-    element = element.elements[onConditionOptions.associationNames[i]]
-  }
-
-  const onCond = getOnCond(element, onConditionOptions)
-
-  cqn.where(onCond)
-}
-
 // special case in lambda functions
 const _addParentAlias = (where, alias) => {
   where.forEach(e => {
@@ -136,14 +116,9 @@ const convertPathExpressionToWhere = (fromClause, model, options) => {
     }
 
     if (previousSelect) {
-      _addOnCondToWhere(
-        previousSelect,
-        previousEntityName,
-        _getTargetFromRef(fromClause.ref[i]),
-        tableAlias,
-        previousTableAlias,
-        model,
-        prefix
+      const navigation = _getTargetFromRef(fromClause.ref[i])
+      previousSelect.where(
+        model.definitions[previousEntityName]._relations[[...prefix, navigation]].join(tableAlias, previousTableAlias)
       )
       _convertSelect(previousSelect, model, options)
       currentSelect.where('exists', previousSelect)
@@ -248,6 +223,7 @@ const _createWindowCQN = (SELECT, model) => {
       from: SELECT.from
     }
   }
+
   delete SELECT.groupBy
 }
 
@@ -260,6 +236,7 @@ const _isAll = element => {
   return last && last.id && last.where && last.where[0] === 'not' && last.where[1].xpr
 }
 
+// eslint-disable-next-line complexity
 const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
   const _unshiftRefsWithNavigation = nav => el => {
     if (el.ref) return { ref: [...nav, ...el.ref] }
@@ -268,12 +245,14 @@ const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
   }
 
   if (!options.lambdaIteration) options.lambdaIteration = 1
-
-  const outerAlias = cqn.SELECT.from.as || PARENT_ALIAS + options.lambdaIteration
+  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 queryTarget = getEntityFromPath(getPathFromRef(cqn.SELECT.from.ref), model)
+  const ref = cqn.SELECT.from.ref || (cqn.SELECT.from.args && cqn.SELECT.from.args[0].ref)
+  const queryTarget = getEntityFromPath(getPathFromRef(ref), model)
 
   const nav = where[index].ref.map(el => (el.id ? el.id : el))
   const last = where[index].ref.slice(-1)[0]
@@ -296,15 +275,6 @@ const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
       ? last.where.map(_unshiftRefsWithNavigation(nav.slice(1)))
       : last.where
     : undefined
-  const onConditionOptions = {
-    associationNames: navName,
-    csn: model,
-    aliases: {
-      select: innerAlias,
-      join: outerAlias
-    }
-  }
-  const onCondition = getOnCond(navElement, onConditionOptions)
 
   const subSelect = SELECT.from({ ref: [navElement.target], as: innerAlias })
   if (condition) {
@@ -322,7 +292,7 @@ const _getLambdaSubSelect = (cqn, where, index, lambdaOp, model, options) => {
     }
     subSelect.where(condition)
   }
-  subSelect.where(onCondition)
+  subSelect.where(queryTarget._relations[navName].join(innerAlias, outerAlias))
   if (cds.env.effective.odata.structs) {
     flattenStructuredSelect(subSelect, model)
   }
@@ -412,6 +382,7 @@ const _convertNotEqual = container => {
     })
   }
 }
+
 const _ifOrderByOrWhereSkip = (queryTarget, ref, model) => {
   if (!queryTarget.elements[ref[0]]) return
   return ref.some(el => {
@@ -474,6 +445,7 @@ const _convertExpand = expand => {
     }
   })
 }
+
 const _convertRefWhereInExpand = columns => {
   if (columns) {
     columns.forEach(col => {
@@ -484,83 +456,92 @@ const _convertRefWhereInExpand = columns => {
   }
 }
 
-const _defaultColumns4 = entity => {
-  if (entity && entity.elements) {
-    const addAliasToColumns = []
-    for (const column in entity.elements) {
-      if (column === 'DraftAdministrativeData_DraftUUID') continue
-      const e = entity.elements[column]
-      if (e.isAssociation || e.virtual) continue
-      else if (entity._isDraftEnabled && column === 'IsActiveEntity') {
-        addAliasToColumns.push({ val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } })
-      } else if (entity._isDraftEnabled && column === 'HasActiveEntity') {
-        addAliasToColumns.push({ val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } })
-      } else if (entity._isDraftEnabled && column === 'HasDraftEntity') {
-        const draftName = `${entity.name}_drafts`
-        const subSelect = SELECT.from(draftName).columns([1])
-        for (const k in entity.keys) {
-          if (k !== 'IsActiveEntity') subSelect.where([{ ref: [entity.name, k] }, '=', { ref: [draftName, k] }])
-        }
-        addAliasToColumns.push({
-          xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
-          as: 'HasDraftEntity',
-          cast: { type: 'cds.Boolean' }
-        })
-      } else addAliasToColumns.push({ ref: [column], as: column })
-    }
-    return addAliasToColumns
+const _flattenCQN = cqn => {
+  if (Array.isArray(cqn)) cqn.forEach(_flattenCQN)
+  else if (cqn) {
+    if (cqn.SELECT) _flattenCQN(cqn.SELECT)
+    if (cqn.from) _flattenCQN(cqn.from)
+    if (cqn.ref) _flattenCQN(cqn.ref)
+    if (cqn.SET) _flattenCQN(cqn.SET)
+    if (cqn.args) _flattenCQN(cqn.args)
+    if (cqn.columns) _flattenCQN(cqn.columns)
+    if (cqn.expand) _flattenCQN(cqn.expand)
+    if (cqn.where) _flattenXpr(cqn.where)
+    if (cqn.having) _flattenXpr(cqn.having)
   }
 }
 
-// eslint-disable-next-line complexity
-const _convertSelect = (cqn, model, options) => {
-  // REVISIT: still needed?
-  // Moved from old SELECT.from where this done much too eager, always for all queries
-  if ((!cqn.SELECT.columns || (cqn.SELECT.columns && !cqn.SELECT.columns.length)) && cqn._target) {
-    cqn.SELECT.columns = _defaultColumns4(cqn._target)
+const _flattenXpr = cqn => {
+  if (!Array.isArray(cqn)) {
+    if (cqn.xpr) cqn = cqn.xpr
+    return
+  }
+
+  let idx = cqn.findIndex(el => el.xpr)
+  while (idx > -1) {
+    cqn.splice(idx, 1, '(', ...cqn[idx].xpr, ')')
+    idx = cqn.findIndex(el => el.xpr)
   }
 
+  cqn.forEach(_flattenCQN)
+}
+
+// eslint-disable-next-line complexity
+const _convertSelect = (query, model, options) => {
+  const isDB = options.service instanceof cds.DatabaseService
+  const isDraft = options.draft
+  // REVISIT: a temporary workaround for xpr from new parser
+  if (cds.env.features.odata_new_parser) _flattenCQN(query)
+
   // lambda functions
-  _convertLambda(cqn, model, options)
+  _convertLambda(query, model, options)
 
   // add 'or is null' in case of '!='
-  if (cqn.SELECT._4odata) _convertNotEqual(cqn.SELECT)
-
-  // extract where clause if it is in column expand ref
-  _convertRefWhereInExpand(cqn.SELECT.columns)
+  if (query.SELECT._4odata) _convertNotEqual(query.SELECT)
 
-  let searchOptions = cqn._searchOptions
-  const cqnSelectFromRef = cqn.SELECT.from.ref
+  let searchOptions = query._searchOptions
+  const cqnSelectFromRef = query.SELECT.from.ref
 
   // no path expression
   if (!cqnSelectFromRef || (cqnSelectFromRef.length === 1 && !cqnSelectFromRef[0].where)) {
+    rewriteAsterisks(query, cqnSelectFromRef && model.definitions[cqnSelectFromRef[0]], isDB, isDraft)
+    // extract where clause if it is in column expand ref
+    _convertRefWhereInExpand(query.SELECT.columns)
     // remove virtual and with skip annotated fields in orderby and where
-    _convertOrderByOrWhereIfSkip(cqn, getEntityNameFromCQN(cqn), model)
+    _convertOrderByOrWhereIfSkip(query, getEntityNameFromCQN(query), model)
 
-    if (cqnSelectFromRef && cqn.SELECT.search && !options.suppressSearch) {
+    if (cqnSelectFromRef && query.SELECT.search && !options.suppressSearch) {
       searchOptions = { ...searchOptions, ...{ targetName: cqnSelectFromRef[0] } }
-      search2cqn4sql(cqn, model, searchOptions)
+      search2cqn4sql(query, model, searchOptions)
     }
 
-    if (cqn.SELECT.columns && cds.env.effective.odata.structs) {
-      flattenStructuredSelect(cqn, model)
+    if (query.SELECT.columns && cds.env.effective.odata.structs) {
+      flattenStructuredSelect(query, model)
     }
 
     // topcount with groupby
-    if (cqn.SELECT.columns && _isBottomTop(cqn.SELECT.columns)) {
-      _createWindowCQN(cqn.SELECT, model)
+    if (query.SELECT.columns && _isBottomTop(query.SELECT.columns)) {
+      _createWindowCQN(query.SELECT, model)
     }
 
-    return cqn
+    return query
   }
 
   // path expression handling
-  const { target, alias, where, cardinality, columns } = convertPathExpressionToWhere(cqn.SELECT.from, model, options)
+  const { target, alias, where, cardinality, columns } = convertPathExpressionToWhere(query.SELECT.from, model, options)
+  rewriteAsterisks(query, model.definitions[target], isDB, isDraft, !!columns)
+  if (columns) {
+    if (query._streaming) query.SELECT.columns = columns
+    else query.SELECT.columns.push(...columns)
+  }
+
+  // extract where clause if it is in column expand ref
+  _convertRefWhereInExpand(query.SELECT.columns)
 
   // remove virtual and with skip annotated fields in orderby and where
-  _convertOrderByOrWhereIfSkip(cqn, target, model)
+  _convertOrderByOrWhereIfSkip(query, target, model)
 
-  const select = SELECT.from(target, columns || cqn.SELECT.columns)
+  const select = SELECT.from(target, query.SELECT.columns)
 
   if (alias) {
     select.SELECT.from.as = alias
@@ -568,25 +549,29 @@ const _convertSelect = (cqn, model, options) => {
 
   // TODO: REVISIT: We need to add alias to subselect in .where, .columns, .from, ... etc
   if (where) {
-    select.where(where)
+    if (!isDraft) {
+      select.where(removeIsActiveEntityRecursively(where))
+    } else {
+      select.where(where)
+    }
   }
 
   if (cardinality && cardinality.max === 1) {
-    cqn.SELECT.one = true
+    query.SELECT.one = true
   }
 
-  if (cqn.SELECT.search) {
+  if (query.SELECT.search) {
     searchOptions = { ...searchOptions, ...{ targetName: target } }
-    search2cqn4sql(cqn, model, searchOptions)
+    search2cqn4sql(query, model, searchOptions)
   }
 
-  if (cqn.SELECT.where) {
-    select.where(_addAliasToExpression(cqn.SELECT.where, select.SELECT.from.as))
+  if (query.SELECT.where) {
+    select.where(_addAliasToExpression(query.SELECT.where, select.SELECT.from.as))
   }
 
   // We add all previous properties ot the newly created query.
   // Reason is to not lose the query API functionality
-  Object.assign(select.SELECT, cqn.SELECT, {
+  Object.assign(select.SELECT, query.SELECT, {
     columns: select.SELECT.columns,
     from: select.SELECT.from,
     where: select.SELECT.where
@@ -599,9 +584,9 @@ const _convertSelect = (cqn, model, options) => {
   return select
 }
 
-const _convertInsert = (cqn, model) => {
+const _convertInsert = (query, model, options) => {
   // resolve path expression
-  const resolvedIntoClause = _convertPathExpressionForInsertOrDelete(cqn.INSERT.into, model)
+  const resolvedIntoClause = _convertPathExpressionForInsertOrDelete(query.INSERT.into, model)
 
   // overwrite only .into, foreign keys are already set
   const insert = INSERT.into(resolvedIntoClause)
@@ -610,7 +595,7 @@ const _convertInsert = (cqn, model) => {
 
   // We add all previous properties ot the newly created query.
   // Reason is to not lose the query API functionality
-  Object.assign(insert.INSERT, cqn.INSERT, { into: resolvedIntoClause })
+  Object.assign(insert.INSERT, query.INSERT, { into: resolvedIntoClause })
 
   const targetName = insert.INSERT.into.name || insert.INSERT.into
 
@@ -619,10 +604,10 @@ const _convertInsert = (cqn, model) => {
 
   const resolvedView = resolveView(insert, model, cds.db)
 
-  if (cqn.INSERT.into.ref && cqn.INSERT.into.ref.length > 1) {
-    const copyFrom = [...cqn.INSERT.into.ref]
+  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)
+    resolvedView._validationQuery = _convertSelect(SELECT.from({ ref: copyFrom }).columns([1]), model, options)
   }
 
   return resolvedView
@@ -634,11 +619,11 @@ function _modifyNavigationInWhere(whereClause, target) {
     if (e.ref && e.ref.length > 1 && target.elements[e.ref[0]]) {
       const element = target.elements[e.ref[0]]
       if (!element.isAssociation) return
-      const foreignKeys = foreignKeyPropagations(element)
+      const foreignKeys = element._foreignKeys
       const joined = e.ref.join('_')
 
-      for (const { parentFieldName } of foreignKeys) {
-        if (parentFieldName === joined) {
+      for (const { parentElement } of foreignKeys) {
+        if (parentElement && parentElement.name === joined) {
           e.ref = [joined]
         }
       }
@@ -654,23 +639,23 @@ const _plainDelete = (cqn, model) => {
   return resolveView(cqn, model, cds.db)
 }
 
-const _convertDelete = (cqn, model, options) => {
+const _convertDelete = (query, model, options) => {
   // .from is plain string or csn entity
   if (
-    typeof cqn.DELETE.from === 'string' ||
-    cqn.DELETE.from.name ||
-    (cqn.DELETE.from.ref && typeof cqn.DELETE.from.ref[0] === 'string')
+    typeof query.DELETE.from === 'string' ||
+    query.DELETE.from.name ||
+    (query.DELETE.from.ref && typeof query.DELETE.from.ref[0] === 'string')
   ) {
-    return _plainDelete(cqn, model)
+    return _plainDelete(query, model)
   }
 
-  const { target, alias, where } = convertPathExpressionToWhere(cqn.DELETE.from, model, options)
+  const { target, alias, where } = convertPathExpressionToWhere(query.DELETE.from, model, options)
   const deleet = DELETE('x')
-  Object.assign(deleet.DELETE, cqn.DELETE, { from: target, where: undefined })
+  Object.assign(deleet.DELETE, query.DELETE, { from: target, where: undefined })
 
   if (alias) deleet.DELETE.from = { ref: [target], as: alias }
   if (where) deleet.where(where)
-  if (cqn.DELETE.where) deleet.where(_addAliasToExpression(cqn.DELETE.where, alias))
+  if (query.DELETE.where) deleet.where(_addAliasToExpression(query.DELETE.where, alias))
 
   const targetEntity = model.definitions[target]
   if (!targetEntity) return deleet
@@ -686,28 +671,28 @@ function _plainUpdate(cqn, model) {
   return resolveView(cqn, model, cds.db)
 }
 
-const _convertUpdate = (cqn, model, options) => {
+const _convertUpdate = (query, model, options) => {
   // REVISIT flatten structured types, currently its done in SQL builder
 
   // .into is plain string or csn entity
   if (
-    typeof cqn.UPDATE.entity === 'string' ||
-    cqn.UPDATE.entity.name ||
-    (cqn.UPDATE.entity.ref && typeof cqn.UPDATE.entity.ref[0] === 'string' && cqn.UPDATE.entity.ref.length === 1)
+    typeof query.UPDATE.entity === 'string' ||
+    query.UPDATE.entity.name ||
+    (query.UPDATE.entity.ref && typeof query.UPDATE.entity.ref[0] === 'string' && query.UPDATE.entity.ref.length === 1)
   ) {
-    return _plainUpdate(cqn, model)
+    return _plainUpdate(query, model)
   }
 
-  const { target, alias, where } = convertPathExpressionToWhere(cqn.UPDATE.entity, model, options)
+  const { target, alias, where } = convertPathExpressionToWhere(query.UPDATE.entity, model, options)
 
   // link .with and .data and set query target and remove current where clause
   // REVISIT: update statement does not accept cqn partial as input
   const update = UPDATE('x')
-  Object.assign(update.UPDATE, cqn.UPDATE, { entity: target, where: undefined })
+  Object.assign(update.UPDATE, query.UPDATE, { entity: target, where: undefined })
 
   if (alias) update.UPDATE.entity = { ref: [target], as: alias }
   if (where) update.where(where)
-  if (cqn.UPDATE.where) update.where(_addAliasToExpression(cqn.UPDATE.where, alias))
+  if (query.UPDATE.where) update.where(_addAliasToExpression(query.UPDATE.where, alias))
 
   const targetEntity = model.definitions[target]
   if (!targetEntity) return update
@@ -721,30 +706,31 @@ const _convertUpdate = (cqn, model, options) => {
  * REVISIT structured
  * REVISIT topcount when the additional layer for Analytics before SQLBuilder is ready
  *
- * @param {object} cqn - incoming query
+ * @param {object} query - incoming query
  * @param {object} model - csn model
  * @param {import('../../types/api').cqn2cqn4sqlOptions} [options] Additional options.
  */
-const cqn2cqn4sql = (cqn, model, options = { suppressSearch: false }) => {
-  // REVISIT: query instead of cqn (the INSERT/SELECT/UPDATE/DELETE object is the actual cqn)
-
-  if (cqn.SELECT) {
-    return _convertSelect(cqn, model, options)
+const cqn2cqn4sql = (query, model, options = { suppressSearch: false }) => {
+  if (query.SELECT) {
+    return _convertSelect(query, model, options)
   }
 
-  if (cqn.UPDATE) {
-    return _convertUpdate(cqn, model, options)
+  if (query.UPDATE) {
+    return _convertUpdate(query, model, options)
   }
 
-  if (cqn.INSERT) {
-    return _convertInsert(cqn, model, options)
+  if (query.INSERT) {
+    return _convertInsert(query, model, options)
   }
 
-  if (cqn.DELETE) {
-    return _convertDelete(cqn, model, options)
+  if (query.DELETE) {
+    return _convertDelete(query, model, options)
   }
 
-  return cqn
+  return query
 }
 
-module.exports = cqn2cqn4sql
+module.exports = {
+  cqn2cqn4sql,
+  convertPathExpressionToWhere
+}

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

@@ -1,29 +1,11 @@
 const cds = require('../../cds')
 
 const { ensureNoDraftsSuffix } = require('./draft')
-const { getFlatArray } = require('../../db/utils/deep')
 
 const getEtagElement = entity => {
   return Object.values(entity.elements).find(element => element['@odata.etag'])
 }
 
-const _isBacklink = (assoc, parent, target) => {
-  const comps = Object.values(target.associations || {})
-    .filter(assoc => assoc._isCompositionEffective)
-    .filter(assoc => assoc.target === parent.name)
-  if (comps.length === 0) return false
-
-  let backlink = false
-  for (const comp of comps) {
-    const on = comp.on.find(ele => typeof ele === 'object' && ele.ref[0] !== '$self')
-    if (on.ref.length === 2 && on.ref[on.ref.length - 1] === assoc.name) {
-      backlink = true
-      break
-    }
-  }
-  return backlink
-}
-
 const _isDependent = (assoc, parent, target) => {
   return (
     assoc._isAssociationStrict &&
@@ -33,7 +15,7 @@ const _isDependent = (assoc, parent, target) => {
     assoc['@assert.integrity'] !== false &&
     parent['@assert.integrity'] !== false &&
     (!parent._service || parent._service['@assert.integrity'] !== false) &&
-    !_isBacklink(assoc, parent, target)
+    !assoc._isCompositionBacklink
   )
 }
 
@@ -65,18 +47,14 @@ const getDependents = (entity, model) => {
   return entity.set('__dependents', dependents)
 }
 
-const _getUps = (entity, model, previous = []) => {
+const _getUps = (entity, model) => {
   const ups = []
   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
-      ups.push({
-        entity: assoc.parent,
-        assoc: assoc,
-        previous
-      })
+    for (const element of Object.values(def.associations)) {
+      if (element.target !== entity.name || element._isBacklink) continue
+      ups.push(element)
     }
   }
   return ups
@@ -86,31 +64,35 @@ const _ifDataSubject = (entity, role) => {
   return entity['@PersonalData.EntitySemantics'] === 'DataSubject' && entity['@PersonalData.DataSubjectRole'] === role
 }
 
-const getDataSubject = (entity, model, role) => {
-  const hash = '__dataSubject4' + role
-  if (entity.own(hash)) return entity[hash]
-
-  if (_ifDataSubject(entity, role)) return entity.set(hash, { entity: entity, assoc: [], previous: [] })
-
-  let dataSubject
-  let ups = _getUps(entity, model)
-  while (!dataSubject) {
-    for (const { entity, assoc, previous } of ups) {
-      if (_ifDataSubject(entity, role)) dataSubject = { entity, assoc, previous }
+const _getDataSubjectUp = (role, model, element, first = element) => {
+  const upElements = _getUps(element.parent, model)
+  for (const element of upElements) {
+    if (_ifDataSubject(element.parent, role)) {
+      return { element: first, up: { element }, entity: element.parent }
+    }
+    // dfs is a must here
+    const dataSubject = _getDataSubjectUp(role, model, element, first)
+    if (dataSubject) {
+      dataSubject.up = { element, up: dataSubject.up }
+      return dataSubject
     }
-    if (dataSubject) break
-    ups = getFlatArray([
-      ...ups.map(up => [..._getUps(up.entity, model, up.previous.concat({ entity: up.entity, assoc: up.assoc }))])
-    ])
   }
+}
 
-  return entity.set(hash, dataSubject)
+const getDataSubject = (entity, model, role, element) => {
+  const hash = '__dataSubject4' + role
+  if (entity.own(hash)) return entity[hash]
+  if (_ifDataSubject(element.parent, role)) return entity.set(hash, { element, entity: element.parent })
+  return entity.set(hash, _getDataSubjectUp(role, model, element))
 }
 
-const _findRootEntity = (entities, edmName) => {
+const _resolve = (name, model, namespace) =>
+  model.entities(namespace)[name] || model.definitions[`${namespace}.${name}`]
+
+const _findRootEntity = (model, edmName, namespace) => {
   const parts = edmName.split('_')
   let csnName = parts.shift()
-  let target = entities[csnName]
+  let target = _resolve(csnName, model, namespace)
   const len = parts.length
   // try to find a correct entity "greedy" and count leftovers (x4 case below)
   // e.g. we have 2 entities: 'C_root_' and dependant 'C_root_.kid_'
@@ -124,10 +106,10 @@ const _findRootEntity = (entities, edmName) => {
      * if target in entities connect with .
      * if target not in entities connect with _
      */
-    csnName = `${csnName}${entities[csnName] ? '.' : '_'}${parts[i]}`
+    csnName = `${csnName}${_resolve(csnName, model, namespace) ? '.' : '_'}${parts[i]}`
     ++acc
-    if (entities[csnName]) {
-      target = entities[csnName]
+    if (_resolve(csnName, model, namespace)) {
+      target = _resolve(csnName, model, namespace)
       left -= acc
       acc = 0
     }
@@ -145,12 +127,13 @@ const findCsnTargetFor = (edmName, model, namespace) => {
 
   if (mapping[edmName]) return mapping[edmName]
 
-  const entities = model.entities(namespace)
   // simple cases
-  let target = entities[edmName] || entities[edmName.replace(/_/g, '.')]
+  let target = _resolve(edmName, model, namespace) || _resolve(edmName.replace(/_/g, '.'), model, namespace)
+
+  // hard cases
   if (!target) {
     // probably, a combination of '_' and '.', resolving
-    const finding = _findRootEntity(entities, edmName)
+    const finding = _findRootEntity(model, edmName, namespace)
     target = finding.target
     // something left in navigation path => x4 navigation
     // resolving within found entity
@@ -203,11 +186,26 @@ const isRootEntity = (definitions, entityName) => {
   return true
 }
 
+function alias2ref(service, edm) {
+  const defs = edm[service.definition.name]
+  for (const each of Object.values(service.entities)) {
+    const def = defs[each.name.replace(service.definition.name + '.', '').replace(/\./g, '_')]
+    if (!def || !def.$Key || def.$Key.every(ele => typeof ele === 'string')) continue
+    each._alias2ref = {}
+    for (const mapping of def.$Key.filter(ele => typeof ele !== 'string')) {
+      for (const [key, value] of Object.entries(mapping)) {
+        each._alias2ref[key] = value.split('/')
+      }
+    }
+  }
+}
+
 module.exports = {
   getEtagElement,
   findCsnTargetFor,
   getElementDeep,
   getDependents,
   isRootEntity,
-  getDataSubject
+  getDataSubject,
+  alias2ref
 }