@sap/cds 7.3.1 → 7.4.0

package/lib/index.js

@@ -10,8 +10,8 @@ const cds = module.exports = new class cds extends EventEmitter {
   get plugins()  { return super.plugins = require('./plugins').activate() }
   get version()  { return super.version = require('../package.json').version }
   get env()      { return super.env = require('./env/cds-env').for('cds',this.root) }
-  get schema()   { return super.schema = require('./env/schema') }   // dynamic schema loading
   get home()     { return super.home = __dirname.slice(0,-4) }
+  get schema()   { return super.schema = require('./env/schemas') } // REVISIT: Better move that to cds-dk?
   cli = { command:'', options:{}, argv:[] }
   root = process.cwd()
 
@@ -32,7 +32,7 @@ const cds = module.exports = new class cds extends EventEmitter {
   // Model Reflection, Builtin types and classes
   get reflect()     { return super.reflect = this.linked }
   get linked()      { return super.linked = require('./linked/models') }
-  get infer()       { return super.infer = require('./linked/queries') }
+  get infer()       { return super.infer = require('./ql/infer') }
   get builtin()     { return super.builtin = require('./linked/types') }
   get Association() { return super.Association = this.builtin.classes.Association }
   get Composition() { return super.Composition = this.builtin.classes.Composition }
@@ -57,6 +57,7 @@ const cds = module.exports = new class cds extends EventEmitter {
   get server() { return super.server = require('../server') }
   get serve() { return super.serve = require('./srv/cds-serve') }
   get connect() { return super.connect = require('./srv/cds-connect') }
+  get outboxed() { return super.outboxed = require('../libx/outbox') }
   get middlewares() { return super.middlewares = require('./srv/middlewares') }
   get odata() { return super.odata = require('../libx/odata') }
   get auth() { return super.auth = require('./auth') }
@@ -145,5 +146,7 @@ global.cds = cds // REVISIT: using global.cds seems wrong
 if (process.env.CDS_JEST_MEM_FIX && typeof jest !== 'undefined') require('./utils/jest.js')
 
 // Allow for import cds from '@sap/cds' without esModuleInterop
-Object.defineProperty(module.exports, "__esModule", { value: true });
-module.exports.default = module.exports
+Object.defineProperties(module.exports, {
+  default: { value: module.exports },
+  __esModule: { value: true },
+})

package/lib/linked/models.js

@@ -24,10 +24,13 @@ class LinkedCSN extends any {
         d.items           ? array.prototype :
         /* else: */         any.prototype
       )
-      if (p.key && !d.key && d.kind === 'element') Object.defineProperty (d,'key',{value:undefined})  //> don't propagate .key
-      if (p.params && !d.params && d.kind === 'entity') Object.defineProperty (d,'params',{value:undefined})  //> don't propagate .params
-      if (p.actions && !d.actions && d.kind === 'entity') Object.defineProperty (d,'actions',{value:undefined})  //> don't propagate .actions
-      if (d.elements && d.elements.localized) Object.defineProperty (d,'texts',{value: defs [d.elements.localized.target] })
+      if (d.kind === 'entity') {
+        if (p.actions && !d.actions) _set (d,'actions',undefined) //> don't propagate .actions
+        if (p.params && !d.params)   _set (d,'params',undefined)  //> don't propagate .params
+        if (d.elements?.localized)   _set (d,'texts', defs[d.elements.localized.target])
+      } else if (d.kind === 'element') {
+        if (p.key && !d.key) _set (d,'key',undefined)  //> don't propagate .key
+      }
       try { return Object.setPrototypeOf(d,p) }            //> link d to resolved proto
       catch(e) {                                          //> cyclic proto error
         let msg = d.name; for (; p && p.name; p = p.__proto__) msg += ' > '+p.name
@@ -99,7 +102,7 @@ class LinkedCSN extends any {
 
 const _unresolved = (x,unknown=any) => ({ name:x, __proto__:unknown.prototype, _unresolved:true })
 const _builtin = x => types[x] || typeof x === 'string' && x.startsWith('cds.hana.') && any.prototype
-const _infer = require('./queries'), _not_inferred = _unresolved('<query>',entity)
+const _infer = require('../ql/infer'), _not_inferred = _unresolved('<query>',entity)
 const _set = (o,p,v) => Object.defineProperty (o,p,{value:v,enumerable:false,configurable:1,writable:1})
 const _own = (o,p) => { const pd = Reflect.getOwnPropertyDescriptor(o,p); return pd && pd.value }
 const _is = x => {

package/lib/ql/CREATE.js

@@ -19,4 +19,6 @@ module.exports = class Query extends require('./Query') {
     this.CREATE.as = query
     return this
   }
+
+  get _target_ref(){ return this.CREATE.entity }
 }

package/lib/ql/DELETE.js

@@ -18,4 +18,5 @@ module.exports = class Query extends Whereable {
     return super.valueOf('DELETE FROM')
   }
 
+  get _target_ref(){ return this.DELETE.from }
 }

package/lib/ql/DROP.js

@@ -20,4 +20,6 @@ module.exports = class Query extends require('./Query') {
     DROP.entity = DROP.view = this._target4 (e)
     return this
   }
+
+  get _target_ref(){ return this.DROP.entity }
 }

package/lib/ql/INSERT.js

@@ -30,29 +30,7 @@ module.exports = class Query extends require('./Query') {
     this[this.cmd].rows = rows
     return this
   }
-  _rows(rows, ...args) {
 
-    const INSERT = this.cmd
-    if (Array.isArray(rows)) {
-      // check if all the entries in the array are arrays
-      if (rows.every(e => Array.isArray(e))) {
-        this[INSERT].rows = rows
-        // check if array contains one or multiple objects
-      } else if (rows.every(e => typeof e === 'object')) {
-        this[INSERT].entries = rows
-        // the rows have been added as arguments
-      } else if (args.length !== 0) {
-        args.unshift(rows)
-        this[INSERT].rows = args
-      } else {
-        this[INSERT].values = rows
-      }
-    } else if (typeof rows === 'object') {
-      this[INSERT].entries = rows
-    }
-
-    return this
-  }
   as (query) {
     if (!query || !query.SELECT) this._expected `${{query}} to be a CQN {SELECT} query object`
     this[this.cmd].as = query
@@ -61,6 +39,8 @@ module.exports = class Query extends require('./Query') {
   valueOf() {
     return super.valueOf('INSERT INTO')
   }
+
+  get _target_ref(){ return this.INSERT.into }
 }
 
 const is_array = Array.isArray

package/lib/ql/Query.js

@@ -6,7 +6,7 @@ class Query {
   constructor(_={}) { this[this.cmd] = _ }
 
   alias (a) {
-    let _ = this[this.cmd] ;(_.from || _.into || _.entity).as = a
+    this._target_ref.as = a
     return this
   }
 
@@ -36,20 +36,34 @@ class Query {
     return (r,e) => q.runInAsyncScope (srv.run, srv, this) .then (r,e)
   }
 
-  _target_ref4 (target, arg2) {
+  _target4 (...args) {
+    return this._target_ref4 (...args)
+  }
 
-    // Resolving this._target --> REVISIT: this is not reliable !!!
-    Object.defineProperty (this, '_target', { value: _target4 (target,arg2), configurable:true, writable:true })
+  _target_ref4 (target, arg2) {
 
-    return target && (
+    // If called with a linked entity -> use it as this.target
+    if (target instanceof cds.entity) this.target = target
+
+    // REVISIT: this._target is not reliable !!!
+    this._set ('_target', function _target(t) { return t && (
+      typeof t === 'string' ? { name: t } :
+      t.ref ? { name: t.ref[0] } :
+      t.raw ? _target(arg2) :
+      t.SELECT ? _target(t.SELECT.from) :
+      t //> default is assumed to be a csn definition or a look-alike or a SELECT
+    )}(target))
+
+    // Determine from.ref or from.SELECT
+    const from = target && (
+      target.name   ? {ref:[target.name]} :
       typeof target === 'string' ? cds.parse.path(target) :
+      target.raw    ? cds.parse.path(...arguments) :
       target.ref    ? target :
       target.SELECT ? target :
-      target.SET    ? target :
-      target.raw    ? cds.parse.path(...arguments) :
-      target.name   ? {ref:[target.name]} : 0
+      target.SET    ? target : 0
     )
-    || this._expected `${{target}} to be an entity path string, a CSN definition, a {ref}, a {SELECT}, or a {SET}`
+    return from || this._expected `${{target}} to be an entity path string, a CSN definition, a {ref}, a {SELECT}, or a {SET}`
   }
 
   _expected (...args) {
@@ -62,27 +76,50 @@ class Query {
     return this
   }
 
+  _set (property, value) {
+    Reflect.defineProperty (this, property, { value, configurable:true, writable:true })
+    return value
+  }
+
   valueOf (cmd=this.cmd) {
     return `${cmd} ${_name(this._target.name)} `
   }
-}
 
-const _target4 = (target, arg2) =>  target && (
-  typeof target === 'string' ? { name: target } :
-  target.name ? target : //> assumed to be a linked csn definition
-  target.ref ? { name: target.ref[0] } :
-  target.raw ? _target4(arg2) :
-  target._target || { name: undefined }
-)
+  get _target_ref() {
+    throw cds.error `Query subclass ${this.constructor.name} must implement '_target_ref'`
+  }
+
+  /**
+   * Returns the inferred query's source, which is the entity referred
+   * to in SELECT.from, INSERT.into, UPDATE.entity, or DELETE.from,
+   * or a sub query specified in SELECT.from, INSERT.into,
+   */
+  get source() {
+    const m = this._srv?.model || cds.context?.model || cds.model
+    return cds.infer (this, m?.definitions, 'get source')
+  }
+  set source(t) { this._set('source',t) }
+
+  /**
+   * Returns the inferred query's target, which is the entity referred
+   * to in SELECT.from, INSERT.into, UPDATE.entity, or DELETE.from.
+   * In case of a sub query specified in SELECT.from, INSERT.into,
+   * returns the target of the sub query, recursively.
+   */
+  get target() {
+    const m = this._srv?.model || cds.context?.model || cds.model
+    return cds.infer (this, m?.definitions)
+  }
+  set target(t) { this._set('target',t) }
+}
 
 const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
 
-Object.defineProperty (Query.prototype, '_target4', { value: (
-  cds.env.ql.quirks_mode === false ? Query.prototype._target_ref4
-  : function (...args) {
-    const {ref, as} = this._target_ref4 (...args)
+if (cds.env.ql.quirks_mode) Object.defineProperty (Query.prototype, '_target4', {
+  value: function (...args) {
+    const { ref, as } = this._target_ref4 (...args)
     return ref.length === 1 && typeof ref[0] === 'string' && !as ? ref[0] : as ? {ref, as} : {ref}
   }
-)})
+})
 
 module.exports = Query

package/lib/ql/SELECT.js

@@ -151,6 +151,11 @@ module.exports = class Query extends Whereable {
   valueOf() {
     return super.valueOf('SELECT * FROM')
   }
+
+  get _target_ref(){ return this.SELECT.from }
+
+  get elements() { return this.elements = cds.infer.elements4 (this.SELECT.columns, this.source) }
+  set elements(e) { this._set('elements',e) }
 }
 
 

package/lib/ql/STREAM.js

@@ -77,6 +77,8 @@ module.exports = class Query extends Whereable {
     this.STREAM.data = x
     return this
   }
+
+  get _target_ref(){ return this.STREAM.into || this.STREAM.from }
 }
 
 

package/lib/ql/UPDATE.js

@@ -64,6 +64,8 @@ module.exports = class Query extends Whereable {
 
     return this
   }
+
+  get _target_ref(){ return this.UPDATE.entity }
 }
 
 

package/lib/ql/UPSERT.js

@@ -1 +1,3 @@
-module.exports = class Query extends require('./INSERT') {}
+module.exports = class Query extends require('./INSERT') {
+  get _target_ref(){ return this.UPSERT.into }
+}

package/lib/ql/cds-ql.js

@@ -1,16 +1,20 @@
 const Query = require('./Query')
 require = path => { // eslint-disable-line no-global-assign
   const clazz = module.require (path); if (!clazz._api) return clazz
+  const kind = path.match(/\w+$/)[0]
+  Object.defineProperties (clazz.prototype, {
+    kind: { value: kind },
+    cmd: { value: kind }
+  })
   const api = clazz._api()
-  Object.defineProperty (clazz.prototype, 'cmd', { value: path.match(/\w+$/)[0] })
   return Object.assign (function (...args) {
     if (new.target) return new clazz (...args) // allows: new SELECT
     return api (...args)                      // allows: SELECT(...).from()
-  }, api)
+  }, { class: clazz }, api)
 }
 
-module.exports = {
-  Query, clone: (q,_) => Query.prototype.clone.call(q,_),
+module.exports = exports = {
+  Query,
   STREAM: require('./STREAM'),
   SELECT: require('./SELECT'),
   INSERT: require('./INSERT'),
@@ -21,7 +25,19 @@ module.exports = {
   DROP:   require('./DROP'),
 }
 
-module.exports._reset = ()=>{ // for strange tests only
+exports.clone = function (q,_) {
+  // q = this.query(q)
+  return Query.prototype.clone.call(q,_)
+}
+
+exports.query = function (q) {
+  if (q instanceof Query) return q
+  let kind = Object.keys(q)[0]
+  let clazz = exports[kind]
+  return !clazz ? q : new clazz (q[kind])
+},
+
+exports._reset = ()=>{ // for strange tests only
   const cds = require('../index')
   const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
   Object.defineProperty (Query.prototype,'valueOf',{ configurable:1, value: function(cmd=this.cmd) {

package/lib/ql/infer.js

@@ -0,0 +1,129 @@
+const cds = require('../index')
+
+/**
+ * Infers the target entity of a query
+ */
+function infer (q, defs, _get_source) {
+  if (q._target instanceof cds.entity) return q._target
+  let from = q._target_ref
+    || q.SELECT?.from
+    || q.INSERT?.into
+    || q.UPSERT?.into
+    || q.UPDATE?.entity
+    || q.DELETE?.from
+    || q.STREAM?.from
+    || q.STREAM?.into
+  let source = infer_from (from, defs)
+  let target = source?.SELECT ? infer(source, defs) : source
+
+  Object.defineProperties (q, {
+    _target: { value: target, configurable:true, writable:true },
+    target: { value: target, configurable:true, writable:true },
+    source: { value: source, configurable:true, writable:true },
+  })
+  return _get_source ? source : target
+
+  function infer_from (from, defs={}) {
+    if (!from) return undefined
+    if (from.ref) return infer_ref (from.ref, defs) || _unresolved(from.ref[0])
+    if (from.SELECT) return from
+    if (from.SET || from.args) return undefined //> UNIONs and JOINs are not supported
+    return defs[from] || _unresolved(from) //> from is a string in quirks mode
+  }
+
+  function infer_ref (ref, defs) {
+    let target = {elements:defs}
+    for (let r of ref) {
+      const e = target.elements?.[r.id||r]; if (!e) return
+      target = (
+        e._target ||       //> for already linked associations
+        defs[e.target] ||  //> for not yet linked associations
+        e                  //> for structs
+      )
+    }
+    return target
+  }
+
+  function _unresolved (x) {
+    return { name: x.id || x, __proto__: cds.entity.prototype, _unresolved:true }
+  }
+}
+
+
+/**
+ * Infers the elements according to a query's columns.
+ * @param {Array} columns - the query's columns, or a nested .expand or .inline columns
+ * @param {Object} source - the query's source entity or sub select
+ */
+function elements4 (columns, source) {
+
+  // SELECT from Books; SELECT * from Books
+  if (!columns || columns.length === 1 && columns[0] === '*') return source?.elements
+
+  const elements = {}; columns.forEach (c => {
+
+    // 1) SELECT *, ... from Books
+    if (c === '*') {
+      return Object.assign (elements, source.elements)
+    }
+
+    const ref = c.ref?.map(r => r.id??r)
+    const as = c.as || ref?.join('_') || c.func || c.val || cds.error `Alias required for column expressions ${c}`
+    let d = source, is2many
+
+    // 2) SELECT ... : String from Books
+    if (c.cast) {
+      return elements[as] = builtin [c.cast.type]
+    }
+
+    // 3) SELECT title, author.name from Books
+    if (c.ref && d?.elements) {
+      for (let r of ref) d = (d.SELECT ? d : d._target||d).elements?.[r]
+        || cds.error `Couldn't resolve element "${ref.join('/')}" in ${source.kind} ${source.name||''} ${Object.keys(source.elements)}`
+      if (d._target) { is2many = d.is2many; d = d._target }
+      // ... d is further processed in steps 5,6,7 below
+    }
+
+    // 4) SELECT 1, 2+3, count(*) from Books; SELECT type, name from sqlite.schema
+    else if (!c.expand) {
+      return elements[as] = _typeof(c) // { ..._typeof(c), name: as }
+    }
+
+    // 5) SELECT author.books { title } from Books
+    if (c.expand) {
+      if (d.items) { d = d.items; is2many = true }
+      d = new cds.struct ({ elements: elements4 (c.expand, d) }) //> { a, b, c } as x
+      return elements[as] = is2many ? new cds.array ({ items: d }) : d
+    }
+
+    // 6) SELECT author.books.{ title } from Books
+    if (c.inline) {
+      const nested = elements4 (c.inline, d)
+      for (let n in nested) elements[as+'_'+n] = nested[n]
+    }
+
+    // 7) SELECT title, author.name from Books
+    else return elements[as] = d // NOTE: the else is neccessary after step 5 above
+  })
+  return elements
+
+  function _typeof (c) {
+    if (c.val !== undefined) return builtin [typeof c.val] || builtin [ Number.isInteger(c.val) ? 'Integer' : 'Decimal' ]
+    if (c.func === 'count') return builtin.Integer
+    if (c.xpr?.length === 1) return _typeof(c.xpr[0])
+    return unknown
+  }
+}
+
+const unknown = Object.freeze (new cds.type ({ _unresolved:true }))
+const builtin = function _init (){
+  const bi={}, bt = cds.builtin.types
+  for (let t of Object.keys(bt)) bi[t] = bi[t.slice(4)] = { type:t, __proto__: bt[t] }
+  bi.boolean = bi['cds.Boolean']
+  bi.string = bi['cds.String']
+  return bi
+}()
+
+module.exports = exports = Object.assign (infer, {
+  elements4, unknown
+})

package/lib/req/cds-context.js

@@ -43,11 +43,14 @@ module.exports = new class extends AsyncLocalStorage {
         .finally (() => Promise.all(em.listeners('done').map(each => each())))
       })
     }
-    const em = new EventEmitter; em.timer = (
-      (o && o.after) ? setTimeout(fx, o.after).unref() :
-      (o && o.every) ? setInterval(fx, o.every).unref() :
-      setImmediate(fx).unref()
-    )
+    const em = new EventEmitter
+    const { every, after } = o || {}
+    if (every) {
+      em.timer = setInterval(fx, every)
+      cds.on('shutdown', () => clearInterval(em.timer))
+    } else {
+      em.timer = (after ? setTimeout(fx, after) : setImmediate(fx)).unref()
+    }
     return em
   }
 }

package/lib/srv/cds-connect.js

@@ -43,9 +43,11 @@ connect.to = async (datasource, options) => {
     throw new Error (`No service definition found for '${required.service || datasource}'`)
   }
   // construct new service instance
-  const srv = await new Service (datasource,m,o)
+  let srv = await new Service (datasource,m,o)
   await srv.prepend (srv.init, srv.options.impl)
   if (datasource === 'db') cds.db = srv
+  // outbox the service, if configured
+  if (srv.options.outbox) srv = cds.outboxed(srv)
   _done (cds.services[datasource] = srv)
   if (!o.silent) cds.emit ('connect',srv)
   TRACE?.timeEnd(`cds.connect ${datasource} `)

package/lib/utils/axios.js

@@ -1,9 +1,10 @@
+const http = require('http')
 class Axios {
-
   get axios() {
     // eslint-disable-next-line cds/no-missing-dependencies
     const axios = require('axios').create ({
       headers: { 'Content-Type': 'application/json' },
+      httpAgent: new http.Agent({ keepAlive: false}),
       baseURL: this.url,
     })
     // fill in baseURL on subsequent this.url = url, after server has started
@@ -44,6 +45,7 @@ const _args = (args) => {
 
 const _error = (e) => {
   Error.captureStackTrace (e,_error) //> adds the stack trace from caller code
+  if (e.errors) e = e.errors[0] // Node 20 sends AggregationErros
   if (e.code && e.port === 80 /* default port */) throw Object.assign (e, {
     message:  e.message + '\nIt seems that the server was not started. Make sure to call \'cds.test(...)\' or \'cds.test.run(...)\'.',
     stack: null // stack is just clutter here
@@ -52,7 +54,7 @@ const _error = (e) => {
   if (message) e.message = code && code !== 'null' ? `${code} - ${message}` : message
   // Promote toJSON from prototype to own property to make it iterable
   // eslint-disable-next-line no-self-assign
-  if (typeof jest !== 'undefined') e.toJSON = e.toJSON
+  if (typeof jest !== 'undefined') e.toJSON = e.toJSON // REVISIT: what is this for?
   throw e
 }
 

package/lib/utils/data.js

@@ -27,6 +27,9 @@ class DataUtil {
         if (!entity.query && entity['@cds.persistence.skip'] !== true) {
           this._deletes.push(DELETE.from(entity))
         }
+        if (entity.drafts) {
+          this._deletes.push(DELETE.from(entity.drafts))
+        }
       }
     }
     if (this._deletes.length > 0) {

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

@@ -83,6 +83,7 @@ const _betterOkraError = err => {
  * @returns {Function}
  */
 const getErrorHandler = (crashOnError = true, srv) => {
+  // eslint-disable-next-line complexity
   return async (odataReq, odataRes, next, err) => {
     // REVISIT: crashOnError
     if (isStandardError(err) && crashOnError) {
@@ -148,6 +149,17 @@ const getErrorHandler = (crashOnError = true, srv) => {
     // REVISIT: We should also pass stack traces in development
     // if (!cds.env.production) error.stack = err.stack
 
+    if (cds.env.fiori.wrap_multiple_errors === false) {
+      // According to the Fiori Elements Failed Message specification, the format must be:
+      // Root level: First error, Details: Other errors
+      if (error.details) {
+        const [firstDetail, ...restDetails] = error.details
+        Object.assign(error, firstDetail)
+        if (restDetails.length) error.details = restDetails
+        else delete error.details
+      }
+    }
+
     next(null, Object.assign(error, { statusCode }))
   }
 }

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

@@ -1,3 +1,4 @@
+const { join } = require('path')
 const cds = require('../../../../cds')
 const LOG = cds.log('odata')
 
@@ -5,6 +6,12 @@ const { toODataResult } = require('../utils/result')
 const { normalizeError } = require('../../../../common/error/frontend')
 const getError = require('../../../../common/error')
 
+const mpSupportsEmptyLocale = () => {
+  const pkg = require(join('@sap/cds-mtxs', 'package.json'))
+  const version = pkg.version.match(/^(\d+\.)?(\d+\.)?(\*|\d+)$/).map(Number)
+  return version[1] > 1 || (version[1] === 1 && version[2] >= 12)
+}
+
 /**
  * Provide localized metadata handler.
  *
@@ -20,14 +27,25 @@ const metadata = service => {
 
     try {
       const { 'cds.xt.ModelProviderService': mps } = cds.services
-      let edmx = mps
-        ? await mps.getEdmx({ tenant, model: service.model, service: service.definition.name, locale })
-        : cds.localize(
-            service.model,
-            locale,
-            // REVISIT: we could cache this in model._cached
-            cds.compile.to.edmx(service.model, { service: service.definition.name })
-          )
+      let edmx
+      if (mps) {
+        // REVISIT: remove check later
+        if (mpSupportsEmptyLocale()) {
+          edmx = await mps.getEdmx({ tenant, model: service.model, service: service.definition.name })
+          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 })
+        }
+      } else {
+        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/okra/odata-server/batch/BatchProcessor.js

@@ -36,7 +36,7 @@ class BatchProcessor {
    * @returns {Promise} the overall result
    */
   process () {
-    if(cds.odata.batch_limit < this._batchContext.getRequestList().length) return Promise.reject({statusCode: 429, message: 'Batch request contains too many requests'})
+    if(cds.env.odata.batch_limit < this._batchContext.getRequestList().length) return Promise.reject({statusCode: 429, message: 'Batch request contains too many requests'})
     const request = this._batchContext.getRequest()
     const componentManager = request.getService().getComponentManager()