@sap/cds 5.8.3 → 5.9.1

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

@@ -18,18 +18,57 @@ const ensureUnlocalized = table => {
   return _table
 }
 
-const ensureDraftsSuffix = name => {
-  if (name.endsWith('_drafts')) {
-    return name
-  }
+const ensureDraftsSuffix = name => (name.endsWith('_drafts') ? name : `${ensureUnlocalized(name)}_drafts`)
+
+const ensureNoDraftsSuffix = name => name.replace(/_drafts$/g, '')
 
-  return `${ensureUnlocalized(name)}_drafts`
+const getDraftColumnsCQNForActive = target => {
+  const draftName = ensureDraftsSuffix(target.name)
+  const subSelect = SELECT.from(draftName).columns([1])
+  for (const key in target.keys) {
+    if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [draftName, key] }])
+  }
+  return [
+    { val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+    { val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } },
+    {
+      xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
+      as: 'HasDraftEntity',
+      cast: { type: 'cds.Boolean' }
+    }
+  ]
 }
 
-const ensureNoDraftsSuffix = name => name.replace(/_drafts$/g, '')
+const getDraftColumnsCQNForDraft = target => {
+  /*
+   * NOTE: the following with xpr could be used to detect if there really is an active or not, but that breaks tests
+   */
+  // const activeName = ensureNoDraftsSuffix(target.name)
+  // const subSelect = SELECT.from(activeName).columns([1])
+  // for (const key in target.keys) {
+  //   if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [activeName, key] }])
+  // }
+  // return [
+  //   { val: false, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+  //   {
+  //     xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
+  //     as: 'HasActiveEntity',
+  //     cast: { type: 'cds.Boolean' }
+  //   },
+  //   { val: false, as: 'HasDraftEntity', cast: { type: 'cds.Boolean' } }
+  // ]
+
+  return [
+    { val: false, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+    { ref: ['HasActiveEntity'], cast: { type: 'cds.Boolean' } },
+    { val: false, as: 'HasDraftEntity', cast: { type: 'cds.Boolean' } }
+  ]
+}
 
 module.exports = {
   ensureUnlocalized,
   ensureDraftsSuffix,
-  ensureNoDraftsSuffix
+  ensureNoDraftsSuffix,
+  getDraftColumnsCQNForActive,
+  getDraftColumnsCQNForDraft
 }

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

@@ -1,23 +1,26 @@
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
-const getEntityNameFromCQN = cqn => {
+const traverseFroms = (cqn, cb) => {
   while (cqn.SELECT) cqn = cqn.SELECT.from
 
   // Do the most likely first -> {ref}
   if (cqn.ref) {
-    return { entityName: cqn.ref[0].id || cqn.ref[0], alias: cqn.as }
+    return cb(cqn)
   }
 
-  // TODO cleanup
-  // REVISIT infer should do this for req.target
-  // REVISIT2 No, req.target doesn't make sense for joins
   if (cqn.SET) {
-    return cqn.SET.args.map(getEntityNameFromCQN).find(n => n.entityName !== 'DRAFT.DraftAdministrativeData')
+    return cqn.SET.args.map(a => traverseFroms(a, cb))
   }
+
   if (cqn.join) {
-    return cqn.args.map(getEntityNameFromCQN).find(n => n.entityName !== 'DRAFT.DraftAdministrativeData')
+    return cqn.args.map(a => traverseFroms(a, cb))
   }
-  return {}
+}
+
+const getEntityNameFromCQN = cqn => {
+  const res = []
+  traverseFroms(cqn, from => res.push({ entityName: from.ref[0].id || from.ref[0], alias: from.as }))
+  return res.length === 1 ? res[0] : res.find(n => n.entityName !== 'DRAFT.DraftAdministrativeData') || {}
 }
 
 // Note: This also works for the common draft scenarios
@@ -31,5 +34,6 @@ const getEntityFromCQN = (req, service) => {
 
 module.exports = {
   getEntityFromCQN,
-  getEntityNameFromCQN
+  getEntityNameFromCQN,
+  traverseFroms
 }

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

@@ -0,0 +1,18 @@
+const optionsApp = require('./vcap.js')
+
+const BASE_TENANT = 'anonymous'
+
+const channelName = () => {
+  // REVISIT: Why so complicated?
+
+  const appName = optionsApp.appName || 'CAP'
+  const appID = optionsApp.appID || '00000000'
+  const shrunkAppID = appID.substring(0, 4)
+
+  return `${appName}/${shrunkAppID}`
+}
+
+module.exports = {
+  BASE_TENANT,
+  channelName
+}

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

@@ -60,8 +60,7 @@ 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 _resolvedKeys(foreignKeys, true)
   }
   return []
 }
@@ -118,62 +117,11 @@ const _foreignKeyPropagationsFromOn = element => {
   return foreignKeyPropagations
 }
 
-/*
- * recursive resolvedKeys for a structured element
- * returns how many indexes can be skipped in the outer loop
- * example:
- *   foo: {
- *     bar: {
- *       moo: Integer;
- *       shu: Integer;
- *     };
- *     baz: Integer;
- *   };
- *   -> foo_bar_moo, foo_bar_shu, foo_baz
- *   -> processed three instead of one from outer loop perspective
- */
-const _resolve4struct = (others, struct, fkps, fillChild, childIsStruct, i) => {
-  let j = 0
-
-  for (const k in struct.elements) {
-    const other = others[i + j]
-    const current = struct.elements[k]
-
-    if (current._isStructured) {
-      // call recursive and increment skip
-      j += _resolve4struct(others, current, fkps, fillChild, childIsStruct, i + j)
-    } else if (current.isAssociation) {
-      continue
-    } else {
-      // calc prefix
-      let prefix = struct.name
-      let cur = struct.parent
-      while (cur._isStructured) {
-        prefix = cur.name + '_' + prefix
-        cur = cur.parent
-      }
-
-      // push propagation
-      fkps.push({
-        childElement: childIsStruct ? current : other,
-        parentElement: childIsStruct ? other : current,
-        fillChild,
-        prefix,
-        deep: !fillChild && _resolveTargetForeignKey(childIsStruct ? current : other)
-      })
-
-      // increment skip
-      j++
-    }
-  }
-
-  return j
-}
-
 const _resolveTargetForeignKey = targetKey => {
-  const targetName = targetKey['@odata.foreignKey4']
+  const targetName = targetKey._foreignKey4
   if (!targetName) return
-  const _foreignKeyProps = foreignKeyPropagations(targetKey.parent.elements[targetName])
+  const parentElements = targetKey.parent.elements
+  const _foreignKeyProps = foreignKeyPropagations(parentElements[targetName])
   const propagation = _foreignKeyProps.find(_fkp => _fkp.parentElement && targetKey.name === _fkp.parentElement.name)
   return { targetName, propagation }
 }
@@ -184,39 +132,22 @@ const _resolveColumnsFromQuery = query => {
   return []
 }
 
-const _resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
-  const foreignKeyPropagations = []
+const _resolvedKeys = (keys, fillChild) => {
+  const foreignKeys = fillChild ? keys.map(fk => Object.getPrototypeOf(fk)) : keys
+  const targetKeys = fillChild ? keys : keys.map(fk => Object.getPrototypeOf(fk))
 
+  const foreignKeyPropagations = []
   for (let i = 0; i < foreignKeys.length; i++) {
     const fk = foreignKeys[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) {
-      i += _resolve4struct(foreignKeys, tk, foreignKeyPropagations, fillChild, true, i)
-    } else {
-      foreignKeyPropagations.push({
-        fillChild,
-        parentElement: fk,
-        childElement: tk,
-        // needed only for child -> parent propagation since template loops in other direction
-        deep: !fillChild && _resolveTargetForeignKey(tk)
-      })
+    const tk = targetKeys[i]
+    const propagation = {
+      fillChild,
+      parentElement: fk,
+      childElement: tk,
+      // needed only for child -> parent propagation since template loops in other direction
+      deep: !fillChild && _resolveTargetForeignKey(tk)
     }
+    foreignKeyPropagations.push(propagation)
   }
 
   return foreignKeyPropagations
@@ -229,10 +160,7 @@ const foreignKeyPropagations = element => {
   if (element.is2one) {
     if (!element.on) {
       const foreignKeys = _foreignKeys(element)
-      if (foreignKeys) {
-        const targetKeys = _targetKeys(element)
-        return _resolvedKeys(foreignKeys, targetKeys)
-      }
+      if (foreignKeys) return _resolvedKeys(foreignKeys, false)
     } else {
       // It's a link through a backlink
       return _foreignKeyPropagationsFromOn(element)
@@ -241,29 +169,85 @@ const foreignKeyPropagations = element => {
   return []
 }
 
-const _foreignKeys = csnElement => {
-  return Object.values(csnElement.parent.elements).filter(element => element['@odata.foreignKey4'] === csnElement.name)
+// REVISIT: Flattening shouldn't be necessary in the future.
+//          It's better to deal with structures instead, but
+//          that would require changing a lot of code.
+const _foreignKeys = element => {
+  const foreignKeys = element.foreignKeys
+  const path = [element.name]
+  const parent = element.parent
+  const result = []
+  _addToForeignKeysRec(foreignKeys, path, parent, result)
+  return result
 }
 
-const _foreignKeysForTarget = (csnElement, name) => {
-  return Object.values(csnElement._target.elements).filter(
-    element =>
-      !element.isAssociation && !element.isComposition && element['@odata.foreignKey4'] === (name || csnElement.name)
+/*
+ * REVISIT: poor man's look-up of target key
+ * 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 _poorMansLookup = (el, name, foreignKeySource) => {
+  // REVISIT: Dirty hack
+  const tkCol = _resolveColumnsFromQuery(el.parent.query).find(
+    c => c.ref && `${foreignKeySource}_${c.ref.join('_')}` === name
   )
+  return tkCol && Object.values(el.parent.elements).find(tk => tk.name === (tkCol.as ? tkCol.as : tkCol.ref.join('_')))
 }
 
-const _targetKeys = csnElement => {
-  return Object.values(csnElement._target.keys).filter(
-    element => !element.isAssociation && !element.isComposition && element.name !== 'IsActiveEntity'
-  )
+const _createForeignKey = (name, el, parent, foreignKeySource) => {
+  const tk = _poorMansLookup(el, name, foreignKeySource)
+  const navigationCsn = parent.elements[foreignKeySource]
+  const foreignKeyCsn = Object.assign(Object.create(tk || el), { parent, name, foreignKeySource })
+  // annotation propagation is not possible via prototyping
+  for (const key of Object.keys(navigationCsn).filter(key => key.startsWith('@')))
+    foreignKeyCsn[key] = navigationCsn[key]
+  return foreignKeyCsn
 }
 
-const _parentKeys = csnElement => {
-  return Object.values(csnElement.parent.keys).filter(
-    element => !element.isAssociation && !element.isComposition && element.name !== 'IsActiveEntity'
-  )
+const _addToForeignKeysRec = (elements, path, parent, result) => {
+  for (const elName in elements) {
+    const el = elements[elName]
+    const foreignKeySource = path[0]
+    const newPath = [...path, elName]
+    if (el.isAssociation) {
+      const foreignKeysOftarget = _foreignKeys(el)
+      for (const fk of foreignKeysOftarget) {
+        const name = [...path, fk.name].join('_')
+        if (result.some(x => x.name === name)) return
+        const foreignKeyCsn = _createForeignKey(name, fk, parent, foreignKeySource)
+        result.push(foreignKeyCsn)
+      }
+    } else if (!el.elements) {
+      const name = newPath.join('_')
+      if (result.some(x => x.name === name)) return
+      const foreignKeyCsn = _createForeignKey(name, el, parent, foreignKeySource)
+      result.push(foreignKeyCsn)
+    } else _addToForeignKeysRec(el.elements, newPath, parent, result)
+  }
+}
+
+const _foreignKeysForTarget = (csnElement, name) => {
+  const target = csnElement._target.elements[name || csnElement.name]
+  return _foreignKeys(target)
+}
+
+const foreignKey4 = element => {
+  if (!element || !element.parent) return
+  const parentElements = element.parent.elements
+  for (const assoc of Object.keys(parentElements)
+    .map(n => parentElements[n])
+    .filter(e => e.isAssociation)) {
+    const foreignKeys = _foreignKeys(assoc)
+    if (!foreignKeys.length) continue
+    const target = foreignKeys.find(fk => fk.name === element.name)
+    if (target) {
+      return target && target.foreignKeySource
+    }
+  }
 }
 
 module.exports = {
-  foreignKeyPropagations
+  foreignKeyPropagations,
+  foreignKey4
 }

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

@@ -1,3 +1,5 @@
+const { prefixForStruct } = require('./csn')
+
 const _toRef = (alias, column) => {
   if (Array.isArray(column)) column = column.join('_')
   return { ref: alias ? [alias, column] : [column] }
@@ -18,7 +20,7 @@ const _adaptRefs = (onCond, path, { select, join }) => {
 
       return _toRef(join, ref.slice(0))
     } else if (el.xpr) {
-      el.xpr = el.xpr.map(_adaptEl)
+      return { xpr: el.xpr.map(_adaptEl) }
     }
 
     return el
@@ -73,7 +75,8 @@ const _foreignToOn = (csnElement, path, { select, join }) => {
     if (on.length !== 0) {
       on.push('and')
     }
-    const ref1 = _toRef(select, key.prefix ? `${key.prefix}_${key.childElement.name}` : key.childElement.name)
+    const prefixChild = prefixForStruct(key.childElement)
+    const ref1 = _toRef(select, prefixChild + key.childElement.name)
     const structPrefix = path.length > 1 ? path.slice(0, -1) : []
     const ref2 = _toRef(join, [...structPrefix, key.parentElement.name])
     on.push(ref1, '=', ref2)

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

@@ -32,6 +32,8 @@ module.exports = {
       _reserved = _COMPILER_RESERVED[_dialect] || _DEFAULT_RESERVED
     }
 
+    if (typeof s !== 'string') throw new Error(`string expected but ${typeof s} received`)
+
     // * or already quoted?
     if (s === '*' || _isQuoted(s)) return s
 

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

@@ -1,4 +1,4 @@
-const _flattenProps = (subElement, structName, structProperties, structElement, asRef) => {
+const _flattenProps = (subElement, structName, structProperties, structElement, asRef, withKey) => {
   if (subElement.elements) {
     return _resolveStructured(
       {
@@ -6,34 +6,50 @@ const _flattenProps = (subElement, structName, structProperties, structElement,
         structProperties: structProperties.slice(1)
       },
       subElement.elements,
-      asRef
+      asRef,
+      withKey
     )
   } else if (subElement.isAssociation) {
     if (structProperties.length && subElement.is2one && !subElement.on) {
-      return asRef
-        ? [{ ref: [`${structName}_${structProperties.join('_')}`] }]
-        : [`${structName}_${structProperties.join('_')}`]
+      const flattenedName = `${structName}_${structProperties.join('_')}`
+      if (withKey) {
+        return [{ key: structElement, resolved: [flattenedName] }]
+      }
+
+      return asRef ? [{ ref: [flattenedName] }] : [flattenedName]
     }
 
     return []
   }
-  return asRef ? [{ ref: [`${structName}_${structElement}`] }] : [`${structName}_${structElement}`]
+  const flattenedName = `${structName}_${structElement}`
+  if (withKey) {
+    return [{ key: structElement, resolved: [flattenedName] }]
+  }
+
+  return asRef ? [{ ref: [flattenedName] }] : [flattenedName]
 }
 
-const _resolveStructured = ({ structName, structProperties }, subElements, asRef = true) => {
+const _resolveStructured = ({ structName, structProperties }, subElements, asRef = true, withKey = false) => {
   if (!subElements) {
     return []
   }
 
   // only add from structProperties
   if (structProperties.length) {
-    return _flattenProps(subElements[structProperties[0]], structName, structProperties, structProperties[0], asRef)
+    return _flattenProps(
+      subElements[structProperties[0]],
+      structName,
+      structProperties,
+      structProperties[0],
+      asRef,
+      withKey
+    )
   }
 
   const flattenedElements = []
   for (const structElement in subElements) {
     flattenedElements.push(
-      ..._flattenProps(subElements[structElement], structName, structProperties, structElement, asRef)
+      ..._flattenProps(subElements[structElement], structName, structProperties, structElement, asRef, withKey)
     )
   }
   return flattenedElements

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

@@ -346,7 +346,10 @@ const _newSelect = (query, transitions, service) => {
   }
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
   if (newSelect.columns) {
-    rewriteAsterisks({ SELECT: query.SELECT }, service.model, { _4db: service instanceof cds.DatabaseService })
+    rewriteAsterisks({ SELECT: query.SELECT }, service.model, {
+      _4db: service instanceof cds.DatabaseService,
+      target: targetTransition.queryTarget
+    })
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
   }
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)

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

@@ -1,6 +1,6 @@
 const { getNavigationIfStruct } = require('./structured')
 const getColumns = require('../../db/utils/columns')
-const { ensureDraftsSuffix, ensureNoDraftsSuffix } = require('./draft')
+const { ensureNoDraftsSuffix, getDraftColumnsCQNForActive } = require('./draft')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 
 const isAsteriskColumn = col => col === '*' || (col.ref && col.ref[0] === '*' && !col.expand)
@@ -14,20 +14,7 @@ const _isDuplicate = newColumn => column => {
 
 const _cqlDraftColumns = target => {
   if (target.name.endsWith('DraftAdministrativeData')) return []
-  const draftName = ensureDraftsSuffix(target.name)
-  const subSelect = SELECT.from(draftName).columns([1])
-  for (const key in target.keys) {
-    if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [draftName, key] }])
-  }
-  return [
-    { val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
-    { val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } },
-    {
-      xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
-      as: 'HasDraftEntity',
-      cast: { type: 'cds.Boolean' }
-    }
-  ]
+  return getDraftColumnsCQNForActive(target)
 }
 
 const _expandColumn = (column, target, _4db) => {
@@ -135,7 +122,7 @@ const rewriteAsterisks = (query, model, options) => {
     return
   }
 
-  const target = _targetOfQueryIfNotDraft(query, model)
+  const target = options.target || _targetOfQueryIfNotDraft(query, model)
   if (!target) return
 
   // REVISIT: Also support JOINs/SETs here

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

@@ -1,30 +1,21 @@
 const resolveStructured = require('./resolveStructured')
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { traverseFroms } = require('../../common/utils/entityFromCqn')
 // TODO move to commons as also used in cqn2cqn4sql
-const OPERATIONS = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in']
-
-const _getEntityNames = from => {
-  if (from.ref) {
-    return [ensureNoDraftsSuffix(from.ref[0])]
-  }
-
-  if (from.SET) {
-    return Array.from(
-      from.SET.args.reduce((set, elem) => {
-        for (const entityName of _getEntityNames(elem.SELECT.from)) {
-          set.add(entityName)
-        }
-        return set
-      }, new Set())
-    )
-  }
-
-  if (Array.isArray(from.args)) {
-    // TODO this only considers first level refs and not from sub selects
-    return from.args.filter(arg => arg.ref).map(arg => ensureNoDraftsSuffix(arg.ref[0]))
-  }
-
-  return []
+const OPERATIONS_MAP = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in'].reduce((acc, cur) => {
+  acc[cur] = 1
+  return acc
+}, {})
+
+const _getEntityNamesAndIds = from => {
+  const nameAndIds = []
+  traverseFroms(from, from => {
+    const nameAndId = { name: ensureNoDraftsSuffix(from.ref[0].id || from.ref[0]), id: from.as || from.ref[0] }
+    if (nameAndIds.some(x => x.name === nameAndId.name)) return // no duplicates
+    nameAndIds.push(nameAndId)
+  })
+
+  return nameAndIds
 }
 
 const _flattenStructuredInExpand = (column, { _target: expandedEntity }) => {
@@ -117,8 +108,8 @@ const _filterForStructProperty = (structElement, structData, op, prefix = '', na
       )
     } else {
       if (element.isAssociation) continue
-      if (element['@odata.foreignKey4']) {
-        const assocName = element['@odata.foreignKey4']
+      const assocName = element._foreignKey4
+      if (assocName) {
         const assoc = structElement.elements[assocName]
         if (assoc.is2one && !assoc.on) {
           for (const key in assoc._target.keys) {
@@ -214,7 +205,7 @@ const flattenStructuredWhereHaving = (filterArray, csnEntity, model) => {
 
   const newFilterArray = []
   for (let i = 0; i < filterArray.length; i++) {
-    if (OPERATIONS.includes(filterArray[i + 1])) {
+    if (filterArray[i + 1] in OPERATIONS_MAP) {
       const refElement = filterArray[i].ref ? filterArray[i] : filterArray[i + 2]
 
       // copy for processing
@@ -254,42 +245,47 @@ const getNavigationIfStruct = (entity, ref) => {
   return element
 }
 
-const _flattenColumns = (SELECT, flattenedElements, toBeDeleted, csnEntity) => {
+const _flattenColumns = (SELECT, flattenedElements, toBeDeleted, csnEntity, tableId) => {
   for (const column of SELECT.columns) {
     if (!column.ref) continue
 
-    // TODO aliases are not working right now
-    const structName = column.ref[0]
+    // might begin with table id
+    const cleanedUpRef = column.ref.length > 1 && column.ref[0] === tableId ? column.ref.slice(1) : column.ref
+    const structName = cleanedUpRef[0]
 
     const element = csnEntity.elements[structName]
     if (!element) continue
 
     if (column.expand) {
-      _flattenStructuredInExpand(column, getNavigationIfStruct(csnEntity, column.ref))
+      _flattenStructuredInExpand(column, getNavigationIfStruct(csnEntity, cleanedUpRef))
       continue
     }
 
     if (element._isStructured) {
       toBeDeleted.push(structName) // works with aliases?
       flattenedElements.push(
-        ...resolveStructured({ structName, structProperties: column.ref.slice(1) }, element.elements)
+        ...resolveStructured({ structName, structProperties: cleanedUpRef.slice(1) }, element.elements)
       )
     }
+    if (cleanedUpRef.length < column.ref.length) {
+      flattenedElements.forEach(e => e.ref.unshift(tableId))
+    }
   }
 }
 
 const flattenStructuredSelect = ({ SELECT }, model) => {
-  const entityNames = _getEntityNames(SELECT.from) // TODO consider alias for custom CQNs?
+  const entityNamesAndIds = _getEntityNamesAndIds(SELECT.from)
 
-  for (const entityName of entityNames) {
-    const entity = model.definitions[entityName]
+  for (const entityNameAndId of entityNamesAndIds) {
+    const entity = model.definitions[entityNameAndId.name]
+    const tableId = entityNameAndId.id
 
     if (Array.isArray(SELECT.columns) && SELECT.columns.length > 0) {
       const flattenedElements = []
       const toBeDeleted = []
-      _flattenColumns(SELECT, flattenedElements, toBeDeleted, entity)
+      _flattenColumns(SELECT, flattenedElements, toBeDeleted, entity, tableId)
       SELECT.columns = SELECT.columns.filter(column => {
-        const columnName = column.ref ? column.ref[0] : column.as
+        const columnName = column.ref ? (column.ref[0] === tableId ? column.ref[1] : column.ref[0]) : column.as
         return (columnName && !toBeDeleted.includes(columnName)) || column.func || column.expand || 'val' in column
       })
       if (flattenedElements.length) SELECT.columns.push(...flattenedElements)