@sap/cds 6.4.1 → 6.6.0

package/libx/_runtime/fiori/utils/delete.js

@@ -34,6 +34,8 @@ const _validate = (activeResult, draftResult, req, IsActiveEntity) => {
 }
 
 const deleteDraft = async (req, srv, includingActive = false) => {
+  if (!cds.db) req.reject('NO_DATABASE_CONNECTION')
+
   const dbtx = cds.tx(req)
   const definitions = srv.model.definitions
 

package/libx/_runtime/hana/customBuilder/CustomSelectBuilder.js

@@ -4,6 +4,11 @@ const LOG = cds.log('hana|db|sql')
 const SelectBuilder = require('../../db/sql-builder').SelectBuilder
 
 class CustomSelectBuilder extends SelectBuilder {
+  constructor(obj, options, csn) {
+    super(obj, options, csn)
+    // $searchUsingContains property is set in the sub SELECT of the query, optimized search case
+    if (this._obj?._$searchUsingContains) this._options.$searchUsingContains = this._obj._$searchUsingContains
+  }
   get FunctionBuilder() {
     const FunctionBuilder = require('./CustomFunctionBuilder')
     Object.defineProperty(this, 'FunctionBuilder', { value: FunctionBuilder })
@@ -28,11 +33,6 @@ class CustomSelectBuilder extends SelectBuilder {
     return SelectBuilder
   }
 
-  getDefaultOptions() {
-    const options = { $searchUsingContains: !!this._obj.SELECT._$searchUsingContains }
-    return { ...super.getDefaultOptions(), ...options }
-  }
-
   _val(obj) {
     if (typeof obj.val === 'boolean') return { sql: obj.val ? 'true' : 'false', values: [] }
     return super._val(obj)

package/libx/_runtime/hana/pool.js

@@ -79,7 +79,7 @@ async function credentials4(tenant, db) {
   }
 
   if (cds.xt?.serviceManager && !cds.env.requires['cds.xt.DeploymentService']?.['old-instance-manager']) {
-    return (await db._instance_manager.get(tenant)).credentials
+    return (await db._instance_manager.get(tenant, { disableCache: true })).credentials
   }
 
   return new Promise((resolve, reject) => {

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,8 +1,25 @@
+const cds = require('../cds')
 const { computeColumnsToBeSearched } = require('../cds-services/services/utils/columns')
 const searchToLike = require('../common/utils/searchToLike')
 const { isContainsPredicateSupported, search2Contains } = require('./search2Contains')
 const { addAliasToExpression } = require('../db/utils/generateAliases')
-
+const targetAlias = 'Target'
+const textsAlias = 'Texts'
+const _generateKeysWhereCondition = (entity, alias1, alias2) => {
+  const keys = Object.keys(entity.keys).filter(k => !entity.keys[k].isAssociation)
+  const where = []
+  keys.forEach(key => {
+    if (where.length > 0) where.push('and')
+    where.push({ ref: [alias1, key] }, '=', { ref: [alias2, key] })
+  })
+  return where
+}
+const _generateContainsColumns = (columns, entity) => {
+  const columnsTarget = addAliasToExpression(columns, targetAlias)
+  const columns2SearchText = columns.filter(col => col.ref && entity.elements[col.ref[col.ref.length - 1]].localized)
+  const columnsText = addAliasToExpression(columns2SearchText, textsAlias)
+  return [...columnsTarget, ...columnsText]
+}
 /**
  * Computes a CQN expression for a search query.
  *
@@ -24,67 +41,50 @@ const search2cqn4sql = (query, entity, options) => {
   const cqnSearchPhrase = query.SELECT.search
   if (!cqnSearchPhrase) return query
 
-  let { columns: columns2Search = computeColumnsToBeSearched(query, entity), locale } = options
   const localizedAssociation = entity.associations?.localized
-
-  // Resolve localized data at runtime if the localized association is defined for the target entity.
-  // Notice that if the localized association is defined, there should be at least one localized element.
   if (localizedAssociation) {
-    const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
+    let { columns: columns2Search = computeColumnsToBeSearched(query, entity), locale } = options
+    const viewAlias = query.SELECT.from.as ? query.SELECT.from.as : 'LocalizedView'
+    if (!query.SELECT.from.as) {
+      _addAliasToQuery(query, viewAlias)
+    }
 
-    // REVISIT this is dirty but works for now
-    // replace $user_locale placeholder with the user locale or the HANA session context
-    onCondition[0].xpr[onCondition[0].xpr.length - 1] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
+    const subQuery = cds.ql.SELECT.from(entity.name).columns(1)
+    subQuery.SELECT.from.as = targetAlias
+    const onCondition = _generateKeysWhereCondition(entity, targetAlias, textsAlias)
+    onCondition.push('and', { ref: [textsAlias, 'locale'] }, '=', { val: locale || "SESSION_CONTEXT('LOCALE')" })
 
-    // inner join the target table with the _texts table (the _texts table contains the translated texts)
-    const localizedEntityName = localizedAssociation.target
-    query.join(localizedEntityName).on(onCondition)
+    // left outer join the target table with the _texts table (the _texts table contains the translated texts)
+    subQuery.leftJoin(localizedAssociation.target, textsAlias).on(onCondition)
+    // add condition for equal keys of target table and localized view
+    subQuery.where(_generateKeysWhereCondition(entity, targetAlias, viewAlias))
+    const containsColumns = _generateContainsColumns(columns2Search, entity)
+    let expression
+    if (isContainsPredicateSupported(query, entity, columns2Search)) {
+      // generate CQN expression with `CONTAINS` predicate for the columns from the target and text table
+      expression = search2Contains(cqnSearchPhrase, containsColumns)
+      Object.defineProperty(subQuery, '_$searchUsingContains', { value: true, enumerable: true })
+    } else {
+      expression = searchToLike(cqnSearchPhrase, containsColumns)
+    }
 
-    // prevent SQL ambiguity error for columns with the same name
-    columns2Search = _addAliasToQuery(query, entity, columns2Search)
+    subQuery.where(expression)
 
-    // suppress the localize handler from redirecting the query's target to the localized view
-    Object.defineProperty(query, '_suppressLocalization', { value: true })
-  } // else --> resolve localized texts via localized view (default)
+    // suppress the localize handler from redirecting the subQuery's target to the localized view
+    Object.defineProperty(subQuery, '_suppressLocalization', { value: true })
+    query.where('exists', subQuery)
 
-  const useContains = !!localizedAssociation && isContainsPredicateSupported(query, entity, columns2Search)
-  let expression
-
-  if (useContains) {
-    expression = search2Contains(cqnSearchPhrase, columns2Search)
-    Object.defineProperty(query.SELECT, '_$searchUsingContains', { value: true, enumerable: true })
-  } else {
-    // No CONTAINS optimization possible. The search implementation for localized
-    // texts falls back to the LIKE predicate.
-    expression = searchToLike(cqnSearchPhrase, columns2Search)
+    return query
   }
-
-  // REVISIT: find out here if where or having must be used
-  query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
-  return query
 }
 
-// The inner join modifies the original SELECT ... FROM query and adds ambiguity,
-// therefore add the table/entity name (as a preceding element) to the columns ref
-// to prevent a SQL ambiguity error.
-const _addAliasToQuery = (query, entity, columnsToBeSearched) => {
+const _addAliasToQuery = (query, alias) => {
   const SELECT = query.SELECT
-  const localizedEntityName = entity.associations?.localized.target
-  const elements = entity.elements
-  const entityName = entity.name
-  const getEntityName = columnRef => {
-    const columnName = columnRef[0]
-    const localizedElement = !!elements[columnName].localized
-    const targetEntityName = localizedElement ? localizedEntityName : entityName
-    return targetEntityName
-  }
-
-  SELECT.columns = addAliasToExpression(SELECT.columns, getEntityName)
-  columnsToBeSearched = addAliasToExpression(columnsToBeSearched, getEntityName)
-  SELECT.groupBy = addAliasToExpression(SELECT.groupBy, getEntityName)
-  SELECT.orderBy = addAliasToExpression(SELECT.orderBy, getEntityName)
-  SELECT.where = addAliasToExpression(SELECT.where, getEntityName)
-  return columnsToBeSearched
+  SELECT.from.as = alias
+  SELECT.columns = addAliasToExpression(SELECT.columns, alias)
+  SELECT.groupBy = addAliasToExpression(SELECT.groupBy, alias)
+  SELECT.orderBy = addAliasToExpression(SELECT.orderBy, alias)
+  SELECT.where = addAliasToExpression(SELECT.where, alias)
 }
 
 module.exports = search2cqn4sql

package/libx/_runtime/messaging/Outbox.js

@@ -40,7 +40,7 @@ class OutboxService extends cds.Service {
           } catch (e) {
             LOG.error('Emit failed', { event: msg.event, cause: e })
             // opts.crashOnError is not official!!!
-            if (isUnrecoverable(this, e) && outboxOpts.crashOnError !== false) process.exit(1)
+            if (isUnrecoverable(this, e) && outboxOpts.crashOnError !== false) cds.exit(1)
           }
         })
         return

package/libx/_runtime/messaging/enterprise-messaging-utils/getTenantInfo.js

@@ -1,6 +1,7 @@
 const cds = require('../../cds')
 const _transform = o => ({ subdomain: o.subscribedSubdomain, tenant: o.subscribedTenantId })
 
+// REVISIT: Looks ugly -> can we simplify that?
 const getTenantInfo = async tenant => {
   const provisioningServiceName = cds.mtx ? 'ProvisioningService' : 'cds.xt.SaasProvisioningService'
   const primaryKey = cds.mtx ? 'ID' : 'subscribedTenantId'

package/libx/_runtime/messaging/enterprise-messaging.js

@@ -85,8 +85,7 @@ class EnterpriseMessaging extends AMQPWebhookMessaging {
     const deploymentSrv = await cds.connect.to('cds.xt.DeploymentService')
     const provisioningSrv = await cds.connect.to('cds.xt.SaasProvisioningService')
     deploymentSrv.impl(() => {
-      deploymentSrv.on('subscribe', async (req, next) => {
-        const res = await next()
+      deploymentSrv.after('subscribe', async (res, req) => {
         const { tenant } = req.data
         let subdomain
         try {
@@ -98,9 +97,8 @@ class EnterpriseMessaging extends AMQPWebhookMessaging {
         }
         const management = await this.getManagement(subdomain).waitUntilReady()
         await management.deploy()
-        return res
       })
-      deploymentSrv.on('unsubscribe', async (req, next) => {
+      deploymentSrv.before('unsubscribe', async req => {
         const { tenant } = req.data
         let subdomain
         try {
@@ -110,14 +108,12 @@ class EnterpriseMessaging extends AMQPWebhookMessaging {
           this.LOG.error("'unsubscribe' is not yet implemented for @sap/cds-mtxs")
           throw e
         }
-        const res = await next()
         try {
           const management = await this.getManagement(subdomain).waitUntilReady()
           await management.undeploy()
         } catch (error) {
           this.LOG.error('Failed to delete messaging artifacts for subdomain', subdomain, '(', error, ')')
         }
-        return res
       })
     })
     provisioningSrv.impl(() => {

package/libx/_runtime/messaging/file-based.js

@@ -71,8 +71,7 @@ class FileBasedMessaging extends MessagingService {
         unlock(this.file)
       }
     }
-    this.watching = setInterval(watcher, this.options.interval || 500)
-    cds.on('shutdown', () => this.disconnect())
+    this.watching = setInterval(watcher, this.options.interval || 500).unref()
   }
 
   disconnect() {

package/libx/_runtime/messaging/outbox/OutboxRunner.js

@@ -50,7 +50,7 @@ class OutboxRunner {
     const timer = setTimeout(() => {
       this._setStateProp(SCHEDULED, undefined, { name, tenant })
       return cb()
-    }, waitingTime)
+    }, waitingTime).unref()
     this._setStateProp(SCHEDULED, timer, { name, tenant })
   }
 

package/libx/_runtime/messaging/outbox/utils.js

@@ -201,7 +201,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
       }
     }, config)
     spawn.on('done', () => {
-      if (letAppCrash) process.exit(1)
+      if (letAppCrash) cds.exit(1)
       outboxRunner.end({ name, tenant }, () => processMessages(service, tenant, opts))
     })
   })

package/libx/_runtime/messaging/service.js

@@ -4,7 +4,6 @@ const OutboxService = require('./Outbox')
 const ExtendedModels = require('../../../lib/srv/srv-models')
 
 const appId = require('./common-utils/appId')
-const { context } = require('../../../lib/core/classes')
 
 const _topic = declared => declared['@topic'] || declared.name
 

package/libx/_runtime/remote/Service.js

@@ -291,4 +291,5 @@ class RemoteService extends cds.Service {
   }
 }
 
+RemoteService.prototype.isExternal = true
 module.exports = RemoteService

package/libx/_runtime/sqlite/convertDraftAdminPathExpression.js

@@ -9,7 +9,7 @@ function sqliteConvertDraftAdminPathExpression(req) {
     return
   let hasDraftAdminPathExpression = false
 
-  const alias = req.query.SELECT.from.as
+  const tableId = req.query.SELECT.from.as || req.query.SELECT.from.ref[0]
 
   const _modifyCols = cols => {
     return cols.map(col => {
@@ -19,7 +19,7 @@ function sqliteConvertDraftAdminPathExpression(req) {
         newCol.ref = [...col.ref]
         newCol.ref[0] = 'filterAdmin'
         return newCol
-      } else if (col.ref?.length > 1 && alias && col.ref[0] === alias && col.ref[1] === 'DraftAdministrativeData') {
+      } else if (col.ref?.length > 1 && tableId && col.ref[0] === tableId && col.ref[1] === 'DraftAdministrativeData') {
         hasDraftAdminPathExpression = true
         const newCol = { ...col }
         newCol.ref = [...col.ref]
@@ -40,15 +40,31 @@ function sqliteConvertDraftAdminPathExpression(req) {
 
   if (clone.SELECT.columns) clone.SELECT.columns = _modifyCols(req.query.SELECT.columns)
   if (clone.SELECT.where) clone.SELECT.where = _modifyCols(req.query.SELECT.where)
+  if (clone.SELECT.orderBy) clone.SELECT.orderBy = _modifyCols(req.query.SELECT.orderBy)
+  if (clone.SELECT.groupBy) clone.SELECT.groupBy = _modifyCols(req.query.SELECT.groupBy)
+
+  const _addTableId = c => {
+    if (!c.ref || c.ref[0] === tableId || c.ref[0] === 'filterAdmin') return c
+    const newC = { ...c }
+    newC.ref = [...c.ref]
+    newC.ref.unshift(tableId)
+    return newC
+  }
 
   if (hasDraftAdminPathExpression) {
     clone
       .join('DRAFT_DraftAdministrativeData', 'filterAdmin')
       .on([
-        { ref: alias ? [alias, 'DraftAdministrativeData_DraftUUID'] : ['DraftAdministrativeData_DraftUUID'] },
+        { ref: tableId ? [tableId, 'DraftAdministrativeData_DraftUUID'] : ['DraftAdministrativeData_DraftUUID'] },
         '=',
         { ref: ['filterAdmin', 'DraftUUID'] }
       ])
+    if (tableId) {
+      if (clone.SELECT.columns) clone.SELECT.columns = clone.SELECT.columns.map(_addTableId)
+      if (clone.SELECT.where) clone.SELECT.where = clone.SELECT.where.map(_addTableId)
+      if (clone.SELECT.orderBy) clone.SELECT.orderBy = clone.SELECT.orderBy.map(_addTableId)
+      if (clone.SELECT.groupBy) clone.SELECT.groupBy = clone.SELECT.groupBy.map(_addTableId)
+    }
     req.query = clone
   }
 }

package/libx/_runtime/sqlite/customBuilder/CustomExpressionBuilder.js

@@ -1,24 +1,6 @@
 const ExpressionBuilder = require('../../db/sql-builder').ExpressionBuilder
 
 class CustomExpressionBuilder extends ExpressionBuilder {
-  get ReferenceBuilder() {
-    const ReferenceBuilder = require('./CustomReferenceBuilder')
-    Object.defineProperty(this, 'ReferenceBuilder', { value: ReferenceBuilder })
-    return ReferenceBuilder
-  }
-
-  get SelectBuilder() {
-    const SelectBuilder = require('./CustomSelectBuilder')
-    Object.defineProperty(this, 'SelectBuilder', { value: SelectBuilder })
-    return SelectBuilder
-  }
-
-  get FunctionBuilder() {
-    const FunctionBuilder = require('./CustomFunctionBuilder')
-    Object.defineProperty(this, 'FunctionBuilder', { value: FunctionBuilder })
-    return FunctionBuilder
-  }
-
   _addListToOutputObj(list) {
     this._outputObj.sql.push('(')
 

package/libx/_runtime/sqlite/customBuilder/CustomFunctionBuilder.js

@@ -14,24 +14,6 @@ const STANDAD_FUNCTIONS_MAP = ['locate', 'substring', 'to_date', 'to_time'].redu
 }, {})
 
 class CustomFunctionBuilder extends FunctionBuilder {
-  get ExpressionBuilder() {
-    const ExpressionBuilder = require('./CustomExpressionBuilder')
-    Object.defineProperty(this, 'ExpressionBuilder', { value: ExpressionBuilder })
-    return ExpressionBuilder
-  }
-
-  get ReferenceBuilder() {
-    const ReferenceBuilder = require('./CustomReferenceBuilder')
-    Object.defineProperty(this, 'ReferenceBuilder', { value: ReferenceBuilder })
-    return ReferenceBuilder
-  }
-
-  get SelectBuilder() {
-    const SelectBuilder = require('./CustomSelectBuilder')
-    Object.defineProperty(this, 'SelectBuilder', { value: SelectBuilder })
-    return SelectBuilder
-  }
-
   _handleFunction() {
     const functionName = this._functionName()
     const args = this._functionArgs()

package/libx/_runtime/sqlite/customBuilder/CustomSelectBuilder.js

@@ -1,30 +1,6 @@
 const SelectBuilder = require('../../db/sql-builder').SelectBuilder
 
 class CustomSelectBuilder extends SelectBuilder {
-  get ReferenceBuilder() {
-    const ReferenceBuilder = require('./CustomReferenceBuilder')
-    Object.defineProperty(this, 'ReferenceBuilder', { value: ReferenceBuilder })
-    return ReferenceBuilder
-  }
-
-  get ExpressionBuilder() {
-    const ExpressionBuilder = require('./CustomExpressionBuilder')
-    Object.defineProperty(this, 'ExpressionBuilder', { value: ExpressionBuilder })
-    return ExpressionBuilder
-  }
-
-  get FunctionBuilder() {
-    const FunctionBuilder = require('./CustomFunctionBuilder')
-    Object.defineProperty(this, 'FunctionBuilder', { value: FunctionBuilder })
-    return FunctionBuilder
-  }
-
-  get SelectBuilder() {
-    const SelectBuilder = require('./CustomSelectBuilder')
-    Object.defineProperty(this, 'SelectBuilder', { value: SelectBuilder })
-    return SelectBuilder
-  }
-
   getCollate() {
     return 'COLLATE ' + this.getCollatingSequence()
   }

package/libx/_runtime/sqlite/customBuilder/CustomUpsertBuilder.js

@@ -27,7 +27,8 @@ class CustomUpsertBuilder extends InsertBuilder {
 
     columns.forEach(col => {
       const col_ = col.replace(/\./g, '_')
-      if (!keys.includes(col_)) updates.push(`${col_}=excluded.${col_}`)
+      const sqlColumn = this._quoteElement(col_)
+      if (!keys.includes(col_)) updates.push(`${sqlColumn}=excluded.${sqlColumn}`)
     })
     const conflict = updates.length
       ? ` ON CONFLICT(${keys}) DO UPDATE SET ` + updates.join(', ')

package/libx/_runtime/sqlite/customBuilder/index.js

@@ -1,34 +1,49 @@
-const dependencies = {
-  get DeleteBuilder() {
-    const CustomDeleteBuilder = require('./CustomDeleteBuilder')
-    Object.defineProperty(dependencies, 'DeleteBuilder', { value: CustomDeleteBuilder })
-    return CustomDeleteBuilder
-  },
-  get ExpressionBuilder() {
-    const CustomExpressionBuilder = require('./CustomExpressionBuilder')
-    Object.defineProperty(dependencies, 'ExpressionBuilder', { value: CustomExpressionBuilder })
-    return CustomExpressionBuilder
-  },
-  get SelectBuilder() {
-    const CustomSelectBuilder = require('./CustomSelectBuilder')
-    Object.defineProperty(dependencies, 'SelectBuilder', { value: CustomSelectBuilder })
-    return CustomSelectBuilder
-  },
-  get ReferenceBuilder() {
-    const CustomReferenceBuilder = require('./CustomReferenceBuilder')
-    Object.defineProperty(dependencies, 'ReferenceBuilder', { value: CustomReferenceBuilder })
-    return CustomReferenceBuilder
-  },
-  get UpdateBuilder() {
-    const CustomUpdateBuilder = require('./CustomUpdateBuilder')
-    Object.defineProperty(dependencies, 'UpdateBuilder', { value: CustomUpdateBuilder })
-    return CustomUpdateBuilder
-  },
-  get UpsertBuilder() {
-    const CustomUpsertBuilder = require('./CustomUpsertBuilder')
-    Object.defineProperty(dependencies, 'UpsertBuilder', { value: CustomUpsertBuilder })
-    return CustomUpsertBuilder
-  }
+class ReferenceBuilder extends require('../../db/sql-builder').ReferenceBuilder {}
+const ExpressionBuilder = require('./CustomExpressionBuilder')
+const FunctionBuilder = require('./CustomFunctionBuilder')
+const SelectBuilder = require('./CustomSelectBuilder')
+const UpsertBuilder = require('./CustomUpsertBuilder')
+class UpdateBuilder extends require('../../db/sql-builder').UpdateBuilder {}
+class DeleteBuilder extends require('../../db/sql-builder').DeleteBuilder {}
+
+module.exports = {
+  ReferenceBuilder: extend(ReferenceBuilder).with({
+    FunctionBuilder
+  }),
+  ExpressionBuilder: extend(ExpressionBuilder).with({
+    ReferenceBuilder,
+    SelectBuilder,
+    FunctionBuilder
+  }),
+  FunctionBuilder: extend(FunctionBuilder).with({
+    ExpressionBuilder,
+    ReferenceBuilder,
+    SelectBuilder
+  }),
+  SelectBuilder: extend(SelectBuilder).with({
+    ExpressionBuilder,
+    ReferenceBuilder,
+    FunctionBuilder,
+    SelectBuilder
+  }),
+  UpsertBuilder,
+  UpdateBuilder: extend(UpdateBuilder).with({
+    ReferenceBuilder,
+    ExpressionBuilder
+  }),
+  DeleteBuilder: extend(DeleteBuilder).with({
+    ReferenceBuilder,
+    ExpressionBuilder
+  })
 }
 
-module.exports = dependencies
+function extend(clazz) {
+  return {
+    with(properties) {
+      for (let p in properties) {
+        Object.defineProperty(clazz.prototype, p, { value: properties[p] })
+      }
+      return clazz
+    }
+  }
+}

package/libx/odata/afterburner.js

@@ -189,7 +189,7 @@ function _convertVal(element, value) {
   }
 }
 
-function _processSegments(from, model, namespace) {
+function _processSegments(from, model, namespace, cqn) {
   const { ref } = from
 
   let current = model
@@ -284,11 +284,14 @@ function _processSegments(from, model, namespace) {
         incompleteKeys = ref[i].where ? false : i === ref.length - 1 || one ? false : true
 
         if (incompleteKeys && action) {
-          if (action['@cds.odata.bindingparameter.collection']) {
+          if (
+            action['@cds.odata.bindingparameter.collection'] ||
+            (action.params && Object.values(action.params).some(e => e?.items?.type === '$self'))
+          ) {
             incompleteKeys = false
           } else {
-            const msg = `Bound operations are not supported on entity collections.`
-            throw Object.assign(new Error(msg), { statusCode: 501 })
+            const msg = `"${action.name}" must be called on a single instance of "${current.name}".`
+            throw Object.assign(new Error(msg), { statusCode: 400 })
           }
         }
 
@@ -326,12 +329,24 @@ function _processSegments(from, model, namespace) {
           _resolveAliasesInXpr(ref[i].where, current)
           _processWhere(ref[i].where, current)
         }
-      } else if (current._isStructured) {
-        // > nested property
-        one = true
       } else {
         // > property
+        // we do not support navigations from properties yet
         one = true
+        // if the last segment is a property, it must be removed and pushed to columns
+        target = target || _getDefinition(model, ref[0].id, namespace)
+        if (Object.keys(target.elements).includes(current.name)) {
+          if (!cqn.SELECT.columns) cqn.SELECT.columns = []
+          cqn.SELECT.columns.push({ ref: ref.slice(i) })
+          // we need the keys to generate the correct @odata.context
+          for (const key in target.keys || {}) {
+            if (key !== 'IsActiveEntity' && !cqn.SELECT.columns.some(c => c.ref?.[0] === key))
+              cqn.SELECT.columns.push({ ref: [key] })
+          }
+          Object.defineProperty(cqn, '_propertyAccess', { value: current.name, enumerable: false })
+          from.ref.splice(i)
+          break
+        }
       }
     }
   }
@@ -452,7 +467,7 @@ function _4service(service) {
     /*
      * key vs. path segments (/Books/1/author/books/2/...) and more
      */
-    const { one, current, target } = _processSegments(from, model, namespace)
+    const { one, current, target } = _processSegments(from, model, namespace, cqn)
 
     if (cqn.SELECT.where) {
       _processWhere(cqn.SELECT.where, root)

package/libx/odata/cqn2odata.js

@@ -318,7 +318,7 @@ const _parseColumnsV2 = (columns, prefix = []) => {
     }
 
     if (column === '*') {
-      select.push(encodeURIComponent(`${prefix.join('/')}/*`))
+      select.push(encodeURIComponent(prefix.length ? `${prefix.join('/')}/*` : '*'))
     }
   }
 

package/libx/odata/grammar.pegjs

@@ -40,6 +40,7 @@
         const n = Number(str)
         return Number.isSafeInteger(n) ? n : str
       }
+    const skipToken = options.skipToken
     const standardBase64 =
       options.standardBase64 ||
       function (str) {
@@ -447,10 +448,8 @@
     = val:integer { return val }
 
   skiptoken
-    = val:integer? skiptoken:skiptokenChars? {
-      // REVISIT ignore non-numeric $skiptoken as not supported by CQN
-      if (skiptoken) return
-      _setLimitOffset(val)
+    = skiptoken:skiptokenChars? {
+      skipToken(skiptoken, { SELECT })
     }
 
   skip

package/libx/odata/index.js

@@ -1,4 +1,5 @@
-const cds = require('../_runtime/cds'), { decodeURIComponent } = cds.utils
+const cds = require('../_runtime/cds'),
+  { decodeURIComponent } = cds.utils
 const { SELECT } = cds.ql
 
 const odata2cqn = require('./parser').parse
@@ -51,6 +52,8 @@ const enhanceCqn = (cqn, options) => {
   // REVISIT: _target vs __target, i.e., pseudo csn vs actual csn
   // DO NOT USE __target outside of libx/rest!!!
   if (cqn.__target) query.__target = cqn.__target
+  if (cqn._propertyAccess)
+    Object.defineProperty(query, '_propertyAccess', { value: cqn._propertyAccess, enumerable: false })
   return query
 }
 
@@ -69,6 +72,7 @@ module.exports = {
     options = options === 'strict' ? { strict } : options.strict ? { ...options, strict } : options
     if (options.service) Object.assign(options, { minimal: true, afterburner: afterburner.for(options.service) })
     options.safeNumber = safeNumber
+    options.skipToken = require('./utils').skipToken
 
     let cqn
     try {

package/libx/odata/parseToCqn.js

@@ -24,10 +24,10 @@ module.exports = (component, service, target, data, odataReq, upsert) => {
       if (!one) cds.error('DELETE not allowed on collection', { code: 400 })
 
       // eslint-disable-next-line no-case-declarations
-      const last = _target.ref && _target.ref[_target.ref.length - 1]
-      if (target.elements[last]) {
+      const last = query._propertyAccess || (_target.ref && _target.ref[_target.ref.length - 1])
+      if (target.elements[last] || target.elements[query._propertyAccess]) {
         // delete simple property
-        const ref = { ref: _target.ref.slice(0, -1) }
+        const ref = { ref: query._propertyAccess ? _target.ref : _target.ref.slice(0, -1) }
         return UPDATE(ref).data({ [last]: null })
       } else {
         return DELETE.from(_target)