@sap/cds 8.9.4 → 9.0.2

package/libx/odata/ODataAdapter.js

@@ -1,7 +1,16 @@
-const HttpAdapter = require('../../lib/srv/protocols/http')
 const cds = require('../../lib')
 const LOG = cds.log('odata')
 
+const HttpAdapter = require('../../lib/srv/protocols/http')
+const HttpRequest = require('../http/HttpRequest')
+const bodyParser4 = require('../http/body-parser')
+
+class ODataRequest extends HttpRequest {
+  get protocol() {
+    return 'odata'
+  }
+}
+
 const operation4 = require('./middleware/operation')
 const create4 = require('./middleware/create')
 const stream4 = require('./middleware/stream')
@@ -9,48 +18,17 @@ const read4 = require('./middleware/read')
 const update4 = require('./middleware/update')
 const delete4 = require('./middleware/delete')
 const error4 = require('./middleware/error')
-const bodyParser4 = require('./middleware/body-parser')
-
-// REVISIT: copied from lib/req/request.js
-const Http2Crud = { POST: 'CREATE', GET: 'READ', PUT: 'UPDATE', PATCH: 'UPDATE', DELETE: 'DELETE' }
 
 const { isStream } = require('./utils')
 
-class ODataAdapter extends HttpAdapter {
-  log(req) {
-    // REVISIT: this impl recreates the behavior of the old adapter, but is not very clean
-
-    // req.__proto__.method is set in case of upsert
-    if (req.__proto__.method in { PUT: 1, PATCH: 1 }) return // REVISIT: voodoo magic
+// REVISIT: copied from lib/req/request.js
+const Http2Crud = { POST: 'CREATE', GET: 'READ', PUT: 'UPDATE', PATCH: 'UPDATE', DELETE: 'DELETE' }
 
-    if (req._subrequest)
-      //> req._subrequest is set for batch subrequests
-      LOG._info && LOG.info('>', Http2Crud[req.method], req.path, Object.keys(req.query).length ? { ...req.query } : '')
-    else super.log(req)
+module.exports = class ODataAdapter extends HttpAdapter {
+  request4(args) {
+    return new ODataRequest(args)
   }
 
-  // early_access_check4(srv) { // REVISIT: let's remove that!
-  //   const super_early_access_check = super.early_access_check4(srv)
-  //   // REVISIT: We should remove the protectMetadata option in cds8, and always just do the right thing -> DOUBLE CHECK: Bad fiori behavior on 403ers
-  //   return function early_access_check(req, res, next) {
-  //     if (cds.env.odata.protectMetadata === false && (req.path === '/' || req.path === '/$metadata')) { // REVISIT: do that statically!
-  //       // > nothing to do
-  //       return next()
-  //     }
-
-  //     // REVISIT: Why exactly was that required?
-  //     // > It was wrong, as it requested a login for any service operation, even though only one action was restricted (submitOrder)
-  //     // we need to challenge in case of $batch requests if the service has restrictions
-  //     // const user = cds.context.user
-  //     // if (user._is_anonymous && req.path === '/$batch' && containsAnyRestrictions(srv)) {
-  //     //   if (!req._login) throw cds.error({ code: '401', statusCode: 401 })
-  //     //   return req._login()
-  //     // }
-
-  //     return super_early_access_check(req, res, next)
-  //   }
-  // }
-
   get router() {
     const jsonBodyParser = bodyParser4(this)
     return (
@@ -116,28 +94,16 @@ class ODataAdapter extends HttpAdapter {
     )
   }
 
-  request4(args) {
-    return new NoaRequest(args)
-  }
-}
-
-// REVISIT: ugly hack -> eliminate
-class NoaRequest extends cds.Request {
-  constructor(args) {
-    super(args)
-    this.req = args.req
-    this.res = args.res
-  }
+  // REVISIT: this impl recreates the behavior of the old adapter, but is not very clean
+  log(req) {
+    // req.__proto__.method is set in case of upsert
+    if (req.__proto__.method in { PUT: 1, PATCH: 1 }) return // REVISIT: voodoo magic
 
-  // REVISIT: all usages of .protocol are very bad style, violating modularization
-  get protocol() {
-    return 'odata'
-  }
-  // AFC uses unofficial req._queryOptions -> which is bad! -> should eliminate
-  get _queryOptions() {
-    cds.utils.deprecated({ kind: '', old: 'req._queryOptions', new: 'req._.req.query' })
-    return this.req?.query
+    if (req._subrequest) {
+      //> req._subrequest is set for batch subrequests
+      LOG._info && LOG.info('>', Http2Crud[req.method], req.path, Object.keys(req.query).length ? { ...req.query } : '')
+    } else {
+      super.log(req)
+    }
   }
 }
-
-module.exports = Object.assign(ODataAdapter, { NoaRequest })

package/libx/odata/index.js

@@ -1,15 +1,13 @@
 /** @typedef {import('../../lib/srv/cds.Service')} Service */
 
 const cds = require('../../')
-const { SELECT } = cds.ql
 const { decodeURIComponent } = cds.utils
 
 const odata2cqn = require('./parse/parser').parse
 const cqn2odata = require('./parse/cqn2odata')
 
 const afterburner = require('./parse/afterburner')
-const { getSafeNumber: safeNumber } = require('./utils')
-const getError = require('../_runtime/common/error')
+const { getSafeNumber: safeNumber, skipToken } = require('./utils')
 
 // used for function validation in peggy parser
 // -----  should all be lowercase, as peggy compares to lowercase  -----
@@ -67,31 +65,20 @@ const strict = {
   }
 }
 
-const _2query = cqn => {
-  if (cqn.SELECT.from.SELECT) cqn.SELECT.from = _2query(cqn.SELECT.from)
-  const query = cqn.SELECT.one ? SELECT.one(cqn.SELECT.from) : SELECT.from(cqn.SELECT.from)
-  for (const prop in cqn.SELECT) {
-    if (prop === 'from') continue
-    // explicitly use cds.ql to get '_includes_or__' magic for cqn.SELECT.where containing 'or'
-    if (prop === 'where' || prop === 'having') query[prop](cqn.SELECT[prop])
-    else query.SELECT[prop] = cqn.SELECT[prop]
-  }
-  return query
-}
-
-const enhanceCqn = (cqn, options) => {
+const _enhanceCqn = (cqn, options) => {
   if (options.afterburner) {
     /** @type Service */ const service = options.service
-    let { model, namespace } = service // prettier-ignore
+    let { model, namespace } = service
     if (service.isExtensible) model = cds.context?.model || model
     cqn = options.afterburner(cqn, model, namespace, options.protocol)
   }
 
-  const query = _2query(cqn)
+  const query = cds.ql(cqn)
 
   // 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 (options.protocol === 'rest' && cqn.__target) query.__target = cqn.__target
+
   if (cqn._propertyAccess)
     Object.defineProperty(query, '_propertyAccess', { value: cqn._propertyAccess, enumerable: false })
 
@@ -119,13 +106,13 @@ module.exports = {
     options = options === 'strict' ? { strict } : options.strict ? { ...options, strict } : options
     if (options.service?.model) Object.assign(options, { minimal: true, afterburner })
     options.safeNumber = safeNumber
-    options.skipToken = require('./utils').skipToken
+    options.skipToken = skipToken
 
     let cqn
     try {
       cqn = odata2cqn(url, options)
     } catch (err) {
-      if (err.statusCode === 501) throw getError(err.statusCode, err.message)
+      if (err.statusCode === 501) throw new cds.error(err.statusCode, err.message)
 
       let offset = err.location && err.location.start.offset
       if (!offset && err.statusCode && err.message) throw err
@@ -141,9 +128,9 @@ module.exports = {
 
     // cqn is an array, if concat is used
     if (Array.isArray(cqn)) {
-      for (let i = 0; i < cqn.length; i++) cqn[i] = enhanceCqn(cqn[i], options)
+      for (let i = 0; i < cqn.length; i++) cqn[i] = _enhanceCqn(cqn[i], options)
     } else {
-      cqn = enhanceCqn(cqn, options)
+      cqn = _enhanceCqn(cqn, options)
     }
 
     // REVISIT: SELECT.from._params is a temporary hack

package/libx/odata/middleware/batch.js

@@ -9,7 +9,7 @@ const { URL } = require('url')
 const multipartToJson = require('../parse/multipartToJson')
 const { getBoundary } = require('../utils')
 
-const { normalizeError } = require('../../_runtime/common/error/frontend')
+const { normalizeError } = require('./error')
 
 const HTTP_METHODS = { GET: 1, POST: 1, PUT: 1, PATCH: 1, DELETE: 1 }
 const CT = { JSON: 'application/json', MULTIPART: 'multipart/mixed' }
@@ -79,10 +79,11 @@ const _validateBatch = body => {
       // All request objects with the same value for atomicityGroup MUST be adjacent in the requests array
       if (atomicityGroup !== previousAtomicityGroup) {
         if (ids[atomicityGroup]) throw _deserializationError(`Atomicity group ID '${atomicityGroup}' is not unique.`)
-        else ids[atomicityGroup] = [request]
-      } else {
-        ids[atomicityGroup].push(request)
+        else ids[atomicityGroup] = []
       }
+      // add current index to ensure stable order in result
+      request._agIndex = ids[atomicityGroup].length
+      ids[atomicityGroup].push(request)
     }
 
     if (url.startsWith('$')) {
@@ -259,7 +260,7 @@ const _tx_done = async (tx, responses, isJson) => {
     // here, the commit was rejected even though all requests were successful (e.g., by custom handler or db consistency check)
     rejected = 'rejected'
     // construct commit error (without modifying original error)
-    const { error, statusCode } = normalizeError(Object.create(e), { locale: cds.context.locale })
+    const error = normalizeError(Object.create(e), { locale: cds.context.locale })
     // replace all responses with commit error
     for (const res of responses) {
       res.status = 'fail'
@@ -268,7 +269,7 @@ const _tx_done = async (tx, responses, isJson) => {
         let txt = ''
         for (let i = 0; i < res.txt.length; i++) txt += Buffer.isBuffer(res.txt[i]) ? res.txt[i].toString() : res.txt[i]
         txt = JSON.parse(txt)
-        txt.status = statusCode
+        txt.status = error.status
         txt.body = { error }
         // REVISIT: content-length needed? not there in multipart case...
         delete txt.headers['content-length']
@@ -278,9 +279,9 @@ const _tx_done = async (tx, responses, isJson) => {
           'content-type: application/http',
           'content-transfer-encoding: binary',
           '',
-          `HTTP/1.1 ${statusCode} ${STATUS_CODES[statusCode]}`,
+          `HTTP/1.1 ${error.status} ${STATUS_CODES[error.status]}`,
           'odata-version: 4.0',
-          'content-type: application/json;odata.metadata=minimal;IEEE754Compatible=true',
+          'content-type: application/json;odata.metadata=minimal',
           '',
           JSON.stringify({ error })
         ].join(CRLF)
@@ -393,7 +394,7 @@ const _processBatch = async (srv, router, req, res, next, body, ct, boundary) =>
               const dependentOnResult = JSON.parse(dependentResult.value.res._chunk)
               const recentUrl = request.url
               const cqn = cds.odata.parse(dependentOnUrl, { service: srv, baseUrl: req.baseUrl, strict: true })
-              const { target } = cqn
+              const target = cds.infer.target(cqn)
               const keyString =
                 '(' +
                 [...target.keys]
@@ -422,7 +423,9 @@ const _processBatch = async (srv, router, req, res, next, body, ct, boundary) =>
           if (separator) resp.separator = separator
           else separator = Buffer.from(',')
           resp.txt = _formatResponse(req, atomicityGroup)
-          responses.push(resp)
+          // ensure stable order of responses in multipart changeset
+          if (!isJson && request.atomicityGroup) responses[request._agIndex] = resp
+          else responses.push(resp)
         })
         .catch(failedReq => {
           const resp = { status: 'fail' }
@@ -430,7 +433,9 @@ const _processBatch = async (srv, router, req, res, next, body, ct, boundary) =>
           else separator = Buffer.from(',')
           resp.txt = _formatResponse(failedReq, atomicityGroup)
           tx.failed = failedReq
-          responses.push(resp)
+          // ensure stable order of responses in multipart changeset
+          if (!isJson && request.atomicityGroup) responses[request._agIndex] = resp
+          else responses.push(resp)
         })
 
       previousAtomicityGroup = atomicityGroup
@@ -492,23 +497,27 @@ const _formatResponseMultipart = request => {
   }
   txt += CRLF
 
-  if (response._chunk) {
-    let _json
+  const _tryParse = x => {
     try {
-      // REVISIT: tests require specific sequence -> fix and simply use res._chunk
-      _json = JSON.parse(response._chunk)
-      if (typeof _json !== 'object') throw new Error('not an object')
+      return JSON.parse(x)
+    } catch {
+      return x
+    }
+  }
+
+  if (response._chunk) {
+    const chunk = _tryParse(response._chunk)
+    if (chunk && typeof chunk === 'object') {
       let meta = [],
         data = []
-      for (const [k, v] of Object.entries(_json)) {
+      for (const [k, v] of Object.entries(chunk)) {
         if (k.startsWith('@')) meta.push(`"${k}":${typeof v === 'string' ? `"${v.replaceAll('"', '\\"')}"` : v}`)
         else data.push(JSON.stringify({ [k]: v }).slice(1, -1))
       }
       const _json_as_txt = '{' + meta.join(',') + (meta.length && data.length ? ',' : '') + data.join(',') + '}'
       txt += _json_as_txt
-    } catch {
-      // ignore error and take chunk as is (a text)
-      txt += response._chunk
+    } else {
+      txt += chunk
       txt = txt.replace('content-type: application/json;odata.metadata=minimal', 'content-type: text/plain')
     }
   }

package/libx/odata/middleware/create.js

@@ -1,7 +1,7 @@
 const cds = require('../../../')
 const { INSERT } = cds.ql
 
-const { calculateLocationHeader, handleSapMessages, getPreferReturnHeader } = require('../utils')
+const { handleSapMessages, getPreferReturnHeader } = require('../utils')
 const getODataMetadata = require('../utils/metadata')
 const postProcess = require('../utils/postProcess')
 const readAfterWrite4 = require('../utils/readAfterWrite')
@@ -9,6 +9,8 @@ const getODataResult = require('../utils/result')
 const normalizeTimeData = require('../utils/normalizeTimeData')
 const odataBind = require('../utils/odataBind')
 
+const location4 = require('../../http/location')
+
 const { getKeysAndParamsFromPath } = require('../../common/utils/path')
 
 module.exports = (adapter, isUpsert) => {
@@ -18,13 +20,9 @@ module.exports = (adapter, isUpsert) => {
 
   return function create(req, res, next) {
     const {
-      SELECT: { one, from },
-      target
+      SELECT: { one, from }
     } = req._query
 
-    // req.__proto__.method is set in case of upsert
-    // const isUpsert = req.__proto__.method in { PUT: 1, PATCH: 1 }
-
     if (one && !isUpsert) {
       const msg = 'Method POST is not allowed for singletons and individual entities'
       throw Object.assign(new Error(msg), { statusCode: 405 })
@@ -33,6 +31,7 @@ module.exports = (adapter, isUpsert) => {
     const model = cds.context.model ?? service.model
 
     // payload & params
+    const target = cds.infer.target(req._query) // FIXME: this should not happen here but only in an event handler !
     const data = req.body
     if (Array.isArray(data)) {
       const msg = 'Only single entity representations are allowed'
@@ -44,8 +43,6 @@ module.exports = (adapter, isUpsert) => {
     // add keys from url into payload (overwriting if already present)
     Object.assign(data, keys)
 
-    const _isDraft = target.drafts && data.IsActiveEntity !== true
-
     // query
     const query = INSERT.into(from).entries(data)
 
@@ -55,9 +52,6 @@ module.exports = (adapter, isUpsert) => {
     // we need a cds.Request for multiple reasons, incl. params, headers, sap-messages, read after write, ...
     const cdsReq = adapter.request4({ query, params, headers, req, res })
 
-    // rewrite event for draft-enabled entities
-    if (_isDraft) cdsReq.event = 'NEW'
-
     // NOTES:
     // - only via srv.run in combination with srv.dispatch inside,
     //   we automatically either use a single auto-managed tx for the req (i.e., insert and read after write in same tx)
@@ -79,8 +73,7 @@ module.exports = (adapter, isUpsert) => {
         handleSapMessages(cdsReq, req, res)
 
         if (!target._isSingleton) {
-          // determine calculation based on result with req.data as fallback
-          res.set('location', calculateLocationHeader(cdsReq.target, service, result || cdsReq.data))
+          res.set('location', location4(cdsReq.target, service, result || cdsReq.data))
         }
 
         // case: read after write returns no results, e.g., due to auth (academic but possible)

package/libx/odata/middleware/delete.js

@@ -17,7 +17,6 @@ module.exports = adapter => {
     // REVISIT: better solution for query._propertyAccess
     const {
       SELECT: { one, from },
-      target,
       _propertyAccess
     } = req._query
 
@@ -41,9 +40,6 @@ module.exports = adapter => {
     // we need a cds.Request for multiple reasons, incl. params, headers, sap-messages, read after write, ...
     const cdsReq = adapter.request4({ query, data, headers, params, req, res })
 
-    // rewrite event for draft-enabled entities
-    if (target._isDraftEnabled && cdsReq.data.IsActiveEntity === false) cdsReq.event = 'CANCEL'
-
     // NOTES:
     // - only via srv.run in combination with srv.dispatch inside,
     //   we automatically either use a single auto-managed tx for the req (i.e., insert and read after write in same tx)

package/libx/odata/middleware/error.js

@@ -1,40 +1,96 @@
 const cds = require('../../../lib')
+const { shutdown_on_uncaught_errors } = cds.env.server
 
-const _log = require('../../_runtime/common/error/log')
+exports = module.exports = () =>
+  function odata_error(err, req, res, next) {
+    if (exports.pass_through(err)) return next(err)
+    if (err.details) err = _fioritized(err)
+    const content_id = req.headers['content-id']
+    if (content_id) err['@Core.ContentID'] = content_id
+    err['@Common.numericSeverity'] ??= err.numericSeverity || 4
 
-const { normalizeError, unwrapMultipleErrors } = require('../../_runtime/common/error/frontend')
-const { isStandardError } = require('../../_runtime/common/error/standardError')
+    // propagate content-id and set @Common.numericSeverity
+    err.details?.forEach(e => {
+      if (content_id) e['@Core.ContentID'] = content_id
+      e['@Common.numericSeverity'] ??= e.numericSeverity || 4 // Fiori expects this in error.details
+    })
 
-module.exports = () => {
-  return function odata_error(err, req, res, next) {
-    if (err == 401 || err.code == 401) return next(err) // speed up logins, at least temporary until we reviewed and eliminated overhead that may be involved below
+    exports.normalizeError(err, req)
+    return next(err)
+  }
 
-    // if error already has statusCode, it comes from express, don't throw
-    if (!err.statusCode && isStandardError(err) && cds.env.server.shutdown_on_uncaught_errors) {
-      return next(err)
-    }
+exports.pass_through = err => {
+  if (err == 401 || err.code == 401) return true
+  if (shutdown_on_uncaught_errors && !(err.status || err.statusCode) && cds.error.isSystemError(err)) return true
+}
 
-    // REVISIT: keep?
-    // log the error (4xx -> warn)
-    _log(err)
+exports.normalizeError = (err, req, cleanse = ODATA_PROPERTIES) => {
+  const locale = cds.i18n.locale.from(req)
+  err.status = _normalize(err, locale, cleanse) || 500
+  return err
+}
 
-    const { error, statusCode } = normalizeError(err, req) // REVISIT: that's killing error objects and stacks -> get rid of it
+exports.getSapMessages = (messages, req) => {
+  const locale = cds.i18n.locale.from(req)
+  for (let m of messages) _normalize(m, locale, SAP_MSG_PROPERTIES)
+  return JSON.stringify(messages).replace(
+    /[\u007F-\uFFFF]/g,
+    c => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0')
+  )
+}
 
-    const content_id = req.headers['content-id']
-    if (content_id) {
-      error['@Core.ContentID'] = content_id
-      error.details?.forEach(e => (e['@Core.ContentID'] = content_id))
-    }
+const { i18n } = require('../../../lib')
+const ODATA_PROPERTIES = { code: 1, message: 1, target: 1, details: 1, innererror: 1 }
+const SAP_MSG_PROPERTIES = { ...ODATA_PROPERTIES, longtextUrl: 2, transition: 2, numericSeverity: 2 }
+const BAD_REQUESTS = { ENTITY_ALREADY_EXISTS: 1, FK_CONSTRAINT_VIOLATION: 2, UNIQUE_CONSTRAINT_VIOLATION: 3 }
 
-    if (error.details && cds.env.fiori.wrap_multiple_errors === false) {
-      unwrapMultipleErrors(error)
-    }
+// prettier-ignore
+const _normalize = (err, locale = cds.env.i18n.default_language, keep) => {
 
-    // NOTE: express also looks for numbers in err.status or err.statusCode
-    error.statusCode = statusCode
-    // if (err.stack) Object.defineProperty (error, 'stack', { value: err.stack })
-    // REVISIT: we can't do that ^^^^^ currently because the _http_common parsers we use for $batch requests can't handle that
+  // Determine status code if not already set
+  const details = err.details?.map?.(each => _normalize (each, locale, keep))
+  const status = err.status || err.statusCode || _status4(err) || _reduce(details)
 
-    next(error)
+  // Determine error code and message
+  const key = err.message || err.code || status
+  const msg = i18n.messages.at (key, '', err.args) // lookup messages for log output from factory default texts
+  if (msg && msg !== key) {
+    if (typeof err.code !== 'string') err.code = key
+    err.message = msg
   }
+  if (typeof err.code !== 'string') err.code = String(err.code ?? status ?? '')
+
+  // Cleanse and localize in response to client
+  Object.defineProperty(err, 'toJSON', { value: function() {
+    const that = keep ? {} : {...this}
+    if (keep) for (let k in this) if (k in keep || k[0] === '@') that[k] = this[k]
+    if (locale) that.message = i18n.messages.at (key, locale, this.args)
+    if (!that.message) that.message = this.message
+    return that
+  }})
+  return status
+}
+
+const _status4 = err => {
+  if (err.code >= 300 && err.code < 600 && !err.sqlState) return Number(err.code)
+  if (err.message in BAD_REQUESTS) return 400 // REVISIT: should we use 409 or 500 instead?
+}
+
+const _reduce = details => {
+  const unique = [...new Set(details)]
+  if (unique.length === 1) return unique[0] // if only one unique status exists, we use that
+  if (unique.some(s => s >= 500)) return 500 // if at least one 5xx exists, we use 500
+  if (unique.some(s => s >= 400)) return 400 // if at least one 4xx exists, we use 400
+}
+
+/**
+ * According to the Fiori Elements Failed Message specification, the format must be:
+ * Root level: First error, Details: Other errors
+ */ // prettier-ignore
+const _fioritized = cds.env.fiori.wrap_multiple_errors === false ? err => {
+  const [ head, ...tail ] = err.details
+  return Object.assign (err, head, { details: tail.length ? tail : undefined })
+} : err => {
+  err.target ??= 'in' // prevents annoying 'Multiple Errors' modal popups in Fiori
+  return err
 }

package/libx/odata/middleware/metadata.js

@@ -2,6 +2,7 @@ const cds = require('../../../')
 const LOG = cds.log('odata')
 
 const crypto = require('crypto')
+const fs = require('fs')
 
 const _requestedFormat = (queryOption, header) => {
   if (queryOption) return queryOption.match(/json/i) ? 'json' : 'xml'
@@ -17,7 +18,6 @@ const _requestedFormat = (queryOption, header) => {
 }
 
 const _metadataFromFile = async srv => {
-  const fs = require('fs')
   const filePath = cds.root + `/srv/odata/v4/${srv.definition.name}.xml`
   let exists
   try {
@@ -44,12 +44,6 @@ const generateEtag = s => {
   return `W/"${crypto.createHash('sha256').update(s).digest('base64')}"`
 }
 
-const mpSupportsEmptyLocale = () => {
-  const pkg = require(require.resolve('@sap/cds-mtxs/package.json'))
-  const [major, minor] = pkg.version.split('.').map(Number)
-  return major > 1 || (major === 1 && minor >= 12)
-}
-
 module.exports = adapter => {
   const { service } = adapter
 
@@ -60,7 +54,7 @@ module.exports = adapter => {
     }
 
     const format = _requestedFormat(req.query['$format'], req.headers['accept'])
-    const locale = cds.context.locale
+    const locale = cds.context.locale || cds.env.i18n.default_language
 
     // REVISIT: edm(x) and etag cache is only evicted with model
     const csnService = (cds.context.model || cds.model).definitions[service.definition.name]
@@ -97,23 +91,18 @@ module.exports = adapter => {
 
       try {
         let edmx
-        // REVISIT: remove check later
-        if (mpSupportsEmptyLocale()) {
-          // If no extensibility nor fts, do not provide model to mtxs
-          const modelNeeded = cds.env.requires.extensibility || features?.given
-          edmx =
-            metadataCache.edm ||
-            (await mps.getEdmx({
-              tenant,
-              model: modelNeeded ? await mps.getCsn(tenant, features) : undefined,
-              service: service.definition.name
-            }))
-          metadataCache.edm = edmx
-          const extBundle = cds.env.requires.extensibility && (await mps.getI18n({ tenant, locale }))
-          edmx = cds.localize(service.model, locale, edmx, extBundle)
-        } else {
-          edmx = await mps.getEdmx({ tenant, model: service.model, service: service.definition.name, locale })
-        }
+        // If no extensibility nor fts, do not provide model to mtxs
+        const modelNeeded = cds.env.requires.extensibility || features?.given
+        edmx =
+          metadataCache.edm ||
+          (await mps.getEdmx({
+            tenant,
+            model: modelNeeded ? await mps.getCsn(tenant, features) : undefined,
+            service: service.definition.name
+          }))
+        metadataCache.edm = edmx
+        const extBundle = cds.env.requires.extensibility && (await mps.getI18n({ tenant, locale }))
+        edmx = cds.localize(service.model, locale, edmx, extBundle)
         metadataCache.xmlEtag[locale] = generateEtag(edmx)
         res.set('ETag', metadataCache.xmlEtag[locale])
         res.set('Content-Type', 'application/xml')