@sap/cds 5.9.6 → 6.0.1

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

@@ -9,13 +9,25 @@ const getEtagElement = entity => {
 
 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)
+  return _getUps(entity, model).filter(element => element.is2one && element.isComposition)
 }
 
-const _getUps = (entity, model, invalidationFn) => {
+const setEntityContained = (entity, model, isContained) => {
+  if (!entity || entity.kind !== 'entity') return entity
+  if ('_isContained' in entity && !isContained) return entity
+  if ('_isContained' in entity) delete entity._isContained
+  return Object.defineProperty(entity, '_isContained', {
+    get() {
+      return (
+        isContained ||
+        !!_getUps(entity, model).find(element => element._isContained && element.parent.name !== entity.name)
+      )
+    },
+    configurable: true
+  })
+}
+
+const _getUps = (entity, model) => {
   if (entity.own('__parents')) return entity.__parents
   const ups = []
   for (const def of Object.values(model.definitions)) {
@@ -23,7 +35,6 @@ const _getUps = (entity, model, invalidationFn) => {
     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)
     }
   }
@@ -80,86 +91,70 @@ const getDataSubject = (entity, model, role) => {
   return entity.set(hash, dataSubject)
 }
 
-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)
+const _resolve = (edmName, model, namespace) => {
+  const resolved = model._edmToCSNNameMap[namespace][edmName.replace(/\./g, '_')]
   // 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 (!resolved && edmName.endsWith('Parameters')) {
+    const viewWithParam = model._edmToCSNNameMap[namespace][edmName.replace(/Parameters$/, '').replace(/\./g, '_')]
     if (!viewWithParam || !viewWithParam.params) return
     return viewWithParam
   }
   return resolved
 }
 
-const _findRootEntity = (model, edmName, namespace) => {
+const _findCsnTarget = (edmName, model, namespace) => {
+  let target = _resolve(edmName, model, namespace)
+  if (target) return target
+
+  if (!cds.env.effective.odata.structs) return
+
+  // navigation to structured like `StructuredTypes_structured_nested_` (edmx)
   const parts = edmName.split('_')
-  let csnName = parts.shift()
-  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_'
-  // for 'C_root_.kid_assoc_prop' it should find 'C_root_.kid_'
-  // and report 2 leftovers (namely 'assoc' and 'prop')
-  let left = len
-  let acc = 0
-  for (let i = 0; i < len; i++) {
-    /**
-     * Calculate CSN name.
-     * if target in entities connect with .
-     * if target not in entities connect with _
-     */
-    csnName = `${csnName}${_resolve(csnName, model, namespace) ? '.' : '_'}${parts[i]}`
-    ++acc
-    if (_resolve(csnName, model, namespace)) {
-      target = _resolve(csnName, model, namespace)
-      left -= acc
-      acc = 0
+  let i = parts.length
+  let name = edmName
+  while (!target && i > 1) {
+    // Traverse to find the longest entity name.
+    // All weird namings with `.` and `_` are already covered by cache.
+    name = name.replace(/_[^_]*$/, '')
+    target = _resolve(name, model, namespace)
+    i--
+  }
+  // something left in navigation path => resolving within found entity
+  if (i > 0 && target) {
+    const left = parts.slice(i - parts.length)
+    while (target && left.length) {
+      let elm = left.shift()
+      while (!target.elements[elm]) elm = `${elm}_${left.shift()}`
+      target = target.elements[elm]
     }
   }
-  // make sure we consider leftovers only for x4
-  return { left: (cds.env.effective.odata.proxies && left) || 0, target: target }
+  return target
 }
 
 const findCsnTargetFor = (edmName, model, namespace) => {
   const cache =
     model._edmToCSNNameMap || Object.defineProperty(model, '_edmToCSNNameMap', { value: {} })._edmToCSNNameMap
-  const mapping =
+  const edm2csnMap =
     cache[namespace] ||
-    Object.defineProperty(cache, namespace, { enumerable: true, configurable: true, value: {} })[namespace]
-
-  if (mapping[edmName]) return mapping[edmName]
-
-  // simple cases
-  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(model, edmName, namespace)
-    target = finding.target
-
-    // something left in navigation path => x4 navigation
-    // resolving within found entity
-    if (target && finding.left > 0) {
-      const left = edmName.split('_').slice(-finding.left)
-      while (target && left.length) {
-        let elm = left.shift()
-        while (!target.elements[elm]) elm = `${elm}_${left.shift()}`
-        target = target.elements[elm]
+    Object.defineProperty(cache, namespace, {
+      get() {
+        const _ = {}
+        for (const name in model.definitions) {
+          if (!name.startsWith(`${namespace}.`)) continue
+          _[name.replace(new RegExp(`^${namespace}\\.`), '').replace(/\./g, '_')] = model.definitions[name]
+        }
+        return _
       }
-    }
-  }
+    })[namespace]
+
+  const target = _findCsnTarget(edmName, model, namespace)
 
   // remember edm <-> csn
-  if (target) {
-    mapping[edmName] = target
+  if (target && !edm2csnMap[edmName]) {
+    edm2csnMap[edmName] = target
   }
 
-  return mapping[edmName]
+  return edm2csnMap[edmName]
 }
 
 const getElementDeep = (entity, ref) => {
@@ -177,14 +172,14 @@ const isRootEntity = (definitions, entityName) => {
   // TODO: There can be unmanaged relations to some parent -> not detected by the following code
   const associationElements = Object.keys(entity.elements)
     .map(key => entity.elements[key])
-    .filter(element => element._isAssociationEffective)
+    .filter(element => element._isAssociationStrict)
 
   for (const { target } of associationElements) {
     const parentEntity = definitions[target]
     for (const parentElementName in parentEntity.elements) {
       const parentElement = parentEntity.elements[parentElementName]
       if (
-        parentElement._isCompositionEffective &&
+        parentElement.isComposition &&
         parentElement.target === entityName &&
         !(parentElement.parent && ensureNoDraftsSuffix(parentElement.parent.name) === entityName)
       ) {
@@ -195,24 +190,29 @@ const isRootEntity = (definitions, entityName) => {
   return true
 }
 
-function _alias2RefRest(service) {
-  for (const each of Object.values(service.entities)) {
-    each._alias2ref = {}
-    const keys = each.keys
-    for (const key in keys) {
-      if (keys[key].elements) {
-        const structKeys = resolveStructured({ structName: key, structProperties: [] }, keys[key].elements, false, true)
-        for (const structKey of structKeys) {
-          if (each._alias2ref[structKey.key] != null) {
-            // key clash, aliasing not possible
-            each._alias2ref = {}
-            return
-          }
-          each._alias2ref[structKey.key] = structKey.resolved
-        }
+const _setAlias2ref = entity => {
+  const _ref2alias = {}
+  const _alias2ref = {}
+  const keys = entity.keys
+  for (const key in keys) {
+    const structKeys = resolveStructured({ element: keys[key], structProperties: [] }, false, true)
+    for (const structKey of structKeys) {
+      if (_alias2ref[structKey.key] != null) {
+        // key clash, aliasing not possible
+        return entity
       }
+      _alias2ref[structKey.key] = structKey.resolved
+      _ref2alias[structKey.resolved.join('/')] = key
     }
   }
+  entity._alias2ref = Object.defineProperty(_alias2ref, '__2alias', { value: _ref2alias, configurable: true })
+  return entity
+}
+
+function _alias2RefRest(service) {
+  for (const each of service.entities) {
+    _setAlias2ref(each)
+  }
 }
 
 const prefixForStruct = element => {
@@ -230,13 +230,14 @@ function alias2ref(service, edm) {
     return _alias2RefRest(service)
   }
   const defs = edm[service.definition.name]
-  for (const each of Object.values(service.entities)) {
+  for (const each of 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 = {}
+    each._alias2ref = Object.defineProperty({}, '__2alias', { value: {}, configurable: true })
     for (const mapping of def.$Key.filter(ele => typeof ele !== 'string')) {
       for (const [key, value] of Object.entries(mapping)) {
         each._alias2ref[key] = value.split('/')
+        each._alias2ref.__2alias[value] = key
       }
     }
   }
@@ -274,5 +275,6 @@ module.exports = {
   alias2ref,
   getComp2oneParents,
   prefixForStruct,
-  getDraftTreeRoot
+  getDraftTreeRoot,
+  setEntityContained
 }

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

@@ -1,19 +1,20 @@
 const cds = require('../../cds')
 
 module.exports = (entryOrRow, keyOrIndex, user, timestamp) => {
-  if (!entryOrRow[keyOrIndex]) return
+  const v = entryOrRow[keyOrIndex]
+  if (!v) return
 
   // REVISIT: shouldn't be necessary, but sql builder default for user currently cannot be an object (test issue?)
   // normalize user (object vs. string)
   user = user && user.id ? user : { id: user || 'anonymous' }
 
-  if (entryOrRow[keyOrIndex] === '$user') entryOrRow[keyOrIndex] = user.id
-  else if (entryOrRow[keyOrIndex] === '$now') entryOrRow[keyOrIndex] = timestamp
-  else if (entryOrRow[keyOrIndex] === '$uuid') entryOrRow[keyOrIndex] = cds.utils.uuid()
-  else if (typeof entryOrRow[keyOrIndex] === 'string') {
+  if (v === '$user') entryOrRow[keyOrIndex] = user.id
+  else if (v === '$now') entryOrRow[keyOrIndex] = timestamp
+  else if (v === '$uuid') entryOrRow[keyOrIndex] = cds.utils.uuid()
+  else if (typeof v === 'string') {
     // NOTE: with xsuaa, user attributes are always arrays
-    const attr = entryOrRow[keyOrIndex].match(/^\$user\.(.*)/)
-    if (attr && attr.length > 1) {
+    const attr = v.match(/^\$user\.(.*)/)
+    if (attr) {
       const val = (user.attr && user.attr[attr[1]]) || null
       if (Array.isArray(val)) {
         if (val.length > 1) entryOrRow[keyOrIndex] = JSON.stringify(val)

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

@@ -39,7 +39,7 @@ const getDraftColumnsCQNForActive = target => {
   ]
 }
 
-const getDraftColumnsCQNForDraft = target => {
+const getDraftColumnsCQNForDraft = () => {
   /*
    * NOTE: the following with xpr could be used to detect if there really is an active or not, but that breaks tests
    */

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

@@ -30,6 +30,10 @@ const _sub = (newOn, subOns = []) => {
 }
 
 const _getSubOns = element => {
+  // this only works for on conds with `and`, once we support `or` this needs to be adjusted
+
+  // TODO : check that no 'or' is in on
+
   const newOn = element.on || []
   const subOns = _sub(newOn)
 
@@ -38,6 +42,7 @@ const _getSubOns = element => {
     // A = B AND C = D AND ...
     if (subOn.length !== 3) return []
   }
+
   return subOns.map(subOn => subOn.map(ref => _normalizedRef(ref)))
 }
 
@@ -177,15 +182,17 @@ const foreignKeyPropagations = element => {
   if (element.is2many && element.on) {
     return _foreignKeyPropagationsFromOn(element)
   }
+
   if (element.is2one) {
-    if (!element.on) {
-      const foreignKeys = _foreignKeys(element)
-      if (foreignKeys) return _resolvedKeys(foreignKeys, false)
-    } else {
+    if (element.on) {
       // It's a link through a backlink
       return _foreignKeyPropagationsFromOn(element)
     }
+
+    const foreignKeys = _foreignKeys(element)
+    if (foreignKeys) return _resolvedKeys(foreignKeys, false)
   }
+
   return []
 }
 
@@ -218,10 +225,19 @@ const _poorMansLookup = (el, name, foreignKeySource) => {
 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('@')))
+  const key = navigationCsn.key
+
+  const foreignKeyCsn = Object.assign(Object.create(tk || el), { parent, name, foreignKeySource, key })
+  // REVISIT: Overwrite previously defined annotations, maybe there's a better way.
+  //          We might need to be careful with cached information (__xxx)
+  for (const prop in tk || el) {
+    if (prop.startsWith('@')) foreignKeyCsn[prop] = undefined
+  }
+  for (const key in navigationCsn) {
+    if (!key.startsWith('@')) continue
     foreignKeyCsn[key] = navigationCsn[key]
+  }
+  if ('notNull' in navigationCsn) foreignKeyCsn.notNull = navigationCsn.notNull
   return foreignKeyCsn
 }
 

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

@@ -93,7 +93,8 @@ const _newOnConditions = (csnElement, path, aliases) => {
 }
 
 const getOnCond = (csnElement, path = [], aliases = { select: '', join: '' }) => {
-  return ['(', ..._newOnConditions(csnElement, path, aliases), ')']
+  const oncond = _newOnConditions(csnElement, path, aliases)
+  return [{ xpr: oncond }]
 }
 
 module.exports = {

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

@@ -1,13 +1,25 @@
 const { where2obj } = require('./cqn')
 const { deepCopyArray } = require('./copy')
+const { getOnCond } = require('./generateOnCond')
 
 function _getOnCondElements(onCond, onCondElements = []) {
   const andIndex = onCond.indexOf('and')
-  const entityKey = onCond[2].ref && onCond[2].ref.join('.')
-  const entityVal = onCond[2].val
-  const targetKey = onCond[0].ref && onCond[0].ref.join('.')
-  const targetVal = onCond[0].val
-  onCondElements.push({ entityKey, targetKey, entityVal, targetVal })
+
+  const ref0 = onCond[0].ref
+  const ref1 = onCond[2].ref
+
+  let entityRef, targetRef
+  if (ref0 && ref0[0] === 'target') {
+    targetRef = ref0
+    entityRef = ref1
+  } else if (ref1 && ref1[0] === 'target') {
+    targetRef = ref1
+    entityRef = ref0
+  }
+
+  const entityKey = entityRef && entityRef.slice(1).join('.')
+  const targetKey = targetRef && targetRef.slice(1).join('.')
+  onCondElements.push({ entityKey, targetKey })
 
   if (andIndex !== -1) {
     _getOnCondElements(onCond.slice(andIndex + 1), onCondElements)
@@ -15,7 +27,7 @@ function _getOnCondElements(onCond, onCondElements = []) {
   return onCondElements
 }
 
-function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName) {
+function _modifyWhereWithNavigations(where, newWhere, entityKey, targetKey) {
   if (where) {
     // copy where else query will be modified
     const whereCopy = deepCopyArray(where)
@@ -24,8 +36,8 @@ function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName)
   }
 
   newWhere.forEach(element => {
-    if (element.ref && targetKeyElement._target.keys[element.ref[0]]) {
-      element.ref = [keyName + '_' + element.ref[0]]
+    if (element.ref && element.ref[0] === targetKey) {
+      element.ref = [entityKey]
     }
   })
 }
@@ -40,12 +52,17 @@ function _buildWhereForNavigations(ref, newWhere, model, target) {
 
     if (!navigationElement || !navigationElement.on) return
 
-    const nextKeys = _getOnCondElements(navigationElement.on)
+    const onCond = getOnCond(navigationElement, [], { select: 'source', join: 'target' })
+    const nextKeys = _getOnCondElements(onCond[0].xpr)
+
+    // only add where once in _modifyWhereWithNavigations
+    let whereAdded = false
     for (const key of nextKeys) {
-      const keyName = key.targetKey.replace(navigationElement.name + '.', '')
-      const targetKeyElement = navigationElement._target.elements[keyName]
-      if (targetKeyElement && targetKeyElement.isAssociation) {
-        _modifyWhereWithNavigations(currentRef.where, newWhere, targetKeyElement, keyName)
+      const targetKeyElement = navigationElement._target.elements[key.entityKey]
+
+      if (targetKeyElement && (targetKeyElement.isAssociation || targetKeyElement._foreignKey4)) {
+        _modifyWhereWithNavigations(!whereAdded && currentRef.where, newWhere, key.entityKey, key.targetKey, whereAdded)
+        whereAdded = true
       }
     }
     _buildWhereForNavigations(ref.slice(1), newWhere, model, navigationElement._target)

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

@@ -1,3 +1,4 @@
+const { hasAliasedColumns } = require('../../remote/utils/data')
 const { revertData } = require('./resolveView')
 
 // creates a map with key "remote origin name" and value { as: "projection name"}
@@ -17,6 +18,10 @@ const _createAliasMap = columns => {
       }
       if (col.expand) {
         processor.expand = col.expand
+        if (col.expand.some(hasAliasedColumns)) {
+          aliasMap || (aliasMap = new Map())
+          aliasMap.set(col.ref[col.ref.length - 1], processor)
+        }
       }
     }
 
@@ -36,7 +41,7 @@ const handleAliasInResult = (columns, result) => {
 
       for (const col in row) {
         const processor = postProcessor.get(col)
-        if (processor && processor.as !== col) {
+        if (processor && processor.as != null && processor.as !== col) {
           // if a value for the alias is already present, add it to the cache
           if (row[processor.as]) {
             tempCache.set(processor.as, row[processor.as])

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

@@ -1,35 +1,18 @@
 const cds = require('../../cds')
 
-const keywords = require('@sap/cds-compiler/lib/base/keywords')
 const { smartId } = require('@sap/cds-compiler/lib/sql-identifier')
 
 let _dialect
 
-const _DEFAULT_RESERVED = new Set(['WHERE', 'GROUP', 'ORDER', 'BY', 'AT', 'NO', 'LIMIT'])
-const _COMPILER_RESERVED = {
-  hana: new Set(keywords.hana),
-  sqlite: new Set(keywords.sqlite)
-}
-let _reserved = _DEFAULT_RESERVED
-
-const _isTruthy = s => s
 const _isQuoted = s => s.match(/^".*"$/)
-
 const _slugify = s => s.replace(/\./g, '_')
 const _smartId = s => smartId(_slugify(s), _dialect || 'plain')
-const _smartElement = s => {
-  if (s === '*' || _isQuoted(s)) return s
-  const upper = s.toUpperCase()
-  if (_reserved.has(upper)) return upper
-  return _smartId(s)
-}
 
 module.exports = {
   plain: s => {
     // set _dialect and _reserved once cds.db.kind is set
     if (!_dialect && cds.db && cds.db.kind) {
       _dialect = cds.db.options.dialect || cds.db.kind
-      _reserved = _COMPILER_RESERVED[_dialect] || _DEFAULT_RESERVED
     }
 
     if (typeof s !== 'string') throw new Error(`string expected but ${typeof s} received`)
@@ -37,12 +20,6 @@ module.exports = {
     // * or already quoted?
     if (s === '*' || _isQuoted(s)) return s
 
-    // expr or space in name?
-    // REVISIT: default behavior in cds^6?
-    if (s.match(/\s/) && !cds.env.sql.spaced_columns) {
-      return s.split(' ').filter(_isTruthy).map(_smartElement).join(' ')
-    }
-
     return _smartId(s)
   },
   quoted: s => `"${s}"`,

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

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

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

@@ -246,6 +246,7 @@ const _newWhere = (where = [], transition, tableName, alias, isSubselect = false
     if (whereElement.xpr) {
       return { xpr: _newWhere(whereElement.xpr, transition, tableName, alias, isSubselect) }
     }
+
     const newWhereElement = { ...whereElement }
     if (!whereElement.ref && !whereElement.SELECT && !whereElement.func) return whereElement
     if (whereElement.SELECT && whereElement.SELECT.where) {
@@ -309,6 +310,8 @@ const _rewriteQueryPath = (path, transitions) => {
           where: _newWhere(f.where, transitions[i], f.id)
         }
       }
+
+      return f
     }
   })
 }
@@ -656,7 +659,7 @@ const restoreLink = req => {
  * @returns {*} csn entity or undefined
  */
 const findQueryTarget = q => {
-  return q.SELECT
+  return q.SELECT && q.SELECT._transitions
     ? q.SELECT._transitions[q.SELECT._transitions.length - 1].target
     : q.INSERT
     ? q.INSERT._transitions[q.INSERT._transitions.length - 1].target

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

@@ -83,6 +83,9 @@ const rewriteAsterisks = (query, model, options) => {
 
   if (!query.SELECT.columns || !query.SELECT.columns.length) {
     if (_4db || _4fiori) {
+      // REVISIT these are two nasty hacks for UNION and JOIN,
+      // which should be implemented generically.
+      // Please, do not continue to develop here if possible.
       if (
         query.SELECT.from.SET &&
         query.SELECT.from.SET.args[0] &&