@sap/cds 6.4.0 → 6.5.0

package/libx/_runtime/common/code-ext/execute.js

@@ -0,0 +1,106 @@
+const cds = require('../../cds')
+const { Worker } = require('worker_threads')
+const path = require('node:path')
+const { timeout, resourceLimits } = require('./config')
+const workerPath = path.resolve(__dirname, 'worker.js')
+const { Errors } = require('../../../../lib/req/response')
+
+const _getReqData = req => {
+  return {
+    data: req.data,
+    params: req.params,
+    results: req.results,
+    messages: req.messages,
+    errors: req.errors ?? new Errors()
+  }
+}
+
+module.exports = async function executeCode(code, req) {
+  const reqData = _getReqData(req)
+  const _getTarget = target => {
+    switch (target) {
+      case 'srv':
+        return this
+
+      case 'req':
+        return req
+
+      // no default
+    }
+  }
+  const workerId = cds.utils.uuid()
+  const worker = new Worker(workerPath, {
+    workerData: { id: workerId },
+    resourceLimits
+  })
+
+  const executePromise = new Promise(function executeCodePromiseExecutor(resolve, reject) {
+    worker.on('online', onStarted)
+    worker.on('message', onMessageReceived)
+    worker.on('error', onError)
+    worker.on('exit', onExit)
+
+    let onStartTimeoutID
+
+    function onStarted() {
+      onStartTimeoutID = setTimeout(() => {
+        worker.terminate()
+        reject(new Error(`Script execution timed out after ${timeout}ms`))
+      }, timeout)
+    }
+
+    function onMessageReceived(message) {
+      switch (message.kind) {
+        case 'run':
+          run(message)
+          return
+
+        case 'success':
+          onSuccess(message)
+          cleanup()
+          return
+
+        case 'error':
+          onError(message.error)
+          return
+
+        // no default
+      }
+    }
+
+    async function onSuccess(message) {
+      for (const m of message.postMessages) await run(m)
+      req.data && Object.assign(req.data, message.req.data) // REVISIT: Why Object.assign(...) is a required?
+      req.results = message.req.results
+      resolve(req.results ?? message.result)
+    }
+
+    function onError(error) {
+      reject(error)
+    }
+
+    function onExit(exitCode) {
+      if (exitCode !== 0) reject(new Error(`Worker thread stopped with exit code ${exitCode}`))
+    }
+
+    async function run(message) {
+      try {
+        let result = _getTarget(message.target)[message.prop](...message.args)
+        if (typeof result?.then === 'function') result = await result
+        if (message.responseData) worker.postMessage({ id: message.id, kind: 'responseData', result })
+      } catch (error) {
+        worker.postMessage({ id: message.id, kind: 'cleanup' })
+        reject(error)
+      }
+    }
+
+    function cleanup() {
+      clearTimeout(onStartTimeoutID)
+      worker.terminate()
+    }
+  })
+
+  // triggers execution of the code in the worker thread
+  worker.postMessage({ id: workerId, code, reqData })
+  return executePromise
+}

package/libx/_runtime/common/code-ext/handlers.js

@@ -0,0 +1,49 @@
+const cds = require('../../cds')
+const executeCode = require('./execute')
+
+const CODE_ANNOTATION = '@extension.code'
+
+module.exports = cds.service.impl(function () {
+  const getCodeFromAnnotation = async (defName, operation, registration) => {
+    // REVISIT: tenant info in not in this.model and cds.context.model is undefined for single tenancy
+    const model = cds.context.model || this.model
+    const el = model.definitions[defName]
+    const boundEl = el.actions?.[operation]
+    const extensionCode = boundEl?.[CODE_ANNOTATION] ?? el[CODE_ANNOTATION]
+    if (extensionCode) {
+      const annotation = extensionCode.filter(element => element[registration] === operation)
+      return annotation.length && annotation[0].code
+    }
+  }
+
+  this.after('READ', async function (result, req) {
+    if (result == null) return // whether result is null or undefined
+    const code = await getCodeFromAnnotation(req.target.name, req.event, 'after')
+    if (!code) return
+    await executeCode.call(this, code, req)
+  })
+
+  this.before(['CREATE', 'UPDATE', 'DELETE'], async function (req) {
+    const code = await getCodeFromAnnotation(req.target.name, req.event, 'before')
+    if (!code) return
+    await executeCode.call(this, code, req)
+  })
+
+  this.on('*', async function (req, next) {
+    if (this.name.startsWith('cds.xt')) return next()
+    // REVISIT: req.target -> wait until implementation task finished
+    let fqn = req.target?.actions?.[`${req.event}`] // check for bound action/function
+    if (!fqn) {
+      if (req.target) return next()
+      fqn = this.model.definitions[`${this.name}.${req.event}`] // check for unbound action/function or event
+    }
+
+    // REVISIT: DO NOT OVERWRITE EXISTING Action Implementations!
+    // REVISIT: check whether action/function or event is part of an extension
+    if (fqn.kind === 'action' || fqn.kind === 'function' || req.constructor.name === 'EventMessage') {
+      const code = await getCodeFromAnnotation(req?.target?.name ?? fqn.name, req.event, 'on')
+      if (!code) return
+      return await executeCode.call(this, code, req)
+    }
+  })
+})

package/libx/_runtime/common/code-ext/worker.js

@@ -0,0 +1,36 @@
+const { parentPort, workerData } = require('worker_threads')
+const { WorkerSELECT, WorkerINSERT, WorkerUPSERT, WorkerUPDATE, WorkerDELETE } = require('./workerQuery')
+const WorkerReq = require('./WorkerReq')
+const { timeout } = require('./config')
+
+parentPort.once('message', function onMessageReceived({ id, code, reqData }) {
+  if (id !== workerData.id) return
+
+  // eslint-disable-next-line cds/no-missing-dependencies
+  const { VM } = require('vm2')
+  const workerReq = new WorkerReq(reqData)
+  const vm = new VM({
+    console: 'inherit',
+    timeout, // specifies the number of milliseconds to execute code before terminating execution
+    allowAsync: true,
+
+    // the sandbox represents the global object inside the vm instance
+    sandbox: {
+      req: workerReq,
+      SELECT: WorkerSELECT._api(),
+      INSERT: WorkerINSERT._api(),
+      UPSERT: WorkerUPSERT._api(),
+      UPDATE: WorkerUPDATE._api(),
+      DELETE: WorkerDELETE._api()
+    }
+  })
+
+  try {
+    ;(async function () {
+      const result = await vm.run(code)
+      parentPort.postMessage({ kind: 'success', req: reqData, postMessages: workerReq.postMessages, result })
+    })()
+  } catch (error) {
+    parentPort.postMessage({ kind: 'error', error })
+  }
+})

package/libx/_runtime/common/code-ext/workerQuery.js

@@ -0,0 +1,45 @@
+const SELECT = require('../../../../lib/ql/SELECT')
+const INSERT = require('../../../../lib/ql/INSERT')
+const UPSERT = require('../../../../lib/ql/UPSERT')
+const UPDATE = require('../../../../lib/ql/UPDATE')
+const DELETE = require('../../../../lib/ql/DELETE')
+const queryExecutor = require('./workerQueryExecutor')
+
+class WorkerSELECT extends SELECT {
+  // intercept await SELECT.from(...) calls
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerINSERT extends INSERT {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerUPSERT extends UPSERT {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerUPDATE extends UPDATE {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+class WorkerDELETE extends DELETE {
+  then(r, e) {
+    return new Promise(queryExecutor.bind(this)).then(r, e)
+  }
+}
+
+Object.defineProperty(WorkerSELECT.prototype, 'cmd', { value: 'SELECT' })
+Object.defineProperty(WorkerINSERT.prototype, 'cmd', { value: 'INSERT' })
+Object.defineProperty(WorkerUPSERT.prototype, 'cmd', { value: 'UPSERT' })
+Object.defineProperty(WorkerUPDATE.prototype, 'cmd', { value: 'UPDATE' })
+Object.defineProperty(WorkerDELETE.prototype, 'cmd', { value: 'DELETE' })
+
+module.exports = { WorkerSELECT, WorkerINSERT, WorkerUPSERT, WorkerUPDATE, WorkerDELETE }

package/libx/_runtime/common/code-ext/workerQueryExecutor.js

@@ -0,0 +1,33 @@
+const cds = require('../../cds')
+const { parentPort } = require('worker_threads')
+const executorCallbackMap = new Map()
+
+parentPort.on('message', function onMessageReceived({ id, kind, result }) {
+  if (!executorCallbackMap.has(id)) return
+
+  switch (kind) {
+    case 'responseData':
+      executorCallbackMap.get(id)(result)
+      executorCallbackMap.delete(id)
+      return
+
+    case 'cleanup':
+      executorCallbackMap.delete(id)
+      return
+  }
+})
+
+function queryExecutor(resolve, reject) {
+  const id = cds.utils.uuid()
+  executorCallbackMap.set(id, result => resolve(result))
+  parentPort.postMessage({
+    id,
+    kind: 'run',
+    target: 'srv',
+    prop: 'run',
+    responseData: true,
+    args: [this]
+  })
+}
+
+module.exports = queryExecutor

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

@@ -26,7 +26,7 @@ const _targetEntityDoesNotExist = async req => {
 
 exports.impl = cds.service.impl(function () {
   // eslint-disable-next-line complexity
-  this.on(['CREATE', 'READ', 'UPDATE', 'DELETE'], '*', async function (req) {
+  this.on(['CREATE', 'READ', 'UPDATE', 'DELETE', 'UPSERT'], '*', async function (req) {
     if (typeof req.query !== 'string' && req.target && req.target._hasPersistenceSkip) {
       throw getError({
         code: 501,
@@ -61,6 +61,10 @@ exports.impl = cds.service.impl(function () {
       req.query.where(singleton)
     }
 
+    if (req.event === 'READ' && req.query?.SELECT) {
+      req.query.SELECT.localized = true
+    }
+
     if (!result) {
       result = await cds.tx(req).run(req.query, req.data)
     }

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

@@ -1,5 +1,5 @@
 const cds = require('../../cds')
-const { getDefaultPageSize, getMaxPageSize } = require('../utils/page')
+const { getPageSize } = require('../utils/page')
 
 const commonGenericPaging = function (req) {
   // only if http request
@@ -11,13 +11,14 @@ const commonGenericPaging = function (req) {
   _addPaging(req.query, req.target)
 }
 
-const _addPaging = function (query, target) {
-  let { rows, offset } = query.SELECT.limit || {}
-  rows = rows && 'val' in rows ? rows.val : getDefaultPageSize(target)
-  offset = offset && 'val' in offset ? offset.val : 0
-  query.limit(...[Math.min(rows, getMaxPageSize(target)), offset])
+const _addPaging = function ({ SELECT }, target) {
+  const { rows } = SELECT.limit || (SELECT.limit = {})
+  const conf = getPageSize(target)
+  SELECT.limit.rows = {
+    val: !rows ? conf.default : Math.min(rows.val ?? rows, conf.max)
+  }
   //Handle nested limits
-  if (query.SELECT.from.SELECT?.limit) _addPaging(query.SELECT.from, target)
+  if (SELECT.from.SELECT?.limit) _addPaging(SELECT.from, target)
 }
 
 /**

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

@@ -8,7 +8,7 @@ const dirs = (cds.env.i18n && cds.env.i18n.folders) || []
 const i18ns = {}
 
 function exists(args, locale) {
-  const file = path.join(process.cwd(), ...args, locale ? `messages_${locale}.properties` : 'messages.properties')
+  const file = path.join(cds.root, ...args, locale ? `messages_${locale}.properties` : 'messages.properties')
   return fs.existsSync(file) ? file : undefined
 }
 

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

@@ -11,7 +11,7 @@ const search2cqn4sql = require('./search2cqn4sql')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 const getError = require('../../common/error')
 const { rewriteAsterisks } = require('./rewriteAsterisks')
-const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
+const { getEntityFromPath } = require('../../common/utils/path')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { addRefToWhereIfNecessary } = require('../../../odata/afterburner')
 const { addAliasToExpression, PARENT_ALIAS, FOREIGN_ALIAS } = require('../../db/utils/generateAliases')
@@ -445,7 +445,7 @@ const convertWhereExists = (query, model, options, currentTarget) => {
   if (currentTarget) {
     queryTarget = getEntityFromPath({ ref }, currentTarget)
   } else {
-    queryTarget = getEntityFromPath(getPathFromRef(ref), model)
+    queryTarget = getEntityFromPath({ ref }, model)
     outerAlias = as || PARENT_ALIAS + lambdaIteration
     innerAlias = FOREIGN_ALIAS + lambdaIteration
   }
@@ -604,14 +604,19 @@ const _convertExpand = expand => {
   })
 }
 
-const _convertRefWhereInExpand = columns => {
-  if (!columns) return
+const _simplifyWhere = col => {
+  if (col.ref?.[0].where) {
+    col.where = col.ref[0].where
+    col.ref[0] = col.ref[0].id
+  }
+}
 
-  columns.forEach(col => {
-    if (col.expand && typeof col.expand !== 'string') {
-      _convertExpand(col.expand)
-    }
-  })
+const _simplifyWhereInColumns = columns => {
+  if (!columns) return
+  for (const col of columns) {
+    _simplifyWhere(col)
+    if (col.expand) _simplifyWhereInColumns(col.expand)
+  }
 }
 
 const _convertPathExpression = (query, model, options = {}) => {
@@ -742,8 +747,8 @@ const _convertSelect = (query, model, _options) => {
     _convertToOneEqNullInFilter(query.SELECT, target)
   }
 
-  // extract where clause if it is in column expand ref
-  _convertRefWhereInExpand(query.SELECT.columns)
+  // extract where clause if it is in an expand column
+  _simplifyWhereInColumns(query.SELECT.columns)
 
   // REVISIT: The following operations only work for _one_ entity.
   // We must also enable them for joins etc.
@@ -804,6 +809,33 @@ const _convertSelect = (query, model, _options) => {
   return query
 }
 
+const _convertUpsert = (query, model) => {
+  // resolve path expression
+  const resolvedIntoClause = _convertPathExpressionForInsert(query.UPSERT.into, model)
+
+  const target = model.definitions[resolvedIntoClause]
+  if (!target) {
+    // if there is no target, just return original query, as a copy is not deep anyways and all the sub items of query.UPSERT are referenced only anyways
+    return query
+  }
+
+  // overwrite only .into, foreign keys are already set
+  // 'a' added as placeholder since its overwritten by Object.assign below
+  const upsert = UPSERT.into('a')
+
+  // REVISIT flatten structured types, currently its done in SQL builder
+
+  // We add all previous properties ot the newly created query.
+  // Reason is to not lose the query API functionality
+  Object.assign(upsert.UPSERT, query.UPSERT, { into: { ref: [resolvedIntoClause], as: query.UPSERT.into.as } })
+
+  const resolved = resolveView(upsert, model, cds.db)
+  // required for deplyoing of extensions, not used anywhere else except UpsertBuilder
+  resolved._target = resolved.UPSERT?._transitions?.[0].target || query._target
+  // resolved._target = query._target
+  return resolved
+}
+
 const _convertInsert = (query, model) => {
   // resolve path expression
   const resolvedIntoClause = _convertPathExpressionForInsert(query.INSERT.into, model)
@@ -950,6 +982,10 @@ const cqn2cqn4sql = (query, model, options = { suppressSearch: false }) => {
     return _convertInsert(query, model)
   }
 
+  if (query.UPSERT) {
+    return _convertUpsert(query, model)
+  }
+
   if (query.DELETE) {
     return _convertDelete(query, model, options)
   }

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

@@ -1,41 +1,21 @@
 const cds = require('../../cds')
 const { ensureNoDraftsSuffix } = require('./draft')
 
-/*
- * returns path like <service>.<entity>:<prop1>.<prop2> for ref = [{ id: '<service>.<entity>' }, '<prop1>', '<prop2>']
- */
-const getPathFromRef = ref => {
-  const x = ref.reduce((acc, cur) => {
-    acc += (acc ? ':' : '') + (cur.id ? cur.id : cur)
-    return acc
-  }, '')
-  const y = x.split(':')
-  let z = y.shift()
-  if (y.length) z += ':' + y.join('.')
-  return z
-}
-
 /*
  * returns the target entity for the given path
  */
 const getEntityFromPath = (path, def) => {
   let current = def.definitions ? { elements: def.definitions } : def
-  path = typeof path === 'string' ? cds.parse.path(path) : path
-  const segments = [...path.ref]
-  while (segments.length) {
-    let segment = segments.shift()
-    if (segment.id && typeof segment.id === 'string') {
-      segment.id = ensureNoDraftsSuffix(segment.id)
-    } else if (typeof segment === 'string') {
-      segment = ensureNoDraftsSuffix(segment)
-    }
-    current = current.elements[segment.id || segment]
+
+  let id
+  for (const segment of path.ref) {
+    id = ensureNoDraftsSuffix(segment.id || segment)
+    current = current.elements[id]
     if (current && current.target) current = current._target
   }
   return current
 }
 
 module.exports = {
-  getPathFromRef,
   getEntityFromPath
 }

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

@@ -679,6 +679,8 @@ const findQueryTarget = q => {
     ? q.INSERT._transitions[q.INSERT._transitions.length - 1].target
     : q.UPDATE
     ? q.UPDATE._transitions[q.UPDATE._transitions.length - 1].target
+    : q.UPSERT
+    ? q.UPSERT._transitions[q.UPSERT._transitions.length - 1].target
     : q.DELETE
     ? q.DELETE._transitions[q.DELETE._transitions.length - 1].target
     : undefined

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

@@ -15,20 +15,24 @@ const search2cqn4sql = (query, model, options = {}) => {
   const { search2cqn4sql } = options
   const { entityName, alias } = _targetFrom(query.SELECT.from, options)
   const entity = model.definitions[entityName]
-  const columns = computeColumnsToBeSearched(query, entity, alias)
-
+  const localizedAssociation = entity.associations?.localized
   // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
   // REVISIT: $search query option combined with $count is not currently optimized
-  if (typeof search2cqn4sql === 'function' && !query.SELECT.count) {
-    const search2cqnOptions = { columns, locale: options.locale }
+  if (
+    typeof search2cqn4sql === 'function' &&
+    !query.SELECT.count &&
+    localizedAssociation &&
+    !(query._aggregated || /* new parser */ query.SELECT.groupBy)
+  ) {
+    const search2cqnOptions = { columns: computeColumnsToBeSearched(query, entity), locale: options.locale }
     return search2cqn4sql(query, entity, search2cqnOptions)
-  }
+  } else {
+    const expression = searchToLike(cqnSearchPhrase, computeColumnsToBeSearched(query, entity, alias))
 
-  const expression = searchToLike(cqnSearchPhrase, columns)
-
-  // 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)
+    // 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)
+  }
 }
 
 module.exports = search2cqn4sql

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

@@ -40,7 +40,8 @@ function getCqnCopy(readToOneCQN) {
 
 class JoinCQNFromExpanded {
   constructor(cqn, csn, locale) {
-    this._SELECT = Object.assign({}, cqn.SELECT)
+    this._SELECT = {}
+    for (const prop in cqn.SELECT) this._SELECT[prop] = cqn.SELECT[prop]
     this._csn = csn
     // REVISIT: locale is only passed in case of sqlite -> bad coding
     if (cds.env.i18n.for_sqlite.includes(locale)) {

package/libx/_runtime/db/sql-builder/InsertBuilder.js

@@ -36,6 +36,10 @@ class InsertBuilder extends BaseBuilder {
     this._csn = csn
   }
 
+  annotatedColumns(entityName, csn) {
+    return getAnnotatedColumns(entityName, csn)
+  }
+
   /**
    * Builds an Object based on the properties of the CQN object.
    *
@@ -77,7 +81,7 @@ class InsertBuilder extends BaseBuilder {
     this._findUuidKeys(entityName)
 
     this._columnIndexesToDelete = []
-    const annotatedColumns = getAnnotatedColumns(entityName, this._csn)
+    const annotatedColumns = this.annotatedColumns(entityName, this._csn)
 
     if (this._obj.INSERT.columns) {
       this._removeAlreadyExistingInsertAnnotatedColumnsFromMap(annotatedColumns)

package/libx/_runtime/db/sql-builder/UpsertBuilder.js

@@ -6,40 +6,17 @@ class UpsertBuilder extends InsertBuilder {
     super(obj, options, csn)
   }
 
+  annotatedColumns(entityName, csn) {
+    const { updateAnnotatedColumns } = getAnnotatedColumns(entityName, csn)
+    return { insertAnnotatedColumns: updateAnnotatedColumns }
+  }
+
   // REVISIT: We need to copy over the implementation for annotation handling
   build() {
-    this._outputObj = {
-      sql: ['UPSERT'],
-      values: []
-    }
-    this._obj = { INSERT: this._obj.UPSERT, _target: this._obj._target }
-
-    const entityName = this._into()
-
-    this._columnIndexesToDelete = []
-    const annotatedColumns = getAnnotatedColumns(entityName, this._csn)
-    // hack: treat update annotations as insert because of sql builder impl
-    if (annotatedColumns) {
-      annotatedColumns.insertAnnotatedColumns = annotatedColumns.updateAnnotatedColumns
-    }
-
-    if (this._obj.INSERT.columns) {
-      this._removeAlreadyExistingInsertAnnotatedColumnsFromMap(annotatedColumns)
-      this._columns(annotatedColumns)
-    }
-
-    if (this._obj.INSERT.values || this._obj.INSERT.rows) {
-      if (annotatedColumns && !this._obj.INSERT.columns) {
-        // if columns not provided get indexes from csn
-        this._getAnnotatedColumnIndexes(annotatedColumns)
-      }
-
-      this._values(annotatedColumns)
-    } else if (this._obj.INSERT.entries && this._obj.INSERT.entries.length !== 0) {
-      this._entries(annotatedColumns)
-    }
-
-    this._outputObj.sql = this._outputObj.sql.join(' ') + ' WITH PRIMARY KEY'
+    this._obj = { INSERT: this._obj.UPSERT }
+    super.build()
+    this._outputObj.sql = this._outputObj.sql.replace('INSERT INTO', 'UPSERT')
+    this._outputObj.sql += ' WITH PRIMARY KEY'
     return this._outputObj
   }
 }

package/libx/_runtime/db/sql-builder/annotations.js

@@ -16,7 +16,10 @@ const _getAnnotationNames = column => {
 const getAnnotatedColumns = (entityName, csn) => {
   const entityNameWithoutSuffix = ensureNoDraftsSuffix(entityName)
   if (!csn || !csn.definitions[entityNameWithoutSuffix]) {
-    return undefined
+    return {
+      insertAnnotatedColumns: new Map(),
+      updateAnnotatedColumns: new Map()
+    }
   }
   const columns = getColumns(csn.definitions[entityNameWithoutSuffix])
   const insertAnnotatedColumns = new Map()
@@ -39,8 +42,8 @@ const getAnnotatedColumns = (entityName, csn) => {
   }
 
   return {
-    insertAnnotatedColumns: insertAnnotatedColumns,
-    updateAnnotatedColumns: updateAnnotatedColumns
+    insertAnnotatedColumns,
+    updateAnnotatedColumns
   }
 }
 

package/libx/_runtime/db/utils/localized.js

@@ -11,7 +11,7 @@ const _redirectXpr = (xpr, localize) => {
       }
 
       if (ele.SELECT) {
-        redirect(ele.SELECT, localize)
+        if (!ele._suppressLocalization) redirect(ele.SELECT, localize)
       }
     })
 }

package/libx/_runtime/fiori/generic/activate.js

@@ -174,6 +174,10 @@ const fioriGenericActivate = async function (req) {
     })
   ])
 
+  // REVISIT: we need to use okra API here because it must be set in the batched request
+  // status code must be set in handler to allow overriding for FE V2
+  req?._?.odataRes.setStatusCode(201)
+
   return result
 }