@sap/cds 6.0.2 → 6.1.0

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/action.js

@@ -7,16 +7,16 @@ const {
 } = require('../okra/odata-server')
 
 const { getSapMessages } = require('../../../../common/error/frontend')
-const { getActionOrFunctionReturnType } = require('../utils/handlerUtils')
+const { getActionOrFunctionReturnType, isReturnMinimal } = require('../utils/handlerUtils')
 const { validateResourcePath } = require('../utils/request')
 const { toODataResult, postProcess } = require('../utils/result')
-const { DRAFT_MOD_EVENTS } = require('../../../../common/constants/events')
+const { DRAFT_EVENTS } = require('../../../../common/constants/events')
 const { readAfterWrite } = require('../utils/readAfterWrite')
 
 const _postProcess = async (req, odataReq, odataRes, tx, result) => {
   const returnType = getActionOrFunctionReturnType(odataReq.getUriInfo().getPathSegments(), tx.model.definitions)
   // as of spec meeting: no generic support of $select/$expand for custom actions/functions
-  if (returnType && returnType.kind === 'entity' && req.event in DRAFT_MOD_EVENTS) {
+  if (returnType && returnType.kind === 'entity' && (req.event in DRAFT_EVENTS || req.event === 'EDIT')) {
     result = await readAfterWrite(req, tx, { operation: { result, returnType } })
     if (result && !('IsActiveEntity' in result)) result.IsActiveEntity = req.event === 'draftActivate'
   }
@@ -59,13 +59,25 @@ const action = service => {
       } else {
         await tx.commit(result)
       }
+
+      if (isReturnMinimal(req) || result === null) odataRes.setStatusCode(204)
+      else if (req.event === 'draftActivate' || req.event === 'EDIT') {
+        odataRes.setStatusCode(201)
+        const keys = Object.keys(req.target.keys).filter(k => {
+          return k !== 'IsActiveEntity' && !req.target.keys[k]._isAssociationStrict
+        })
+        const keysString = keys.map(key => `${key}=${result[key]}`).join(',')
+        odataRes.setHeader(
+          'location',
+          `../${req.target.name.replace(`${service.name}.`, '')}(${keysString},IsActiveEntity=${
+            req.event === 'draftActivate'
+          })`
+        )
+      }
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/create.js

@@ -38,15 +38,15 @@ const create = service => {
     try {
       result = await tx.dispatch(req)
 
-      // REVISIT: Return post processing once we implement srv read after write
+      // REVISIT:
+      // Performance: For `isReturnMinimal` it's enough to just read the etag.
+      // Note: Without read access, one cannot return the etag.
+      if (req._.readAfterWrite) {
+        result = await readAfterWrite(req, service, { operation: { result } })
+      }
       if (isReturnMinimal(req)) {
         result = postProcessMinimal(req, service, result)
       } else {
-        // REVISIT: find better solution
-        if (req._.readAfterWrite) {
-          result = await readAfterWrite(req, service)
-        }
-
         postProcess(req, odataRes, service, result)
       }
 
@@ -57,16 +57,13 @@ const create = service => {
         await tx.commit(result)
       }
 
-      if (isReturnMinimal(req)) {
+      if (isReturnMinimal(req) || result === null) {
         odataRes.setStatusCode(204)
       }
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/delete.js

@@ -44,10 +44,7 @@ const del = service => {
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/error.js

@@ -114,13 +114,13 @@ const getErrorHandler = (crashOnError = true, srv) => {
 
     // invoke srv.on('error', function (err, req) { ... }) here in special situations
     // REVISIT: if for compat reasons, remove once cds^5.1
-    if (srv._handlers._error) {
+    if (srv._handlers._error.length) {
       let ctx = cds.context
       if (!ctx) {
         // > error before req was dispatched
         ctx = new cds.Request({ req, res: req.res, user: req.user || new cds.User.Anonymous() })
         for (const each of srv._handlers._error) each.handler.call(srv, err, ctx)
-      } else if (err.getRootCause) {
+      } else {
         // > error after req was dispatched, e.g., serialization error in okra
         for (const each of srv._handlers._error) each.handler.call(srv, err, ctx)
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/metadata.js

@@ -5,10 +5,6 @@ const { toODataResult } = require('../utils/result')
 const { normalizeError } = require('../../../../common/error/frontend')
 const getError = require('../../../../common/error')
 
-const _getMetadata4Tenant = async (tenant, locale, service) => {
-  return await cds.mtx.getEdmx(tenant, service.name, locale)
-}
-
 /**
  * Provide localized metadata handler.
  *
@@ -23,21 +19,12 @@ const metadata = service => {
     const locale = odataRes.getContract().getLocale()
 
     try {
-      let edmx
-
-      if (cds.mtx && service._isExtended) {
-        edmx = await _getMetadata4Tenant(tenant, locale, service)
-      }
-
-      if (!edmx) {
-        edmx = cds.localize(
-          service.model,
-          locale,
-          // REVISIT: we could cache this in a weak map
-          cds.compile.to.edmx(service.model, { service: service.definition.name })
-        )
-      }
-
+      let edmx = cds.localize(
+        service.model,
+        locale,
+        // REVISIT: we could cache this in model._cached
+        cds.compile.to.edmx(service.model, { service: service.definition.name })
+      )
       return next(null, toODataResult(edmx))
     } catch (e) {
       if (LOG._error) {

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/read.js

@@ -484,10 +484,7 @@ const read = service => {
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/request.js

@@ -6,7 +6,7 @@ module.exports = srv => {
   const requires = getRequiresAsArray(srv.definition)
   const restricted = isRestricted(srv)
 
-  return (odataReq, odataRes, next) => {
+  return function ODataRequestHandler(odataReq, odataRes, next) {
     const req = odataReq.getBatchApplicationData()
       ? odataReq.getBatchApplicationData().req
       : odataReq.getIncomingRequest()
@@ -51,7 +51,7 @@ module.exports = srv => {
         })
       }
 
-      odataReq.setApplicationData({ req })
+      odataReq.setApplicationData({ req, res })
     }
 
     next()

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/update.js

@@ -149,12 +149,13 @@ const update = service => {
       // try UPDATE and, on 404 error, try CREATE
       ;[result, req] = await _updateThenCreate(req, odataReq, odataRes, tx)
 
+      if (!primitive && req._.readAfterWrite) {
+        // REVISIT:
+        // Performance: For `isReturnMinimal` it's enough to just read the etag.
+        // Note: Without read access, one cannot return the etag.
+        result = await readAfterWrite(req, service, { operation: { result } })
+      }
       if (!isReturnMinimal(req)) {
-        // REVISIT: find better solution
-        if (!primitive && req._.readAfterWrite) {
-          result = await readAfterWrite(req, service)
-        }
-
         postProcess(req, odataRes, service, result, previousResult)
       } else {
         result = postProcessMinimal(req, service, result)
@@ -167,16 +168,13 @@ const update = service => {
         await tx.commit(result)
       }
 
-      if (isReturnMinimal(req)) {
+      if (isReturnMinimal(req) || result === null) {
         odataRes.setStatusCode(204)
       }
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/to.js

@@ -1,7 +1,41 @@
-const Dispatcher = require('./Dispatcher')
+const { alias2ref } = require('../../../common/utils/csn') // REVISIT: eliminate that
+const cds = require('../../../cds')
+const OData = require('./OData')
 
-const to = service => {
-  return new Dispatcher(service).getService()
+/**
+ * This is the express handler for a specific OData endpoint.
+ * Note: the same service can be served at different endpoints.
+ */
+module.exports = srv => {
+  const okra = new OkraAdapter(srv)
+  return okra.process.bind(okra)
 }
 
-module.exports = to
+function OkraAdapter(srv, model = srv.model) {
+  const edm = cds.compile.to.edm(model, { service: srv.definition?.name || srv.name })
+  alias2ref(srv, edm) // REVISIT: eliminate that -> done again and again -> search for _alias2ref
+  return new OData(edm, model, srv.options).addCDSServiceToChannel(srv)
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  REVISIT: Move to ExtensibilityService
+//
+if (cds.mtx || cds.requires.extensibility || cds.requires.toggles)
+  module.exports = srv => {
+    const id = `${++unique} - ${srv.path}` // REVISIT: this is to allow running multiple express apps serving same endpoints, as done by some questionable tests
+    return function ODataAdapter(req, res) {
+      const model = cds.context?.model || srv.model
+      if (!model._cached) Object.defineProperty(model, '_cached', { value: {} })
+
+      // Note: cache is attached to model cache so they get disposed when models are evicted from cache
+      let adapters = model._cached._odata_adapters || (model._cached._odata_adapters = {})
+      let okra = adapters[id]
+      if (!okra) {
+        const _srv = { __proto__: srv, _real_srv: srv, model } // REVISIT: we need to do that better in new adapters
+        okra = adapters[id] = new OkraAdapter(_srv, model)
+      }
+      return okra.process(req, res)
+    }
+  }
+let unique = 0

package/libx/_runtime/cds-services/adapter/odata-v4/utils/handlerUtils.js

@@ -16,9 +16,7 @@ const _keysOf = (row, target) => {
   if (!keyElements.length) return
   const keys = {}
   for (const key of keyElements) {
-    if (key._isAssociationStrict || key.name in DRAFT_COLUMNS_MAP) {
-      continue
-    }
+    if (key._isAssociationStrict) continue
     keys[key.name] = key.elements ? { val: JSON.stringify(row[key.name]) } : row[key.name]
   }
   return keys
@@ -111,10 +109,8 @@ const _getColumns = (target, data, prefix = []) => {
  * (depth determined by req.data)
  */
 const getDeepSelect = req => {
-  // REVISIT: Why do we do such expensive deep reads after write at all ???
-  const { target, data } = req
+  let { target, data } = req
   const columns = _getColumns(target, data)
-
   return getSimpleSelectCQN(target, data, columns)
 }
 

package/libx/_runtime/cds-services/adapter/odata-v4/utils/readAfterWrite.js

@@ -1,3 +1,4 @@
+const { removeDraftUUIDIfNecessary } = require('../../../../fiori/utils/handler')
 const cds = require('../../../../cds')
 const {
   Request,
@@ -8,7 +9,7 @@ const { normalizeError } = require('../../../../common/error/frontend')
 
 const { getDeepSelect, getSimpleSelectCQN } = require('./handlerUtils')
 const { hasDeepUpdate } = require('../../../../common/composition/update')
-const { WRITE_EVENTS, CDS_EVENTS, DRAFT_MOD_EVENTS } = require('../../../../common/constants/events')
+const { WRITE_EVENTS, CDS_EVENTS } = require('../../../../common/constants/events')
 
 const setLocationHeader = (req, { model }) => {
   const { odataRes } = req._
@@ -21,10 +22,8 @@ const _isNoAccessError = e => Number(e.code) === 403 || Number(e.code) === 401
 const _isNotFoundError = e => Number(e.code) === 404
 const _isEntityNotReadableError = e => Number(e.code) === 405
 
-const _handleReadError = (err, req) => {
+const _handleReadError = err => {
   if (!(_isNoAccessError(err) || _isEntityNotReadableError(err) || _isNotFoundError(err))) throw err
-  const log = Object.assign(err, { level: 'ERROR', message: normalizeError(err, req).error.message })
-  process.env.NODE_ENV !== 'production' && LOG._warn && LOG.warn(log)
 }
 
 const _getOperationQueryColumns = urlQueryOptions => {
@@ -38,7 +37,7 @@ const _getOperationQueryColumns = urlQueryOptions => {
   return columns
 }
 
-const _isDraftAction = req => req.event in DRAFT_MOD_EVENTS
+const _isDraftAction = req => req.event in { draftActivate: 1, EDIT: 1, draftPrepare: 1 }
 const _isActionOrFunction = req => !(req.event in CDS_EVENTS) || _isDraftAction(req)
 const _isWriteWithResponse = req => req.event in WRITE_EVENTS && !(req.event in { CANCEL: 1, DELETE: 1 })
 
@@ -49,6 +48,9 @@ const readAfterWrite = async (req, srv, { operation, isBefore } = { isBefore: fa
     const { result, returnType } = operation
     query = getSimpleSelectCQN(returnType, result, _getOperationQueryColumns(req._queryOptions))
     if (_isDraftAction(req)) query.where({ IsActiveEntity: req.event === 'draftActivate' })
+  } else if (req.event === 'NEW' || req.event === 'PATCH') {
+    const { result } = operation
+    query = getSimpleSelectCQN(req.target, result)
   } else if (req.event === 'UPDATE' && !hasDeepUpdate(srv.model, req.query)) {
     query = Array.isArray(req.data) ? SELECT.from(req.query.UPDATE.entity) : SELECT.one(req.query.UPDATE.entity)
   } else {
@@ -60,6 +62,7 @@ const readAfterWrite = async (req, srv, { operation, isBefore } = { isBefore: fa
   try {
     const _req = new Request({ query, event: 'READ', _: req._ })
     result = await srv.dispatch(_req)
+    if (result && req.target._isDraftEnabled) removeDraftUUIDIfNecessary(req)(result)
     if (result === null && !isBefore && (_isWriteWithResponse(req) || _isDraftAction(req))) {
       // > something must be written and no READ error <=> @restrict or static where
       _req.reject({

package/libx/_runtime/cds-services/services/utils/differ.js

@@ -18,6 +18,10 @@ module.exports = class Differ {
   _createSelectColumnsForDelete(entity) {
     const columns = []
     for (const element of Object.values(entity.elements)) {
+      // Don't take into account virtual or computed properties to make the diff result
+      // consistent with the ones for UPDATE/CREATE (where we don't have access to that
+      // information).
+      if (!element.key && (element.virtual || element['@Core.Computed'])) continue
       if (element.isComposition) {
         if (element._target._hasPersistenceSkip) continue
         columns.push({

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

@@ -9,35 +9,7 @@ const getFeatureNotSupportedError = message => {
   return getError(501, `Feature is not supported: ${message}`)
 }
 
-const getAuditLogNotWrittenError = (rootCauseError, phase, event) => {
-  const errorMessage =
-    !phase || event === 'READ' ? 'Audit log could not be written' : `Audit log could not be written ${phase}`
-  const error = new Error(errorMessage)
-  error.rootCause = rootCauseError
-  return error
-}
-
-const hasBeenCalledError = (method, query) => {
-  return new Error(`Method ${method} has been called before. Invalid CQN: ${JSON.stringify(query)}`)
-}
-
-const unexpectedFunctionCallError = (functionName, expectedFunction) => {
-  return new Error(`Cannot build CQN object. Invalid call of "${functionName}" before "${expectedFunction}"`)
-}
-
-const invalidFunctionArgumentError = (statement, arg) => {
-  const details = JSON.stringify(arg, (key, value) => (value === undefined ? '__undefined__' : value)).replace(
-    /"__undefined__"/g,
-    'undefined'
-  )
-  return new Error(`Cannot build ${statement} statement. Invalid data provided: ${details}`)
-}
-
 module.exports = {
   getModelNotDefinedError,
-  getFeatureNotSupportedError,
-  getAuditLogNotWrittenError,
-  hasBeenCalledError,
-  unexpectedFunctionCallError,
-  invalidFunctionArgumentError
+  getFeatureNotSupportedError
 }

package/libx/_runtime/common/constants/events.js

@@ -2,7 +2,6 @@ const MOD_EVENTS = { UPDATE: 1, DELETE: 1, EDIT: 1 }
 const WRITE_EVENTS = Object.assign({ CREATE: 1, NEW: 1, PATCH: 1, CANCEL: 1 }, MOD_EVENTS)
 const CRUD_EVENTS = Object.assign({ READ: 1 }, WRITE_EVENTS)
 const DRAFT_EVENTS = { PATCH: 1, CANCEL: 1, draftActivate: 1, draftPrepare: 1 }
-const DRAFT_MOD_EVENTS = { draftActivate: 1, EDIT: 1 }
 const CDS_EVENTS = Object.assign({}, CRUD_EVENTS, DRAFT_EVENTS)
 
 module.exports = {
@@ -10,6 +9,5 @@ module.exports = {
   WRITE_EVENTS,
   CRUD_EVENTS,
   DRAFT_EVENTS,
-  CDS_EVENTS,
-  DRAFT_MOD_EVENTS
+  CDS_EVENTS
 }

package/libx/_runtime/common/i18n/messages.properties

@@ -74,8 +74,9 @@ ENTITY_IS_NOT_CRUD=Entity "{0}" is not {1}
 ENTITY_IS_NOT_CRUD_VIA_NAVIGATION=Entity "{0}" is not {1} via navigation "{2}"
 ENTITY_IS_AUTOEXPOSED=Entity "{0}" is not explicitly exposed as part of the service
 EXPAND_IS_RESTRICTED=Navigation property "{0}" is not allowed for expand operation
-EXPAND_COUNT_UNSUPPORTED="$count" is not supported for expand operation
+EXPAND_COUNT_UNSUPPORTED="/$count" is not supported for expand operation
 ORDERBY_LAMBDA_UNSUPPORTED="$orderby" does not support lambda
+EXPAND_APPLY_UNSUPPORTED="$apply" is not supported for expand operation
 
 # rest protocol adapter
 INVALID_RESOURCE="{0}" is not a valid resource

package/libx/_runtime/common/perf/index.js

@@ -4,21 +4,16 @@ const _statisticsRequested = req =>
   (req.query && req.query['sap-statistics'] === 'true') ||
   (req.headers && req.headers['sap-statistics'] === 'true' && (!req.query || !req.query['sap-statistics']))
 
-module.exports = app => {
-  if (app._perf_measured) return
-  else app._perf_measured = true
+module.exports = function sap_statistics(req, res, next) {
+  if (!_statisticsRequested(req)) return next()
 
-  app.use((req, res, next) => {
-    if (!_statisticsRequested(req)) return next()
+  const t0 = performance.now()
+  const { writeHead } = res
+  res.writeHead = function (...args) {
+    const total = Number((performance.now() - t0) / 1000).toFixed(2)
+    if (res.statusCode < 400) res.setHeader('sap-statistics', `total=${total}`)
+    writeHead.call(this, ...args)
+  }
 
-    const t0 = performance.now()
-    const { writeHead } = res
-    res.writeHead = function (...args) {
-      const total = Number((performance.now() - t0) / 1000).toFixed(2)
-      if (res.statusCode < 400) res.setHeader('sap-statistics', `total=${total}`)
-      writeHead.call(this, ...args)
-    }
-
-    next()
-  })
+  next()
 }

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

@@ -698,7 +698,6 @@ const _convertToOneEqNullInFilter = (query, target) => {
     }
   }
 }
-
 // eslint-disable-next-line complexity
 const _convertSelect = (query, model, _options) => {
   const _4db = _options.service instanceof cds.DatabaseService

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

@@ -1,25 +1,28 @@
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
-const traverseFroms = (cqn, cb) => {
+const traverseFroms = (cqn, cb, aliasForSet) => {
   while (cqn.SELECT) cqn = cqn.SELECT.from
 
   // Do the most likely first -> {ref}
   if (cqn.ref) {
-    return cb(cqn)
+    return cb(cqn, aliasForSet)
   }
 
   if (cqn.SET) {
-    return cqn.SET.args.map(a => traverseFroms(a, cb))
+    // if a union has an alias, we should use it for the columns we get out of the union
+    return cqn.SET.args.map(a => traverseFroms(a, cb, cqn.as))
   }
 
   if (cqn.join) {
-    return cqn.args.map(a => traverseFroms(a, cb))
+    return cqn.args.map(a => traverseFroms(a, cb, aliasForSet))
   }
 }
 
 const getEntityNameFromCQN = cqn => {
   const res = []
-  traverseFroms(cqn, from => res.push({ entityName: from.ref[0].id || from.ref[0], alias: from.as }))
+  traverseFroms(cqn, (from, aliasForSet) =>
+    res.push({ entityName: from.ref[0].id || from.ref[0], alias: aliasForSet || from.as })
+  )
   return res.length === 1 ? res[0] : res.find(n => n.entityName !== 'DRAFT.DraftAdministrativeData') || {}
 }
 

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

@@ -134,7 +134,7 @@ const getCache = (anything, cache, newCacheFn) => {
 }
 
 module.exports = (usecase, tx, target, ...args) => {
-  // get model first as it may be added to tx (cf. "_ensureModel")
+  // get model first as it may be added to tx (cf. "_ensureModel") // REVISIT: _ensureModel is gone
   const model = tx.model
   if (!model) return
 

package/libx/_runtime/db/Service.js

@@ -24,28 +24,16 @@ class DatabaseService extends cds.Service {
       this[`_${each}`] = generic[each]
     }
 
-    // REVISIT: ensures tenant-aware this.model if this is a transaction -> this should be fixed in mtx integration, not here
-    this._ensureModel = function (req) {
-      if (this.context) {
-        // if the tx was initiated in messaging, then this.context._model is not unfolded
-        //   -> use this.context._model._4odata if present
-        const { _model } = this.context
-        if (_model) this.model = _model._4odata || _model
-        else this.model = req._model
-      }
-    }
-    this._ensureModel._initial = true
-
     // REVISIT: how to generic handler registration?
   }
 
   /** Database services don't support custom-defined operations */
-  operations() {
+  get operations() {
     return []
   }
 
   /** Database services don't support custom-defined events */
-  events() {
+  get events() {
     return []
   }
 

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -12,6 +12,8 @@ const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 const { filterKeys } = require('../../fiori/utils/handler')
 
+const getError = require('../../common/error')
+
 // Symbols are used to add extra information in response structure
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
 const TO_MANY = Symbol.for('sap.cds.toMany')
@@ -94,6 +96,16 @@ class JoinCQNFromExpanded {
     return this._isDraft
   }
 
+  // There can be a limit/offset for the target entity.
+  // The current expand implementation applys a `DISTINCT` on
+  // `filterExpand`, which changes the sorting in absence of `ORDER BY`.
+  // Therefore, add an implicit `ORDER BY` in those cases.
+  _addImplicitOrderBy(cqn, entity, alias) {
+    if (cqn.orderBy || !cqn.limit || !entity) return // not needed
+    const orderByColumns = cqn.groupBy || getAllKeys(entity).map(key => ({ ref: [alias, key] }))
+    cqn.orderBy = orderByColumns
+  }
+
   /**
    * Build first level of expanding regarding to many and all to one if not part of a nested to many expand.
    *
@@ -123,6 +135,7 @@ class JoinCQNFromExpanded {
         })
       // expand to one
       const entity = this._csn.definitions[joinArgs[0].SELECT.from.SET.args[1].SELECT.from.ref[0]]
+      this._addImplicitOrderBy(readToOneCQN, entity, tableAlias)
       const givenColumns = readToOneCQN.columns
       readToOneCQN.columns = []
       this._expandedToFlat({ entity, givenColumns, readToOneCQN, tableAlias, toManyTree, defaultLanguage })
@@ -130,7 +143,7 @@ class JoinCQNFromExpanded {
       const table = unionTable || this._getRef(SELECT).table
       const isDraftTree = this._isDraftTree(table)
       const entity = this._getEntityForTable(table)
-
+      this._addImplicitOrderBy(readToOneCQN, entity, tableAlias)
       if (unionTable) readToOneCQN[IS_UNION_DRAFT] = true
 
       readToOneCQN[IS_ACTIVE] = isDraftTree ? this._isDraftTargetActive(table) : true
@@ -455,14 +468,10 @@ class JoinCQNFromExpanded {
 
     if (element.ref) {
       element.ref[1] = Object.assign({}, element.ref[1])
-      element.ref[1].args = element.ref[1].args.map(arg => {
-        return this._mapArg(arg, cqn, tableAlias)
-      })
+      element.ref[1].args = element.ref[1].args.map(arg => this._mapArg(arg, cqn, tableAlias))
     } else {
       element.args = element.args.slice(0)
-      element.args = element.args.map(arg => {
-        return this._mapArg(arg, cqn, tableAlias)
-      })
+      element.args = element.args.map(arg => this._mapArg(arg, cqn, tableAlias))
     }
   }
 
@@ -684,6 +693,17 @@ class JoinCQNFromExpanded {
         c => !expandedEntity.keys[c].isAssociation && !(c in DRAFT_COLUMNS_MAP)
       )
       const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
+
+      const assoc = entity.associations[column.ref[0]]
+      if (assoc.is2one && assoc.on) {
+        const onCond = expandedEntity._relations[assoc.name].join('target', 'source')
+        const xpr = onCond[0].xpr
+        const fks = (xpr && xpr.filter(e => e.ref && e.ref[0] === 'target').map(e => e.ref[1])) || []
+        for (const k of fks) {
+          if (!cols.includes(k)) cols.push(k)
+        }
+      }
+
       const unionFrom = getCQNUnionFrom(cols, expandedEntity.name, expandedEntity.name + '.drafts', ks, user)
       readToOneCQN.from.args[1] = {
         SELECT: {
@@ -1162,7 +1182,7 @@ class JoinCQNFromExpanded {
       cqn.orderBy = this._copyOrderBy(column.orderBy, tableAlias, expandedEntity)
     }
 
-    if (column.limit) cqn.limit = column.limit
+    if (column.limit) throw getError(501, 'Pagination is not supported in expand')
 
     cqn = this._adaptWhereOrderBy(cqn, tableAlias)
 
@@ -1227,23 +1247,6 @@ class JoinCQNFromExpanded {
     return assoc.target + '_drafts'
   }
 
-  _getLimitInSelect(cqn, columns, limit, orderBy, expandedEntity) {
-    const select = {
-      SELECT: {
-        columns: this._copyColumns(columns, 'limitFilter'),
-        from: { ref: [cqn.from.args[0].ref[0]], as: 'limitFilter' },
-        where: this._convertOnToWhere(cqn.from.on, cqn.from.args[0].as, 'limitFilter'),
-        limit: limit
-      }
-    }
-
-    if (orderBy) {
-      select.SELECT.orderBy = this._copyOrderBy(orderBy, 'limitFilter', expandedEntity)
-    }
-
-    return select
-  }
-
   _isPathExpressionToOne(ref, entity) {
     const ref0 = ref[0]
     const el = entity.elements[ref0]