@sap/cds 7.6.4 → 7.7.1

package/libx/_runtime/cds-services/util/assert.js

@@ -5,20 +5,9 @@ const templatePathSerializer = require('../../common/utils/templateProcessorPath
 // REVISIT: replace with cds.Request
 const getEntry = require('../../common/error/entry')
 
-const ISO_DATE_PART1 =
-  '[1-9]\\d{3}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1\\d|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)'
-const ISO_DATE_PART2 = '(?:[1-9]\\d(?:0[48]|[2468][048]|[13579][26])|(?:[2468][048]|[13579][26])00)-02-29'
-const ISO_DATE = `(?:${ISO_DATE_PART1}|${ISO_DATE_PART2})`
-const ISO_TIME_NO_MILLIS = '(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d'
-const ISO_TIME = `${ISO_TIME_NO_MILLIS}(?:\\.\\d{1,9})?`
-const ISO_DATE_TIME = `${ISO_DATE}T${ISO_TIME_NO_MILLIS}(?:Z|[+-][01]\\d:?[0-5]\\d)`
-const ISO_TIMESTAMP = `${ISO_DATE}T${ISO_TIME}(?:Z|[+-][01]\\d:?[0-5]\\d)`
-
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
-const ISO_DATE_REGEX = new RegExp(`^${ISO_DATE}$`, 'i')
-const ISO_TIME_REGEX = new RegExp(`^${ISO_TIME_NO_MILLIS}$`, 'i')
-const ISO_DATE_TIME_REGEX = new RegExp(`^${ISO_DATE_TIME}$`, 'i')
-const ISO_TIMESTAMP_REGEX = new RegExp(`^${ISO_TIMESTAMP}$`, 'i')
+const typeCheckers = require('../../../common/assert/type')
+const { 'cds.Decimal': checkDecimal } = typeCheckers
+const { checkMandatory, checkEnum, checkRange, checkFormat } = require('../../../common/assert/validation')
 
 const ASSERT_VALID_ELEMENT = 'ASSERT_VALID_ELEMENT'
 const ASSERT_RANGE = 'ASSERT_RANGE'
@@ -80,93 +69,6 @@ const assertError = (code, element, value, key, path) => {
   return assertError
 }
 
-const _checkString = value => typeof value === 'string'
-
-const _checkNumber = value => typeof value === 'number'
-
-const _checkDecimal = (value, element) => {
-  const [left, right] = String(value).split('.')
-  return (
-    _checkNumber(value) &&
-    (!element.precision || left.length <= element.precision - (element.scale || 0)) &&
-    (!element.scale || ((right || '').length <= element.scale && parseFloat(right) !== 0))
-  )
-}
-
-const _checkInteger = value => _checkNumber(value) && parseInt(value, 10) === value
-
-const _checkBoolean = value => typeof value === 'boolean'
-
-// REVISIT: Extension parameter in push is an object with buffer data
-const _checkBuffer = value => Buffer.isBuffer(value) || value.type === 'Buffer'
-
-const _checkUUID = value => {
-  return _checkString(value) && UUID_REGEX.test(value)
-}
-
-const _checkISODate = value => (_checkString(value) && ISO_DATE_REGEX.test(value)) || value instanceof Date
-
-const _checkISOTime = value => _checkString(value) && ISO_TIME_REGEX.test(value)
-
-const _checkISODateTime = value => (_checkString(value) && ISO_DATE_TIME_REGEX.test(value)) || value instanceof Date
-
-const _checkISOTimestamp = value => (_checkString(value) && ISO_TIMESTAMP_REGEX.test(value)) || value instanceof Date
-
-const _checkDateValue = (val, r1, r2) => {
-  const dateVal = new Date(val)
-  return (dateVal - new Date(r1)) * (dateVal - new Date(r2)) <= 0
-}
-
-const _toDate = val => `2000-01-01T${val}Z`
-
-const _checkInRange = (val, range, type) => {
-  switch (type) {
-    case 'cds.Date':
-      return _checkISODate(val) && _checkDateValue(val, range[0], range[1])
-    case 'cds.DateTime':
-      return _checkISODateTime(val) && _checkDateValue(val, range[0], range[1])
-    case 'cds.Timestamp':
-      return _checkISOTimestamp(val) && _checkDateValue(val, range[0], range[1])
-    case 'cds.Time':
-      return _checkISOTime(val) && _checkDateValue(_toDate(val), _toDate(range[0]), _toDate(range[1]))
-    default:
-      return (val - range[0]) * (val - range[1]) <= 0
-  }
-}
-
-const _resolveCDSType = element => {
-  if (element.type.startsWith('cds.')) return element.type
-  if (!element.type) return
-
-  return _resolveCDSType(element.__proto__)
-}
-
-// process.env.CDS_ASSERT_FORMAT_FLAGS not official!
-const _checkRegExpFormat = (val, format) =>
-  _checkString(val) && val.match(new RegExp(format, process.env.CDS_ASSERT_FORMAT_FLAGS || 'u'))
-
-const CDS_TYPE_CHECKS = {
-  'cds.UUID': _checkUUID,
-  'cds.Boolean': _checkBoolean,
-  'cds.Integer': _checkInteger,
-  'cds.UInt8': _checkInteger,
-  'cds.Int16': _checkInteger,
-  'cds.Int32': _checkInteger,
-  'cds.Integer64': _checkInteger,
-  'cds.Int64': _checkInteger,
-  'cds.Decimal': _checkDecimal,
-  'cds.DecimalFloat': _checkNumber,
-  'cds.Double': _checkNumber,
-  'cds.Date': _checkISODate,
-  'cds.Time': _checkISOTime,
-  'cds.DateTime': _checkISODateTime,
-  'cds.Timestamp': _checkISOTimestamp,
-  'cds.String': _checkString,
-  'cds.Binary': _checkBuffer,
-  'cds.LargeString': _checkString,
-  'cds.LargeBinary': _checkBuffer
-}
-
 // Limitation: depth 1
 const checkComplexType = ([key, value], elements, ignoreNonModelledData) => {
   let found = false
@@ -174,12 +76,12 @@ const checkComplexType = ([key, value], elements, ignoreNonModelledData) => {
   for (const objKey in elements) {
     if (objKey.startsWith(`${key}_`)) {
       const element = elements[objKey]
-      const check = CDS_TYPE_CHECKS[element._type]
+      const typeChecker = typeCheckers[element._type]
       found = true
 
       const nestedData = value[objKey.substring(key.length + 1)]
       // check existence of nestedData to not stumble across not-provided, yet-modelled type parts with depth > 1
-      if (nestedData && !check(nestedData)) {
+      if (nestedData && !typeChecker(nestedData)) {
         return false
       }
     }
@@ -188,6 +90,7 @@ const checkComplexType = ([key, value], elements, ignoreNonModelledData) => {
   return found || ignoreNonModelledData
 }
 
+// TODO: what fails if no-op?!
 const checkStaticElementByKey = (definition, key, value, result = [], ignoreNonModelledData = true) => {
   const elementsOrParameters = definition.elements || definition.params
   if (!elementsOrParameters) return result
@@ -201,15 +104,15 @@ const checkStaticElementByKey = (definition, key, value, result = [], ignoreNonM
     return result
   }
 
-  let check
+  let typeChecker
   if (elementOrParameter.isUUID && definition.name === 'ProvisioningService.tenant') {
     // > old SCP accounts don't have UUID ids
-    check = CDS_TYPE_CHECKS['cds.String']
+    typeChecker = typeCheckers['cds.String']
   } else {
-    check = CDS_TYPE_CHECKS[elementOrParameter._type]
+    typeChecker = typeCheckers[elementOrParameter._type]
   }
 
-  if (check && !check(value, elementOrParameter)) {
+  if (typeChecker && !typeChecker(value, elementOrParameter)) {
     // code, entity, element, value
     const args = [typeof value === 'string' ? '"' + value + '"' : value, elementOrParameter._type]
     result.push(assertError({ code: ASSERT_DATA_TYPE, args }, elementOrParameter, value, key))
@@ -218,131 +121,62 @@ const checkStaticElementByKey = (definition, key, value, result = [], ignoreNonM
   return result
 }
 
-const _isNotFilled = value =>
-  value === null || value === undefined || (typeof value === 'string' && value.trim() === '')
-
-const _checkMandatoryElement = (element, value, errors, key, pathSegmentsInfo) => {
-  if (element.parent?.query?.SELECT?.columns?.find(col => _isNavigationColumn(col, element.name))) return
-  if (element._isMandatory && !element.default && _isNotFilled(value)) {
-    errors.push(assertError(ASSERT_NOT_NULL, element, value, key, pathSegmentsInfo))
-  }
-}
-
-const _isNavigationColumn = (column, searched) =>
-  column.ref?.length > 1 && (column.as === searched || column.ref[column.ref.length - 1] === searched)
-
-const _getEnumElement = element =>
-  (element['@assert.range'] && element.enum) || element['@assert.enum'] ? element.enum : undefined
-
-const _checkEnumElement = (element, value, errors, key, pathSegmentsInfo) => {
-  const enumElements = _getEnumElement(element)
-  const enumValues = enumElements && _enumValues(enumElements)
+/**
+ * @param {import('../../types/api').InputConstraints} constraints
+ */
+const checkInputConstraints = ({ element, value, errors, key, pathSegmentsInfo }) => {
+  if (!element) return errors
 
-  if (enumElements && !enumValues.includes(value)) {
-    const args =
-      typeof value === 'string'
-        ? ['"' + value + '"', enumValues.map(ele => '"' + ele + '"').join(', ')]
-        : [value, enumValues.join(', ')]
+  let path
+  if (pathSegmentsInfo?.length) path = templatePathSerializer(element.name || key, pathSegmentsInfo)
 
-    errors.push(assertError({ code: ASSERT_ENUM, args }, element, value, key, pathSegmentsInfo))
+  // not nice, but best option for keeping new cds.assert() clean
+  if (element._isMandatory) {
+    const mandatoryErrors = []
+    checkMandatory(value, element, mandatoryErrors, [], key)
+    if (mandatoryErrors.length) {
+      errors.push(...mandatoryErrors.map(() => assertError({ code: ASSERT_NOT_NULL }, element, value, key, path)))
+    }
   }
-}
 
-const _checkRangeElement = (element, value, errors, key, pathSegmentsInfo) => {
-  const rangeElements = element['@assert.range'] && !_getEnumElement(element) ? element['@assert.range'] : undefined
-  if (rangeElements && !_checkInRange(value, rangeElements, _resolveCDSType(element))) {
-    const args = [value, ...element['@assert.range']]
-    errors.push(assertError({ code: ASSERT_RANGE, args }, element, value, key, pathSegmentsInfo))
-  }
-}
+  if (value == null) return errors
 
-const _checkFormatElement = (element, value, errors, key, pathSegments) => {
-  const formatElements = element['@assert.format']
-  if (formatElements && !_checkRegExpFormat(value, formatElements)) {
-    errors.push(assertError({ code: ASSERT_FORMAT, args: [value, formatElements] }, element, value, key, pathSegments))
+  // not nice, but best option for keeping new cds.assert() clean
+  const enumErrors = []
+  checkEnum(value, element, enumErrors, [], key)
+  if (enumErrors.length) {
+    errors.push(...enumErrors.map(e => assertError({ code: ASSERT_ENUM, args: e.args }, element, value, key, path)))
   }
-}
 
-const getNormalizedDecimal = value => {
-  let val = `${value}`
-  const cgs = val.match(/^(\d*\.*\d*)e([+|-]*)(\d*)$/)
-  if (cgs) {
-    let [l, r = ''] = cgs[1].split('.')
-    const dir = cgs[2] || '+'
-    const exp = Number(cgs[3])
-    if (dir === '+') {
-      // move decimal point to the right
-      r = r.padEnd(exp, '0')
-      l += r.substring(0, exp)
-      r = r.slice(exp)
-      val = `${l}${r ? '.' + r : ''}`
-    } else {
-      // move decimal point to the left
-      l = l.padStart(exp, '0')
-      r = l.substring(0, exp) + r
-      l = l.slice(exp)
-      val = `${l ? l : '0'}.${r}`
-    }
+  // not nice, but best option for keeping new cds.assert() clean
+  const rangeErrors = []
+  checkRange(value, element, rangeErrors, [], key)
+  if (rangeErrors.length) {
+    errors.push(...rangeErrors.map(e => assertError({ code: ASSERT_RANGE, args: e.args }, element, value, key, path)))
   }
-  return val
-}
 
-const _checkDecimalElement = (element, value, errors, key, path) => {
-  const { precision, scale } = element
-  let val = getNormalizedDecimal(value)
-  if (precision != null && scale != null) {
-    let isValid = true
-    if (!val.match(/\./)) val += '.0'
-
-    if (precision === scale) {
-      if (!val.match(new RegExp(`^-?0\\.\\d{0,${scale}}$`, 'g'))) isValid = false
-    } else if (scale === 0) {
-      if (!val.match(new RegExp(`^-?\\d{1,${precision - scale}}\\.0{0,1}$`, 'g'))) isValid = false
-    } else if (!val.match(new RegExp(`^-?\\d{1,${precision - scale}}\\.\\d{0,${scale}}$`, 'g'))) {
-      isValid = false
-    }
+  // not nice, but best option for keeping new cds.assert() clean
+  const formatErrors = []
+  checkFormat(value, element, formatErrors, [], key)
+  if (formatErrors.length) {
+    errors.push(...formatErrors.map(e => assertError({ code: ASSERT_FORMAT, args: e.args }, element, value, key, path)))
+  }
 
-    if (!isValid)
+  if (element.type === 'cds.Decimal') {
+    // not nice, but best option for keeping new cds.assert() clean
+    const decimalErrors = []
+    checkDecimal(value, element, decimalErrors, [], key)
+    if (decimalErrors.length) {
       errors.push(
-        assertError(
-          { code: ASSERT_DATA_TYPE, args: [value, `Decimal(${precision},${scale})`] },
-          element,
-          value,
-          key,
-          path
-        )
-      )
-  } else if (precision != null) {
-    if (!val.match(new RegExp(`^-?\\d{1,${precision}}$`, 'g'))) {
-      errors.push(
-        assertError({ code: ASSERT_DATA_TYPE, args: [value, `Decimal(${precision})`] }, element, value, key, path)
+        ...decimalErrors.map(e => assertError({ code: ASSERT_DATA_TYPE, args: e.args }, element, value, key, path))
       )
     }
   }
-}
-
-/**
- * @param {import('../../types/api').InputConstraints} constraints
- */
-const checkInputConstraints = ({ element, value, errors, key, pathSegmentsInfo }) => {
-  if (!element) return errors
-
-  let path
-
-  if (pathSegmentsInfo?.length) path = templatePathSerializer(element.name || key, pathSegmentsInfo)
-  _checkMandatoryElement(element, value, errors, key, path)
-
-  if (value == null) return errors
-
-  _checkEnumElement(element, value, errors, key, path)
-  _checkRangeElement(element, value, errors, key, path)
-  _checkFormatElement(element, value, errors, key, path)
-
-  if (element.type === 'cds.Decimal') _checkDecimalElement(element, value, errors, key, path)
 
   return errors
 }
 
+// TODO: what fails if no-op?!
 const checkStatic = (definition, data, ignoreNonModelledData = false) => {
   if (!Array.isArray(data)) data = [data]
 
@@ -355,24 +189,6 @@ const checkStatic = (definition, data, ignoreNonModelledData = false) => {
   }, [])
 }
 
-const checkKeys = (entity, data) => {
-  if (!Array.isArray(data)) {
-    return checkKeys(entity, [data])
-  }
-
-  const entityKeys = Object.keys(entity.keys)
-  return data.reduce((result, row) => {
-    for (const key of entityKeys) {
-      if (row[key] === undefined && !entity.elements[key].isAssociation)
-        result.push(assertError(ASSERT_NOT_NULL, entity.elements[key]))
-    }
-
-    return result
-  }, [])
-}
-
-const assertNotNullError = element => assertError(ASSERT_NOT_NULL, element)
-
 /**
  * Check whether the target entity referenced by the association (the reference's target) exists and assert an error if
  * the the reference's target doesn't exist.
@@ -428,14 +244,8 @@ const assertTargets = async (assertMap, errors) => {
 }
 
 module.exports = {
-  CDS_TYPE_CHECKS,
-  checkComplexType,
   checkStatic,
-  checkInputConstraints,
-  checkKeys,
-  assertError,
   checkStaticElementByKey,
-  assertNotNullError,
-  assertTargets,
-  getNormalizedDecimal
+  checkInputConstraints,
+  assertTargets
 }

package/libx/_runtime/cds.js

@@ -10,6 +10,11 @@ cds.extend(any).with(require('./common/aspects/any'))
 cds.extend(Association).with(require('./common/aspects/Association'))
 cds.extend(entity).with(require('./common/aspects/entity'))
 
+/*
+ * cds.assert(data, definition, options?)
+ */
+Object.defineProperty(cds, 'assert', { get: () => require('../common/assert') })
+
 /**
  * Logs a deprecation warning once per process
  *

package/libx/_runtime/common/aspects/any.js

@@ -1,31 +1,34 @@
 const { foreignKey4 } = require('../../common/utils/foreignKeyPropagations')
 
-// NOTE: Please only add things which are relevant to _any_ type,
-// use specialized types otherwise (entity, Association, ...).
-module.exports = class {
-  get _isStructured() {
-    return this.own('__isStructured', () => !!this.elements && this.kind !== 'entity')
-  }
-
-  get _isMandatory() {
-    return this.own('__isMandatory', () => !this.isAssociation && isMandatory(this))
-  }
-
-  get _isReadOnly() {
-    return this.own('__isReadOnly', () => !this.key && isReadOnly(this))
-  }
+const _getCommonFieldControl = e => {
+  const cfr = e['@Common.FieldControl']
+  return cfr && cfr['#']
+}
 
-  // REVISIT: Where to put?
-  get _relations() {
-    return this.own('__relations', () => getRelations(this))
-  }
+const _isMandatory = e => {
+  return (
+    e['@assert.mandatory'] !== false &&
+    (e['@mandatory'] ||
+      e['@Common.FieldControl.Mandatory'] ||
+      e['@FieldControl.Mandatory'] ||
+      _getCommonFieldControl(e) === 'Mandatory')
+  )
+}
 
-  get _foreignKey4() {
-    return this.own('__foreignKey4', () => foreignKey4(this))
-  }
+const _isReadOnly = e => {
+  return (
+    e['@readonly'] ||
+    e['@cds.on.update'] ||
+    e['@cds.on.insert'] ||
+    e['@Core.Computed'] ||
+    e['@Common.FieldControl.ReadOnly'] ||
+    e['@FieldControl.ReadOnly'] ||
+    _getCommonFieldControl(e) === 'ReadOnly'
+  )
 }
 
 const Relation = require('./relation')
+
 const _exposeRelation = relation => Object.defineProperty({}, '_', { get: () => relation })
 
 const _relationHandler = relation => ({
@@ -52,34 +55,39 @@ const _relationHandler = relation => ({
   }
 })
 
-const getRelations = e => {
+const _getRelations = e => {
   const newRelation = Relation.to(e)
   return new Proxy(_exposeRelation(newRelation), _relationHandler(newRelation))
 }
 
-const CommonFieldControl = e => {
-  const cfr = e['@Common.FieldControl']
-  return cfr && cfr['#']
-}
+// NOTE: Please only add things which are relevant to _any_ type,
+// use specialized types otherwise (entity, Association, ...).
+module.exports = class {
+  get _isStructured() {
+    return this.own('__isStructured', () => !!this.elements && this.kind !== 'entity')
+  }
 
-const isMandatory = e => {
-  return (
-    e['@assert.mandatory'] !== false &&
-    (e['@mandatory'] ||
-      e['@Common.FieldControl.Mandatory'] ||
-      e['@FieldControl.Mandatory'] ||
-      CommonFieldControl(e) === 'Mandatory')
-  )
-}
+  get _isMandatory() {
+    return this.own('__isMandatory', () => !this.isAssociation && _isMandatory(this))
+  }
 
-const isReadOnly = e => {
-  return (
-    e['@readonly'] ||
-    e['@cds.on.update'] ||
-    e['@cds.on.insert'] ||
-    e['@Core.Computed'] ||
-    e['@Common.FieldControl.ReadOnly'] ||
-    e['@FieldControl.ReadOnly'] ||
-    CommonFieldControl(e) === 'ReadOnly'
-  )
+  get _isReadOnly() {
+    return this.own('__isReadOnly', () => !this.key && _isReadOnly(this))
+  }
+
+  get _mandatories() {
+    return this.own(
+      '__mandatories',
+      () => this.elements && Object.entries(this.elements).filter(([_, v]) => v._isMandatory)
+    )
+  }
+
+  // REVISIT: Where to put?
+  get _relations() {
+    return this.own('__relations', () => _getRelations(this))
+  }
+
+  get _foreignKey4() {
+    return this.own('__foreignKey4', () => foreignKey4(this))
+  }
 }

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

@@ -179,19 +179,23 @@ const _pick = element => {
     categories.push({ category: 'propagateForeignKeys' })
   }
 
-  if (
-    element['@assert.range'] ||
-    element['@assert.enum'] ||
-    element['@assert.format'] ||
-    element.type === 'cds.Decimal'
-  ) {
-    categories.push('assert')
-  }
+  if (!cds.env.features.cds_assert) {
+    if (
+      element['@assert.range'] ||
+      element['@assert.enum'] ||
+      element['@assert.format'] ||
+      element.type === 'cds.Decimal'
+    ) {
+      categories.push('assert')
+    }
 
-  if (element._isMandatory) {
-    categories.push('mandatory')
+    if (element._isMandatory) {
+      categories.push('mandatory')
+    }
   }
 
+  // TODO: can we move more checks to cds.assert()?
+
   if (element._isReadOnly) {
     // > _isReadOnly includes @cds.on.insert and @cds.on.update
     categories.push('readonly')

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

@@ -21,7 +21,7 @@ const getPageSize = def => {
     DEFAULT
   if (!max) max = Number.MAX_SAFE_INTEGER
   if (!_default || _default > max) _default = max
-  return (def[_cached] = { default: _default, max })
+  return def.set(_cached, { default: _default, max })
 }
 
 const commonGenericPaging = function (req) {

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

@@ -37,7 +37,7 @@ function where2obj(where, target = null, data = {}) {
     // optional validation if target is passed
     if (target) {
       const colEl = target.elements[colName]
-      if (!colEl || !(colEl.key || colEl.__foreignKey4)) continue
+      if (!colEl || !colEl.key) continue
     }
     const opWhere = where[i + 1]
     const valWhere = where[i + 2]

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

@@ -12,7 +12,7 @@ const getError = require('../../common/error')
 const { rewriteAsterisks } = require('./rewriteAsterisks')
 const { getEntityFromPath } = require('../../common/utils/path')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
-const { addRefToWhereIfNecessary } = require('../../../odata/afterburner')
+const { addRefToWhereIfNecessary } = require('../../../odata/parse/afterburner')
 const { addAliasToExpression, PARENT_ALIAS, FOREIGN_ALIAS } = require('../../db/utils/generateAliases')
 const { getColumns } = require('../../cds-services/services/utils/columns')
 

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

@@ -57,7 +57,7 @@ function _buildWhereForNavigations(ref, newWhere, model, target) {
 
     if (!navigationElement || !navigationElement.on) return
 
-    const onCond = getOnCond(navigationElement, [], { select: 'source', join: 'target' })
+    const onCond = getOnCond(navigationElement, [navigationElement.name], { select: 'source', join: 'target' })
     const nextKeys = _getOnCondElements(onCond[0].xpr)
 
     // only add where once in _modifyWhereWithNavigations

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

@@ -1,6 +1,6 @@
 const cds = require('../../cds')
 
-const { smartId } = require('@sap/cds-compiler/lib/sql-identifier')
+const { smartId } = cds.compiler.to.sql
 
 let _dialect
 

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

@@ -13,17 +13,20 @@ const _flattenProps = (element, structProperties, asRef, withKey, prefix) => {
     if (structProperties.length && element.is2one && !element.on) {
       const resolved = [...prefix, ...structProperties]
       if (withKey) {
+        // TODO: should be "element._alias || element.name", but how to get alias from edm?
+        //       cf. removed alias2ref (https://github.tools.sap/cap/cds/pull/3583)
         return [{ key: element.name, resolved }]
       }
       const flattenedName = resolved.join('_')
       return asRef ? [{ ref: [flattenedName] }] : [flattenedName]
     }
-
     return []
   }
 
   const resolved = [...prefix, element.name]
   if (withKey) {
+    // TODO: should be "element._alias || element.name", but how to get alias from edm?
+    //       cf. removed alias2ref (https://github.tools.sap/cap/cds/pull/3583)
     return [{ key: element.name, resolved }]
   }
   const flattenedName = resolved.join('_')

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

@@ -68,22 +68,15 @@ const rewriteExpandAsterisk = (columns, target) => {
   }
 }
 
-const _isLargeBinary = (col, target) => target.elements[col.ref[col.ref.length - 1]]?.type === 'cds.LargeBinary'
-
 const _rewriteAsterisk = (columns, target, _4db, isRoot) => {
   const asteriskColumnIndex = columns.findIndex(col => isAsteriskColumn(col))
   if (asteriskColumnIndex > -1) {
     columns.splice(
       asteriskColumnIndex,
       1,
-      ...getColumns(target, { _4db })
+      ...getColumns(target, { _4db, omitStream: !cds.env.features.stream_compat })
         .map(c => ({ ref: [c.name] }))
-        .filter(
-          c =>
-            !columns.find(isDuplicate(c)) &&
-            (!_4db || cds.env.features.stream_compat || !_isLargeBinary(c, target)) &&
-            (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID')
-        )
+        .filter(c => !columns.find(isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
     )
   }
 }
@@ -150,9 +143,9 @@ const rewriteAsterisks = (query, model, options) => {
         const target = _targetOfQueryIfNotDraft(query, model)
         if (!target) return
 
-        query.SELECT.columns = getColumns(target, { _4db })
-          .map(col => ({ ref: [col.name] }))
-          .filter(col => !_4db || cds.env.features.stream_compat || !_isLargeBinary(col, target))
+        query.SELECT.columns = getColumns(target, { _4db, omitStream: !cds.env.features.stream_compat }).map(col => ({
+          ref: [col.name]
+        }))
         if (_4db && target._isDraftEnabled && !cds.env.fiori.lean_draft)
           query.SELECT.columns.push(..._cqlDraftColumns(target))
       }