@sap/cds 8.9.3 → 9.0.2

package/lib/test/cds-test.js

@@ -1,264 +1,5 @@
-module.exports = require_local('@cap-js/cds-test')
+// Overwrite require to support IntelliSense in VS Code...
+const {resolve} = require, paths = [ process.cwd(),  __dirname ]
+require = id => module.require (resolve(id,{paths})) // eslint-disable-line no-global-assign
 
-// TODO remove the code below with cds 9
-if (!module.exports) {
-
-const { RED, RESET } = require('../utils/colors')
-// eslint-disable-next-line no-console
-console.error(RED+'Test support will move to package @cap-js/cds-test in @sap/cds v9.\nGet ready and add a dependency to it:\n  npm add -D @cap-js/cds-test\n'+RESET)
-
-/**
- * Instances of this class are constructed and returned by cds.test().
- */
-class Test extends require('./axios') {
-
-  /**
-   * Allows: const { GET, expect, test } = cds.test()
-   */
-  test = this
-
-  get cds() { return require('../index') }
-  get sleep() { return super.sleep = require('util').promisify(setTimeout) }
-  get data() { return super.data = new (require('./data'))}
-
-  /**
-   * Launches a cds server with arbitrary port and returns a subclass which
-   * also acts as an axios lookalike, providing methods to send requests.
-   */
-  run (folder_or_cmd, ...args) {
-
-    switch (folder_or_cmd) {
-      case 'serve': break // nothing to do as all arguments are given
-      case 'run': if (args.length > 0) args.unshift('--project'); break
-      default: this.in(folder_or_cmd); args.push('--in-memory?')
-    }
-    const {cds} = this
-
-    // launch cds server...
-    before (async ()=>{
-      process.env.cds_test_temp = cds.utils.path.resolve(cds.root,'_out',''+process.pid)
-      if (!args.includes('--port')) args.push('--port', '0')
-      let { server, url } = await cds.exec(...args)
-      this.server = server
-      this.url = url
-    })
-
-    // gracefully shutdown cds server...
-    after (async ()=>{
-      await cds.shutdown()
-      // cds.service.providers = []
-      // delete cds.services
-      // delete cds.plugins
-      // delete cds.env
-      await cds.utils.rimraf (process.env.cds_test_temp)
-    })
-
-    return this
-  }
-
-  /**
-   * Serving projects from subfolders under the root specified by a sequence
-   * of path components which are concatenated with path.resolve().
-   * Checks conflicts with cds.env loaded in other folder before.
-   */
-  in (folder, ...paths) {
-    if (!folder) return this
-    const {cds} = this, { isdir, local } = cds.utils
-    // try to resolve folder relative to cds.root, or as a node module
-    try {
-      const path = require('path')
-      folder = isdir (path.resolve (cds.root, folder, ...paths))
-      || path.join (require.resolve (folder+'/package.json').slice(0,-13), ...paths)
-    } catch {
-      throw cds.error (`No such folder or package '${process.cwd()}' -> '${folder}'`)
-    }
-    // Check if cds.env was loaded before running cds.test in different folder
-    if (process.env.CDS_TEST_ENV_CHECK) {
-      const env = Reflect.getOwnPropertyDescriptor(cds,'env')?.value
-      if (env && env._home !== folder && env.stack) {
-        let filter = line => !line.match(/node_modules\/jest-|node:internal/)
-        let err = new Error; err.message =
-          `Detected cds.env loaded before running cds.test in different folder: \n` +
-          `1. cds.env loaded from:  ${local(cds.env._home)||'./'} \n` +
-          `2. cds.test running in:  ${local(folder)} \n\n` +
-          err.stack.split('\n').filter(filter).slice(1).join('\n')
-        err.stack = env.stack.split('\n').filter(filter).slice(1).join('\n')
-        throw err
-      }
-    }
-    cds.root = folder
-    return this
-  }
-
-  /**
-   * Method to spy on a function in an object, similar to jest.spyOn().
-   */
-  spy (o,f) {
-    const origin = o[f]
-    const fn = function (...args) {
-      ++fn.called
-      return origin.apply(this,args)
-    }
-    fn.called = 0
-    fn.restore = ()=> o[f] = origin
-    return o[f] = fn
-  }
-
-  /**
-   * For usage in repl, e.g. var test = await cds.test()
-   */
-  then (resolve) {
-    if (this.server) {
-      resolve({ server: this.server, url: this.url })
-    } else {
-      this.cds.once('listening', resolve)
-    }
-  }
-
-  /**
-   * Captures console.log output.
-   */
-  log (_capture) {
-    const {console} = global, {format} = require('util')
-    const log = { output: '' }
-    beforeAll(()=> global.console = { __proto__: console,
-      log: _capture ??= (..._)=> log.output += format(..._)+'\n',
-      info: _capture,
-      warn: _capture,
-      debug: _capture,
-      trace: _capture,
-      error: _capture,
-      timeEnd: _capture, time: ()=>{},
-    })
-    afterAll (log.release = ()=>{ log.output = ''; global.console = console })
-    afterEach (log.clear = ()=>{ log.output = '' })
-    return log
-  }
-
-  /**
-   * Silences all console log output, e.g.: CDS_TEST_SILENT=y jest/mocha ...
-   */
-  silent(){
-    global.console = { __proto__: console,
-      log: ()=>{},
-      info: ()=>{},
-      warn: ()=>{},
-      debug: ()=>{},
-      trace: ()=>{},
-      error: ()=>{},
-      time: ()=>{},
-      timeEnd: ()=>{},
-    }
-    return this
-  }
-  /** @deprecated */ verbose(){ return this }
-
-
-  /**
-   * Lazily loads and returns an instance of chai
-   */
-  get chai() {
-    const chai = require('chai')
-    chai.use (require('chai-subset'))
-    const chaip = require('chai-as-promised')
-    chai.use (chaip.default/*v8 on ESM*/ ?? chaip/*v7*/)
-    return chai
-    function require (mod) { try { return module.require(mod) } catch(e) {
-      if (e.code === 'MODULE_NOT_FOUND')
-        throw new Error (`Failed to load required package '${mod}'. Please add it thru:`
-        + `\n  npm add -D chai chai-as-promised chai-subset`, {cause: e})
-      else if (e.name === 'SyntaxError') // Jest stumbling over ESM
-        throw new Error (`Jest failed to load ESM package '${mod}'.`
-        + `\nDowngrade '${mod}' to the major version before, or use a different test runner like 'node --test'.\n`, {cause: e})
-      else if (e.code === 'ERR_REQUIRE_ESM') // node --test on older Node versions
-        throw new Error (`Failed to load ESM package '${mod}'. This only is supported on Node.js >= 23.`
-          + `\nUpgrade your Node.js installation or downgrade '${mod}' to the major version before.\n`, {cause: e})
-      else throw e
-    }}
-  }
-  set expect(x) { super.expect = x }
-  get expect() { return this.chai.expect }
-  get assert() { return this.chai.assert }
-  get should() { return this.chai.should() }
-}
-
-
-/** @type Test & ()=>Test */
-module.exports = exports = Object.assign ((..._) => (new Test).run(..._), { Test })
-
-// Set prototype to allow usages like cds.test.in(), cds.test.log(), ...
-Object.setPrototypeOf (exports, Test.prototype)
-
-
-// Provide same global functions for jest and mocha
-;(function _support_jest_and_mocha() {
-  const _global = p => Object.getOwnPropertyDescriptor(global,p)?.value
-  const is_jest = _global('beforeAll')
-  const is_mocha = _global('before')
-  const repl = global.cds?.repl || process.env.CDS_TEST_FAKE // for crazy forks in some cds-dk and mtxs tests ;)
-  if (repl) { // it's cds repl
-
-    global.beforeAll  = global.before    = (msg,fn) => (fn||msg)()
-    global.afterAll   = global.after     = (msg,fn) => repl.on?.('exit',fn||msg)
-    global.beforeEach = global.afterEach = ()=>{}
-    global.describe   = ()=>{}
-    global.expect = require('./expect')
-
-  } else if (is_mocha) { // it's mocha
-
-    global.describe.each = global.it.each = each
-    global.beforeAll = before
-    global.afterAll = after
-    global.test = it
-    global.xtest = test.skip
-    global.xdescribe = describe.skip
-    process.env.CDS_TEST_SILENT == 'false' || exports.silent()
-
-  } else if (is_jest) { // it's jest
-
-    global.before = (msg,fn) => global.beforeAll(fn||msg)
-    global.after  = (msg,fn) => global.afterAll(fn||msg)
-
-  } else { // it's node --test
-
-    const { describe, suite, test, before, after, beforeEach, afterEach } = require('node:test')
-    describe.each = test.each = describe.skip.each = test.skip.each = each
-    global.describe = describe; global.xdescribe = describe.skip
-    global.test = global.it = test; global.xtest = test.skip
-    global.beforeAll = global.before = (msg,fn=msg) => {
-      if (fn.length > 0) { const f = fn; fn = (_,done)=>f(done) }
-      return before(fn) // doesn't work for some reason
-    }
-    // global.beforeAll = global.before = (msg,fn) => {
-    //   if (!fn) [msg,fn] = ['',msg]
-    //   return test('<before> '+ msg, (_,done) => fn(done))
-    // }
-    global.afterAll = global.after = (msg,fn) => after(fn||msg)
-    global.beforeEach = beforeEach
-    global.afterEach = afterEach
-    global.expect = require('./expect')
-    // suite was introduced in Node 22
-    suite?.('<next>', ()=>{}) //> to signal the start of a test file
-
-  }
-
-  // required for test.each in mocha and node --test
-  function each (table) {
-    const {format} = require('util')
-    return (msg,fn) => Promise.all (table.map (each => {
-      if (!Array.isArray(each))  each = [each]
-      return this (format(msg,...each), ()=> fn(...each))
-    }))
-  }
-})()
-
-}
-
-function require_local(id) {
-  const cds = require('..')
-  try {
-    return require(require.resolve(id, { paths: [cds.root, __dirname] }))
-  } catch (e) {
-    if (e.code !== 'MODULE_NOT_FOUND')  throw e
-  }
-}
+module.exports = require ('@cap-js/cds-test')

package/lib/utils/cds-utils.js

@@ -18,9 +18,9 @@ exports = module.exports = new class {
     return super.format = format
   }
   get uuid() { return super.uuid = require('crypto').randomUUID }
-  get yaml() { return super.yaml = require('@sap/cds-foss').yaml }
-  get pool() { return super.pool = require('@sap/cds-foss').pool }
+  get yaml() { const yaml = require('js-yaml'); return super.yaml = Object.assign(yaml,{parse:yaml.load}) }
   get tar()  { return super.tar = process.platform === 'win32' && _tarLib() ? require('./tar-lib') : require('./tar') }
+  get _unit()  { return super._unit = require('./unit') }
 }
 
 /** @type {import('node:path')} */
@@ -52,6 +52,22 @@ exports.results = oa => {
 }
 
 
+/**
+ * Simple helper to deep-merge two or more objects.
+ * Entries from `xs` overwrite entries in `o`.
+ * @example cds.utils.merge({foo:1},{bar:2},{baz:3})
+ * @returns `o` with entries from `xs` merged in.
+ */
+exports.merge = function merge (o,...xs) {
+  let v; for (let x of xs) for (let k in x)
+    if (k === '__proto__' || k === 'constructor') continue //> avoid prototype pollution
+    else o[k] = is_object(v=x[k]) ? merge(o[k]??={},v) : v
+  return o
+}
+const is_object = x => typeof x === 'object' && x !== null && !is_array(x)
+const is_array = Array.isArray
+
+
 /**
  * Should be used in data providers, i.e., db services to return single
  * rows in response to SELECT.one queries.

package/lib/utils/tar.js

@@ -80,8 +80,8 @@ const tarInfo = async (info) => {
 
 const logDebugTar = async () => {
   const LOG = cds.log('tar')
-  if (!LOG?._debug) return 
-  try {    
+  if (!LOG?._debug) return
+  try {
     LOG (`tar path: ${await tarInfo('path')}`)
     LOG (`tar version: ${await tarInfo('version')}`)
   } catch (err) {
@@ -113,7 +113,7 @@ const logDebugTar = async () => {
  * - `.then()` collects the tar output into an in-memory `Buffer`
  * - `.to()` is a convenient shortcut to pipe the output into a write stream
  */
-exports.create = async (dir='.', ...args) => {
+exports.create = (dir='.', ...args) => {
   logDebugTar()
   if (typeof dir === 'string') dir = _resolve(dir)
   if (Array.isArray(dir)) [ dir, ...args ] = [ cds.root, dir, ...args ]
@@ -127,9 +127,7 @@ exports.create = async (dir='.', ...args) => {
     }
     args.push('.')
     if (Array.isArray(args[0])) {
-      temp = await createTemp(dir, args[0])
-      args.shift()
-      c = spawnDir(temp, args)
+      c = createTemp(dir, args.shift()) .then (t => spawnDir(t,args))
     } else {
       c = spawnDir(dir, args)
     }
@@ -210,7 +208,7 @@ exports.extract = (archive, ...args) => ({
     const x = spawn('tar', ['xf', win(input), '-C', win(dest), ...args])
     if (archive === '-') return x.stdin
     if (Buffer.isBuffer(archive)) archive = require('stream').Readable.from (archive)
-    if (typeof archive !== 'string') archive.pipe (x.stdin)
+    if (typeof archive !== 'string') (archive.stdout || archive) .pipe (x.stdin)
     let stdout='', stderr=''
     x.stdout.on ('data', d => stdout += d)
     x.stderr.on ('data', d => stderr += d)
@@ -269,7 +267,7 @@ exports.t = tar.tf = tar.list
  * @example fs.createReadStream('t.tar') .pipe (tar.x.to('dest/dir'))
  * @returns `stdin` of the tar child process
  */
- exports.extract.to = function (..._) { return this().to(..._) }
+ exports.extract.to = function (..._) { return this('-').to(..._) }
 
 
 

package/lib/utils/unit.js

@@ -0,0 +1,19 @@
+module.exports.time2ms = timeout => {
+  const match = timeout.match(/^([0-9]+)(w|d|h|hrs|min)$/)
+  if (!match) return
+
+  const [, val, t] = match
+  switch (t) {
+    case 'w':
+      return val * 1000 * 3600 * 24 * 7
+    case 'd':
+      return val * 1000 * 3600 * 24
+    case 'h':
+    case 'hrs':
+      return val * 1000 * 3600
+    case 'min':
+      return val * 1000 * 60
+    default:
+      return val
+  }
+}

package/libx/_runtime/.eslintrc

@@ -4,7 +4,7 @@
     "jest": true
   },
   // "extends": ["prettier-standard"],
-  "ignorePatterns": ["**/okra/**/*.js"],
+  "ignorePatterns": [],
   "rules": {
     "no-console": ["error"],
     "complexity": ["error"], // > default threshold: 20

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

@@ -2,14 +2,10 @@ const cds = require('../../cds')
 const LOG = cds.log('app')
 const templatePathSerializer = require('../../common/utils/templateProcessorPathSerializer')
 
-// REVISIT: replace with cds.Request
-const getEntry = require('../../common/error/entry')
-
 const typeCheckers = require('../../../common/assert/type-strict')
 const { 'cds.Decimal': checkDecimal } = typeCheckers
 const { checkMandatory, checkEnum, checkRange, checkFormat } = require('../../../common/assert/validation')
 
-const ASSERT_VALID_ELEMENT = 'ASSERT_VALID_ELEMENT'
 const ASSERT_RANGE = 'ASSERT_RANGE'
 const ASSERT_FORMAT = 'ASSERT_FORMAT'
 const ASSERT_DATA_TYPE = 'ASSERT_DATA_TYPE'
@@ -49,11 +45,12 @@ const assertError = (code, element, value, key, path) => {
     args: args ?? [name ?? key]
   }
 
-  const assertError = Object.assign(error, getEntry(errorEntry))
+  const assertError = Object.assign(error, errorEntry)
   Object.assign(assertError, {
     entity: element.parent && element.parent.name,
     element: name, // > REVISIT: when is error.element needed?
     type: element.items ? element.items._type : type,
+    status: 400,
     value
   })
 
@@ -69,58 +66,6 @@ const assertError = (code, element, value, key, path) => {
   return assertError
 }
 
-// Limitation: depth 1
-const checkComplexType = ([key, value], elements, ignoreNonModelledData) => {
-  let found = false
-
-  for (const objKey in elements) {
-    if (objKey.startsWith(`${key}_`)) {
-      const element = elements[objKey]
-      const typeChecker = typeCheckers[element._type]
-      found = true
-
-      const nestedData = value[objKey.substring(key.length + 1)]
-      // check existence of nestedData to not stumble across not-provided, yet-modelled type parts with depth > 1
-      if (nestedData && !typeChecker(nestedData)) {
-        return false
-      }
-    }
-  }
-
-  return found || ignoreNonModelledData
-}
-
-// TODO: what fails if no-op?!
-const checkStaticElementByKey = (definition, key, value, result = [], ignoreNonModelledData = true) => {
-  const elementsOrParameters = definition.elements || definition.params
-  if (!elementsOrParameters) return result
-  const elementOrParameter = elementsOrParameters[key]
-
-  if (!elementOrParameter) {
-    if (!checkComplexType([key, value], elementsOrParameters, ignoreNonModelledData)) {
-      result.push(assertError(ASSERT_VALID_ELEMENT, { name: key }))
-    }
-
-    return result
-  }
-
-  let typeChecker
-  if (elementOrParameter.isUUID && definition.name === 'ProvisioningService.tenant') {
-    // > old SCP accounts don't have UUID ids
-    typeChecker = typeCheckers['cds.String']
-  } else {
-    typeChecker = typeCheckers[elementOrParameter._type]
-  }
-
-  if (typeChecker && !typeChecker(value, elementOrParameter)) {
-    // code, entity, element, value
-    const args = [typeof value === 'string' ? '"' + value + '"' : value, elementOrParameter._type]
-    result.push(assertError({ code: ASSERT_DATA_TYPE, args }, elementOrParameter, value, key))
-  }
-
-  return result
-}
-
 /**
  * @param {import('../../types/api').InputConstraints} constraints
  */
@@ -176,19 +121,6 @@ const checkInputConstraints = ({ element, value, errors, key, pathSegmentsInfo }
   return errors
 }
 
-// TODO: what fails if no-op?!
-const checkStatic = (definition, data, ignoreNonModelledData = false) => {
-  if (!Array.isArray(data)) data = [data]
-
-  return data.reduce((result, row) => {
-    return Object.entries(row)
-      .filter(([, value]) => value !== null && value !== undefined)
-      .reduce((result, [key, value]) => {
-        return checkStaticElementByKey(definition, key, value, result, ignoreNonModelledData)
-      }, result)
-  }, [])
-}
-
 /**
  * Check whether the target entity referenced by the association (the reference's target) exists and assert an error if
  * the the reference's target doesn't exist.
@@ -244,8 +176,6 @@ const assertTargets = async (assertMap, errors) => {
 }
 
 module.exports = {
-  checkStatic,
-  checkStaticElementByKey,
   checkInputConstraints,
   assertTargets
 }

package/libx/_runtime/cds.js

@@ -15,10 +15,17 @@ cds.extend(service).with(require('./common/aspects/service'))
  * Added to cds.Service so it can be reused in cds.ApplicationService and cds.RemoteService.
  */
 cds.Service.prototype._requires_resolving = function (req) {
-  const already_resolved = req._resolved
-  const belongs_to_me = req.target?.name?.startsWith(this.definition?.name + '.')
-  const is_resolvable = this.model && _is_simple_cqn_query(req.query)
-  const requires_resolving = !(already_resolved || belongs_to_me) && is_resolvable
-  return requires_resolving
+  if (req._resolved) return false
+  if (!this.model) return false
+  if (!req.query || typeof req.query !== 'object') return false
+  if (Array.isArray(req.query)) return false
+  if (Object.keys(req.query).length === 0) return false
+  if (req.target?.name?.startsWith(this.definition?.name + '.')) return false
+  else return true
+}
+
+// FIXME: move resolve out of cds.ql !
+const resolve = require('../../lib/ql/resolve')
+cds.Service.prototype.resolve = function (query) {
+  return resolve(query, this)
 }
-const _is_simple_cqn_query = q => typeof q === 'object' && q !== null && !Array.isArray(q) && Object.keys(q).length > 0

package/libx/_runtime/common/Service.js

@@ -1,6 +1,5 @@
 const cds = require('../cds')
 
-const { findQueryTarget } = require('./utils/resolveView')
 const postProcess = require('./utils/postProcess')
 
 /**
@@ -8,111 +7,70 @@ const postProcess = require('./utils/postProcess')
  */
 class ApplicationService extends cds.Service {
   init() {
-    const clazz = this.constructor,
-      { generics } = clazz
-    for (let each of generics) clazz[each].call(this)
+    const clazz = this.constructor
+    for (let each of clazz.generics) clazz[each].call(this)
     return super.init()
   }
-
   static get generics() {
-    let generics = Reflect.getOwnPropertyDescriptor(this, '_generics')
-    if (generics) return generics.value
-    else {
-      const set = new Set(this.__proto__.generics)
-      for (let p of Reflect.ownKeys(this)) if (p.startsWith('handle_')) set.add(p)
-      Object.defineProperty(this, '_generics', { value: (generics = [...set]) })
-    }
-    return generics
-  }
-
-  static handle_authorization() {
-    require('./generic/auth').call(this)
+    return (this._generics ??= new Set([
+      ...(this.__proto__.generics || []),
+      ...Reflect.ownKeys(this).filter(p => p.startsWith('handle_'))
+    ]))
   }
 
-  static handle_etags() {
-    require('./generic/etag').call(this)
+  static get handle_authorization() {
+    return require('./generic/auth')
   }
 
-  static handle_validations() {
-    require('./generic/input').call(this)
+  static get handle_etags() {
+    return require('./generic/etag')
   }
 
-  static handle_stream_property() {
-    require('./generic/stream').call(this)
+  static get handle_validations() {
+    return require('./generic/input')
   }
 
-  static handle_puts() {
-    require('./generic/put').call(this)
+  static get handle_stream_property() {
+    return require('./generic/stream-only')
   }
 
-  static handle_temporal_data() {
-    require('./generic/temporal').call(this)
+  static get handle_temporal_data() {
+    return require('./generic/temporal')
   }
 
-  static handle_localized_data() {
-    // TODO: can we move handling of localized data here?
+  static get handle_paging() {
+    return require('./generic/paging') // > paging must be executed before sorting
   }
 
-  static handle_managed_data() {
-    // TODO: can we move handling of managed data here?
+  static get handle_sorting() {
+    return require('./generic/sorting')
   }
 
-  static handle_paging() {
-    require('./generic/paging').call(this) // > paging must be executed before sorting
-    require('./generic/sorting').call(this)
+  static get handle_drafts() {
+    return require('../fiori/lean-draft')
   }
 
-  static handle_fiori() {
-    require('../fiori/lean-draft').impl.call(this)
-  }
-
-  static handle_crud() {
-    require('./generic/crud').impl.call(this)
+  static get handle_crud() {
+    return require('./generic/crud')
   }
 
   // Overload .handle in order to resolve projections up to a definition that is known by the remote service instance.
   // Result is post processed according to the inverse projection in order to reflect the correct result of the original query.
   async handle(req) {
-    let result
-    let target = req.target
-
     // REVISIT: We must not allow arbitrary CQNs, so this shouldn't be here!
-    if (!this._requires_resolving(req)) {
-      result = await super.handle(req)
-    } else {
-      const query = cds.ql.resolve(req.query, this)
-      if (!query) throw new Error(`Target ${target.name} cannot be resolved for service ${this.name}`)
-      target = findQueryTarget(query) || req.target
-      // REVISIT: get rid of _4odata
-      if (req.query.SELECT?._4odata) Object.defineProperty(query.SELECT, '_4odata', { value: true })
-      // we need to provide target explicitly because it's cached within ensure_target
-      const _req = new cds.Request({ query, target, _resolved: true })
-      result = await super.dispatch(_req)
-      result = postProcess(query, result, this)
-    }
-
-    return result
-  }
-
-  /**
-   * @param serviceImpl
-   * @deprecated since version 1.11.0 - use Service.prepend instead
-   */
-  with(serviceImpl) {
-    return this.prepend(serviceImpl)
-  }
-
-  /**
-   * Registers custom handlers.
-   * @param {string | object | Function} serviceImpl - init function to register custom handlers.
-   */
-  impl(serviceImpl) {
-    if (typeof serviceImpl === 'string') serviceImpl = require(serviceImpl)
-    return this.prepend(serviceImpl)
+    if (!this._requires_resolving?.(req)) return super.handle(req)
+    // rewrite the query to a target entity served by this service...
+    const query = this.resolve(req.query)
+    if (!query) throw new Error(`Target ${req.target.name} cannot be resolved for service ${this.name}`)
+    const target = query._target || req.target
+    // we need to provide target explicitly because it's cached within ensure_target
+    const _req = new cds.Request({ query, target, _resolved: true })
+    return await this.dispatch(_req).then(result => postProcess(query, result, this))
   }
 }
 
 // NOTE: getRestrictions is VERY INOFFICIAL!!!
+//> only kept temporary because of an ill-devised usage in AMS plugin
 const { getRestrictions } = require('./generic/auth/restrictions')
 ApplicationService.prototype.getRestrictions = function (..._) {
   return getRestrictions.call(this, ..._)