@sap/cds 8.9.3 → 9.0.2

package/lib/ql/cds.ql-infer.js

@@ -1,127 +1,116 @@
 const cds = require('../index')
+const infer = exports = module.exports = (..._) => infer.target(..._)
+
 
 /**
  * Infers the target entity of a query
+ * @param {import('./cds.ql-Query')} q
  */
-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
-  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
-  }
+infer.target = function (q, ctx) {
+  if (q._target instanceof cds.entity) return q._target //> already inferred
+  const subject = _subject4(q)
+  const target = (
+    subject?.SELECT ? infer.target (subject, ctx ??= _context4(q)) :
+    subject?.ref ? infer.ref (subject.ref, ctx ??= _context4(q)) :
+    undefined
+  )
+  Object.defineProperty (q, '_target', { value: target, configurable:true, writable:true })
+  return target
+}
 
-  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
+infer.ref = function (ref, ctx) {
+  const defs = (ctx.model||ctx).definitions
+  let name = _name4(ref[0]), d = defs?.[name] || ctx.entities?.[name]
+  if (!d) return { name, _unresolved:true, __proto__: cds.entity.prototype }
+  else for (let i=1; i < ref.length; ++i) {
+    d = d.elements?.[name = _name4(ref[i])] || cds.error `Element ${name} not found in ${d}`
+    if (d.target) d = defs[d.target] || cds.error `Target ${d.target} not found in ${defs}`
   }
+  return d
+}
 
-  function _unresolved (x) {
-    return { name: x.id || x, __proto__: cds.entity.prototype, _unresolved:true }
+/** @param {import('./SELECT').class} q */
+infer.elements = function (q) {
+
+  const subject = _subject4(q); if (!subject) return
+  const source = subject.SELECT ? subject : infer.target(q)
+
+  return _infer_elements4 (q.SELECT.columns, source, q.SELECT.from.as)
+  function _infer_elements4 (columns, source, alias) {
+
+    // 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(_name4); if (alias && alias === ref?.[0] && ref.length > 1) ref.shift()
+      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; c.expand || c.inline ? d = d._target : d }
+        // ... 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: _infer_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 = _infer_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
   }
 }
 
-
-/**
- * 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; c.expand || c.inline ? d = d._target : d }
-      // ... 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 _context4 = q => q._srv ?? cds.context?.model ?? cds.model ?? {}
+const _subject4 = (q) => q._subject
+  || q.SELECT?.from
+  || q.INSERT?.into
+  || q.UPSERT?.into
+  || q.UPDATE?.entity
+  || q.DELETE?.from
+
+const _name4 = r => r.id || r
+const _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 unknown = exports.unknown = Object.freeze (new cds.type ({ _unresolved:true }))
+const builtin = function() {
   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/ql/resolve.js

@@ -8,6 +8,7 @@ const _isPersistenceTable = target =>
 // REVISIT revert after cds-dbs pr
 // REVISIT: Remove once we get rid of old db
 const _abortDB = resolve.abortDB = target => !!(_isPersistenceTable(target)|| !target.query?._target)
+// _service seems to be inherited in projections, so do not consider prototype chain
 const _defaultAbort = tx => e => e._service?.name === tx.definition?.name
 
 function resolve(query, tx, abortCondition) {
@@ -31,11 +32,9 @@ resolve.table = target => {
 
 // REVISIT: Remove argument `skipForbiddenViewCheck` once we get rid of composition tree
 resolve.transitions = (query, tx, abortCondition, skipForbiddenViewCheck) => {
-  const target = query?.target || query?._target
-
+  const target = query && typeof query === 'object' ? cds.infer.target(query) || query?._target : undefined
   const abort = abortCondition ?? (typeof tx === 'function' ? tx : undefined)
   const _tx = typeof tx === 'function' ? cds.context?.tx : tx
-
   return getTransition(target, _tx, skipForbiddenViewCheck, undefined, {
     abort: abort ?? (tx.isDatabaseService ? _abortDB : _defaultAbort(tx))
   })

package/lib/req/context.js

@@ -1,6 +1,6 @@
 const cds = require ('../index'), { uuid } = cds.utils
 const async_events = { succeeded:1, failed:1, done:1, commit:1 }
-const req_locale = require('./locale')
+const locale = require('./../i18n/locale')
 const { EventEmitter } = require('events')
 
 /**
@@ -31,6 +31,7 @@ class EventContext {
     Object.assign (this, _)
   }
 
+  /** @type <T>( property: string, value: T ) => T */
   _set (property, value) {
     Object.defineProperty (this, property, { value, writable:true })
     return value
@@ -99,10 +100,10 @@ class EventContext {
     if (l) super.locale = super._locale = l
   }
   get locale() {
-    return super.locale = this._propagated.locale || req_locale.from(this._.req)
+    return super.locale = this._propagated.locale || locale.from(this._.req) //||this.http?.req)
   }
   get _locale() {
-    return super._locale = this._propagated._locale || req_locale.raw(this._.req)
+    return super._locale = this._propagated._locale || locale.header(this._.req) //||this.http?.req)
     || this.hasOwnProperty('locale') && this.locale // eslint-disable-line no-prototype-builtins
   }
 
@@ -117,7 +118,7 @@ class EventContext {
   }
 
   get model() {
-    const m = this._propagated.model || this.http?.req.__model // IMPORTANT: Never use that anywhere else
+    const m = this._propagated.model
     return this._set('model',m)
   }
   set model(m) {

package/lib/req/request.js

@@ -1,4 +1,4 @@
-const cds = require('../index'), {production} = cds.env
+const cds = require('../index')
 const { Responses, Errors } = require('./response')
 
 /**
@@ -8,6 +8,11 @@ const { Responses, Errors } = require('./response')
  */
 class Request extends require('./event') {
 
+  constructor(_) { super(_)
+    /** For IntelliSense only: @type import('../ql/cds.ql-Query') */
+    this.query
+  }
+
   toString() { return `${this.event} ${this.path}` }
 
   get assert(){ return super.assert = require('./assert')(this) }
@@ -26,7 +31,7 @@ class Request extends require('./event') {
 
   set entity(e) { if (e) super.entity = e.name ? (this.target = e).name : e }
   get entity() {
-    return this._set ('entity', this.target && this.target.name)
+    return this._set ('entity', this.target?.name)
   }
 
   set params(p) { if (p) super.params = p }
@@ -52,44 +57,41 @@ class Request extends require('./event') {
   set data(d) { if (d) super.data = d }
   get data() {
     const q = this.query; if (!q) return this._set ('data', undefined)
-    const I = q.INSERT || q.UPSERT; if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) ||{})
-    const U = q.UPDATE; if (U) return this._set ('data', U.data ||{})
+    const I = q.INSERT || q.UPSERT; if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) || {})
+    const U = q.UPDATE; if (U) return this._set ('data', U.data ??= {})
     return this._set ('data', {})
   }
 
   set subject(d) { if (d) super.subject = d }
   get subject() {
     const q = this.query
-    let subject = (
-      q?.SELECT?.from ||
-      q?.INSERT?.into ||
-      q?.UPSERT?.into ||
-      q?.UPDATE?.entity ||
-      q?.DELETE?.from
-    )
-
-    const {target} = this; if (!target) return undefined
-
-    // programmatic action calls as of now only in format /Books(201)/action
-    if (!subject) {
-      let where = []
-      for (const param of this.params) {
-        if (typeof param === 'object') {
-          for (const key in param) {
-            if (key in target.keys) {
-              if (where.length > 1) where.push('and')
-              where.push({ ref: [key] }, '=', { val: param[key] })
-            }
+    if (q) {
+      let subject = q._subject
+        || q.SELECT?.from
+        || q.INSERT?.into
+        || q.UPSERT?.into
+        || q.UPDATE?.entity
+        || q.DELETE?.from
+      if (!subject) return super.subject = undefined
+      while ('SELECT' in subject) subject = subject.SELECT.from
+      return super.subject = { ref: subject.ref } // REVISIT: copy is neccessary for now, as there's code modifying req.subject
+    }
+
+    const {target} = this; if (!target) return super.subject = undefined
+    const where = []
+    for (const param of this.params) {
+      if (typeof param === 'object') {
+        for (const key in param) {
+          if (key in target.keys) {
+            if (where.length > 1) where.push('and')
+            where.push({ ref: [key] }, '=', { val: param[key] })
           }
-        } else {
-          where.push({ ref: [Object.keys(target.keys)[0]] }, '=', { val: param })
         }
+      } else {
+        where.push({ ref: [Object.keys(target.keys)[0]] }, '=', { val: param })
       }
-      subject = { id: target.name, where }
     }
-
-    const ref = subject.ref || [ subject ]
-
+    const ref = [{ id: target.name, where }]
     return super.subject = { ref }
   }
 
@@ -100,20 +102,17 @@ class Request extends require('./event') {
   notify (...args) { return this._messages.add (1, ...args) }
   info   (...args) { return this._messages.add (2, ...args) }
   warn   (...args) { return this._messages.add (3, ...args) }
-  error  (...args) { return this._errors.add (4, ...args) }
+  error  (...args) { return this._errors.add (null, ...args) }
   reject (...args) {
     if (args.length === 0 && this.errors) {
-      let errs = this.errors
-      if (errs.length === 1) throw errs[0]
-      let me = new cds.error ('MULTIPLE_ERRORS', { details: errs }, this.reject)
-      if (!production) me.stack += errs.map (e => '\n---------------------------------\n'+ e.stack
-        .replace('\n',': '+ (e.element||e.target||'')+'\n---------------------------------\n')
-        .replace(/^Error: /,'')
-      ).join('')
-      throw me
+      if (this.errors.length === 1) throw this.errors[0]
+      const err = new cds.error ('MULTIPLE_ERRORS', { details: this.errors })
+      delete err.stack
+      throw err
     }
     let e = this.error(...args)
-    if (!e.stack) Error.captureStackTrace (e = Object.assign(new Error,e), this.reject)
+    if (!('stack' in e)) Error.captureStackTrace (e = Object.assign(new Error,e), this.reject)
+    if (!('message' in e)) e.message = String (e.code || e.status)
     throw e
   }
 
@@ -174,6 +173,11 @@ const _path4 = (x,p) => {
 //
 //  REVISIT: Legacy stuff...
 //
-Object.defineProperties (Request.prototype, {
-  diff: { get: ()=> require('../../libx/_runtime/common/utils/differ').reqDiff }
+Object.defineProperty (Request.prototype, 'diff', {
+  get() {
+    const { reqDiff: diff } = require ('../../libx/_runtime/common/utils/differ')
+    Object.defineProperty (Request.prototype, 'diff', { value: diff })
+    return diff
+  },
+  configurable: true
 })

package/lib/req/response.js

@@ -5,7 +5,7 @@ const placeholders = [...'x'.repeat(9)].map((x,i) => `{${i+1}}`)
  * Messages Collector, used for `req.errors` and `req.messages`
  */
 class Responses extends Array {
-  static get (severity, code, message, target, args) {
+  add (severity, code, message, target, args) {
     let e // be filled in below...
     if (code?.raw) {
       if (typeof message === 'object') {
@@ -30,20 +30,16 @@ class Responses extends Array {
         }
       }
     }
-    if (!e.numericSeverity) e.numericSeverity = severity
+    if (severity) e.numericSeverity ??= severity
+    this.push(e)
     return e
   }
-
-  add (...args) {
-    const response = Responses.get(...args)
-    this.push(response)
-    return response
-  }
 }
 
 class Errors extends Responses {
   push(e) {
-    'stack' in e || Error.captureStackTrace (e = Object.assign(new Error,e), cds.Request.prototype.error)
+    if ('stack' in e) return super.push (...arguments)
+    else Error.captureStackTrace (e = Object.assign(new Error,e), cds.Request.prototype.error)
     return super.push(e)
   }
 }

package/lib/req/spawn.js

@@ -0,0 +1,38 @@
+const { EventEmitter } = require('events')
+const EventContext = require('./context')
+
+module.exports = function spawn (o, fn, /** @type {import('../index')} */ cds=this) {
+  if (typeof o === 'function') [fn,o] = [o,fn] //> for compatibility
+  if (o instanceof EventContext) throw cds.error `The passed options must not be an instance of cds.EventContext.`
+  const fx = ()=>{
+    const tx = cds.tx({...o}) // create a new detached transaction for each run of the background job
+    return cds._with (tx, async ()=> {
+      // REVISIT: The model must be set _after_ run to make sure that cds.context.tenant is correctly set.
+      //          Otherwise, `model4` could query the wrong database to check for extensions.
+      if (cds.model && (cds.env.requires.extensibility || cds.env.requires.toggles)) {
+        const ctx = cds.context
+        const ExtendedModels = require('../srv/srv-models') // the sentinel is automatically started when required
+        cds.context.model = await ExtendedModels.model4(ctx.tenant, ctx.features)
+        tx.model = cds.context.model
+      }
+      return Promise.resolve(fn(tx))
+      .then (tx.commit, e => {
+        cds.log().error(`ERROR occurred in background job:`, e)
+        return tx.rollback(e)
+      })
+      .then (res => Promise.all(em.listeners('succeeded').map(each => each(res))))
+      .catch (err => Promise.all(em.listeners('failed').map(each => each(err))))
+      .finally (() => Promise.all(em.listeners('done').map(each => each())))
+    })
+  }
+  const em = new EventEmitter
+  em.timer = (
+    o?.every ? setInterval(fx, o.every) :
+    o?.after ? setTimeout(fx, o.after) :
+    setImmediate(fx)
+  ).unref()
+  if (cds.env.server.shutdown_on_uncaught_errors) em.on ('failed', e => {
+    if (cds.error.isSystemError(e)) cds.shutdown(e)
+  })
+  return em
+}

package/lib/req/validate.js

@@ -5,7 +5,6 @@ const cds = require('..')
  * @returns {Error[]|undefined} an array of errors or undefined if no errors occurred
  */
 const conf = module.exports = exports = function validate (data, target, options={}) {
-  if (!target || target._unresolved) return
   const vc = new Validation (data, target, options)
   target.validate (data, null, vc)
   return vc.errors
@@ -18,6 +17,7 @@ class Validation {
   constructor (data, target, options={}) {
     this.data = data
     this.target = target
+    this.protocol = options.protocol
     this.options = options
     this.insert = options.insert ?? options.mandatories
     this.rejectIgnore = options.rejectIgnore
@@ -49,7 +49,7 @@ class Validation {
   }
 
   unknown(e,d,input) {
-    if (e.match(/@.*\./)) return delete input[e] //> skip all annotations, like @odata.Type (according to OData spec annotations contain an "@" and a ".")
+    if (this.protocol === 'odata' && e.match(/^\w*@\w+\.\w+$/)) return delete input[e] //> skip all annotations, like @odata.Type (according to OData spec annotations contain an "@" and a ".")
     d['@open'] || cds.error (`Property "${e}" does not exist in ${d.name}`, {status:400})
   }
 }
@@ -68,9 +68,7 @@ class ValidationErrors extends Array {
     stack: { configurable:true, get() { return this.message },
       set(v) { Object.defineProperty (this, 'stack', { value:v, writable:true, configurable:true }) },
     },
-    code: { value: '400', writable:true }, // REVISIT: should be 'ASSERT_'... (i.e. msg) but we need to adjust all tests, and have a code catalogue
-    statusCode: { value: 400 }, // REVISIT: should go into mappings in adapter's error handlers -> requires a code catalogue // REVISIT: .statusCode vs .status?
-    numericSeverity: { value: 4, enumerable: true }, // REVISIT: that is OData-specific
+    status: { value: 400 },
   })
 }
 exports.ValidationErrors = ValidationErrors
@@ -148,6 +146,7 @@ const $any = class any {
         else return false // joined field which can't be mandatory, e.g. SELECT from Books { author.name as author }
         function alias4 (x) { return x.as || x.ref?.at(-1) }
       }
+      if (d.notNull && !d.default && (d.parent?.kind === 'action' || d.parent?.kind === 'function')) return true // only for action/function params
       else return false
     })
   }
@@ -193,10 +192,9 @@ const $any = class any {
 /** Structs iterate over their elements to validate them. */
 class struct extends $any {
   validate (data, path, /** @type {Validation} */ ctx, elements = this.elements, skip={}) {
-    const path_ = !path ? [] : [...path, this.name]; if (path?.row) path_.push({...path})
     if (data == null) return
-    // REVISIT cds^9: rm typeof data !== 'function', misuse in cds-mtxs
-    if (typeof data !== 'object' && typeof data !== 'function') return ctx.error ('ASSERT_DATA_TYPE', path_, this.name, data, this.target)
+    const path_ = !path ? [] : [...path, this.name]; if (path?.row) path_.push({...path})
+    if (typeof data !== 'object') return ctx.error ('ASSERT_DATA_TYPE', path_, this.name, data, this.target)
     // check for required elements in case of inserts -- note: null values are handled in the payload loop below
     if (ctx.insert || data && path_.length && this._is_insert(data)) for (let each of this._required (elements)) {
       if (each.name in data) continue // got value for required element
@@ -243,6 +241,9 @@ class action extends struct {
   validate (data, path, ctx) {
     super.validate (data, path, ctx, this.params || {})
   }
+
+  // REVISIT: why is e['@mandatory'] not checked here?
+  _is_mandatory(e) { return e.notNull && !e.default } // params
 }
 
 /** Managed associations are struct-like, with foreign keys as elements to validate. */

package/lib/srv/bindings.js

@@ -1,7 +1,8 @@
 
-const cds = require ('..'), {fs} = cds.utils
+const cds = require ('..')
 const LOG = cds.log('serve|bindings',{label:'cds'})
 const registry = '~/.cds-services.json'
+const fs = require('fs')
 
 class Bindings {
 

package/lib/srv/cds-connect.js

@@ -19,7 +19,7 @@ const connect = module.exports = async function cds_connect (options) {
  * or with options configured in cds.env.requires.<datasource>.
  * @param { string|Function|object } [datasource]
  * @param {{ kind?:String, impl?:String }} [options]
- * @returns { Promise<import('./cds.ServiceClient')> }
+ * @returns { Promise<import('./cds.Service')> }
  */
 connect.to = (datasource, options) => {
   let Service = cds.service.factory
@@ -44,7 +44,7 @@ connect.to = (datasource, options) => {
     }
     // construct new service instance
     let srv = await new Service (datasource,m,o); await (Service._is_service_class ? srv.init?.() : Service.init?.(srv))
-    if (o.outbox) srv = cds.outboxed(srv)
+    if (!(srv instanceof cds.DatabaseService) && _is_queued(o)) srv = cds.queued(srv)
     if (datasource && !options) {
       if (datasource === 'db') cds.db = srv
       cds.services[datasource] = srv
@@ -77,3 +77,6 @@ function model4 (o) {
   if (cds.model) return cds.model         // use global model if available
   if (o.model) return cds.load (o.model) // load specified model from file
 }
+
+// at least one option is truthy and none is false
+const _is_queued = o => (o.queued || o.outboxed || o.outbox) && o.queued !== false && o.outboxed !== false && o.outbox !== false

package/lib/srv/cds-serve.js

@@ -3,7 +3,6 @@ const Service = cds.service.factory
 const _pending = cds.services._pending ??= {}
 const _ready = Symbol()
 const TRACE = cds.debug('trace')
-if (TRACE && !cds.env.features.odata_new_adapter) require('./../../libx/_runtime/cds-services/adapter/odata-v4/to')
 
 
 /** @param som - a service name or a model (name or csn) */
@@ -95,7 +94,6 @@ module.exports = function cds_serve (som, _options) { // NOSONAR
     /** Fluent method to serve constructed providers to express app */
     in (app) {
       const { serve } = cds.service.protocols
-      if (!cds.env.features.odata_new_adapter && cds.edmxs) ready = ready.then (()=> cds.edmxs)
       ready = ready.then (()=> all.forEach (each => {
         const d = each.definition || {}
         if (d['@protocol'] === 'none' || d['@cds.api.ignore']) return each._is_dark = true