@sap/cds 8.5.1 → 8.6.1

package/lib/ql/cqn.d.ts

@@ -0,0 +1,146 @@
+/**
+ * `INSERT` and `UPSERT` queries are represented by the same internal
+ * structures. The `UPSERT` keyword is used to indicate that the
+ * statement should be updated if the targeted data exists.
+ * The `into` property specifies the target entity.
+ *
+ * The data to be inserted or updated can be specified in different ways:
+ *
+ * - in the `entries` property as deeply nested records.
+ * - in the `columns` and `values` properties as in SQL.
+ * - in the `columns` and `rows` properties, with `rows` being array of `values`.
+ * - in the `from` property with a `SELECT` query to provide the data to be inserted.
+ *
+ * The latter is the equivalent of SQL's `INSERT INTO ... SELECT ...` statements.
+ */
+export class INSERT { INSERT: UPSERT['UPSERT'] }
+export class UPSERT { UPSERT: {
+  into      : ref
+  entries?  : data[]
+  columns?  : string[]
+  values?   : scalar[]
+  rows?     : scalar[][]
+  from?     : SELECT
+}}
+
+
+/**
+ * `UPDATE` queries are used to capture modifications to existing data.
+ * They support a `where` clause to specify the rows to be updated,
+ * and a `with` clause to specify the new values. Alternatively, the
+ * `data` property can be used to specify updates with plain data only.
+ */
+export class UPDATE { UPDATE: {
+  entity  : ref
+  where?  : expr
+  data    : data
+  with    : changes
+}}
+
+
+/**
+ * `DELETE` queries are used to remove data from a target datasource.
+ * They support a `where` clause to specify the rows to be deleted.
+ */
+export class DELETE { DELETE: {
+  from    : ref
+  where?  : expr
+}}
+
+
+/**
+ * `SELECT` queries are used to retrieve data from a target datasource,
+ * and very much resemble SQL's `SELECT` statements, with these noteworthy
+ * additions:
+ *
+ * - The `from` clause supports `{ref}` paths with infix filters.
+ * - The `columns` clause supports deeply nested projections.
+ * - The `count` property requests the total count, similar to OData's `$count`.
+ * - The `one` property indicates that only a single record object shall be
+ *   returned instead of an array.
+ *
+ * Also, CDS, and hence CQN, supports minimalistic `SELECT` statements with a `from`
+ * as the only mandatory property, which is equivalent to SQL's `SELECT * from ...`.
+ */
+export class SELECT { SELECT: {
+  distinct?   : true
+  count?      : true
+  one?        : true
+  from        : source
+  columns?    : column[]
+  where?      : xo[]
+  having?     : xo[]
+  groupBy?    : expr[]
+  orderBy?    : order[]
+  limit?      : { rows: val, offset: val }
+}}
+
+type source = OneOf< ref &as | SELECT | {
+  join : 'inner' | 'left' | 'right'
+  args : [ source, source ]
+  on?  : expr
+}>
+
+type column = OneOf< '*' | expr &as &cast | ref &as & OneOf<(
+  { expand?: column[] } |
+  { inline?: column[] }
+)> &infix >
+
+type order = expr & {
+  sort  : 'asc' | 'desc'
+  nulls : 'first' | 'last'
+}
+
+
+interface changes { [elm:string]: OneOf< scalar | expr | changes | changes[] >}
+interface data { [elm:string]: OneOf< scalar | data | data[] >}
+interface as { as?: name }
+interface cast { cast?: {type:name} }
+
+interface infix {
+  orderBy?  : order[]
+  where?    : expr
+  limit?    : { rows: val, offset: val }
+}
+
+
+/**
+ * Expressions can be entity or element references, query parameters,
+ * literal values, lists of all the former, function calls, sub selects,
+ * or compound expressions.
+ */
+export type expr  = OneOf< ref | val | xpr | list | func | param | SELECT >
+export type ref   = { ref: OneOf< name | { id:name &infix } >[] }
+export type val   = { val: scalar }
+export type xpr   = { xpr: xo[] }
+export type list  = { list: expr[] }
+export type func  = { func: string, args: expr[] }
+export type param = { ref: [ '?' | number | string ], param: true }
+
+/**
+ * This is used in `{xpr}` objects as well as in `SELECT.where` clauses to
+ * represent compound expressions as flat `xo` sequences.
+ * Note that CQN by intent does not _understand_ expressions and therefore
+ * keywords and operators are just represented as plain strings.
+ * This allows us to translate to and from any other query languages,
+ * including support for native SQL features.
+ */
+type xo       = OneOf< expr | keyword | operator >
+type operator = '=' | '==' | '!=' | '<' | '<=' | '>' | '>='
+type keyword  = 'in' | 'like' | 'and' | 'or' | 'not'
+type scalar   = number | string | boolean | null
+type name     = string
+
+
+
+// ---------------------------------------------------------------------------
+//  maybe coming later...
+
+declare class CREATE { CREATE: {} }
+declare class DROP { DROP: {} }
+
+
+// ---------------------------------------------------------------------------
+//  internal helpers...
+
+type OneOf<U> = Partial<(U extends any ? (k:U) => void : never) extends (k: infer I) => void ? I : never>

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('./srv-api')> }
+ * @returns { Promise<import('./cds.ServiceClient')> }
  */
 connect.to = (datasource, options) => {
   let Service = cds.service.factory
@@ -34,7 +34,7 @@ connect.to = (datasource, options) => {
   }
   const promise = (async()=>{
     TRACE?.time(`cds.connect.to ${datasource}`.padEnd(22).slice(0,22))
-    const o = Service === cds.service.factory ? options4 (datasource, options) : {}
+    const o = Service.is_factory ? options4 (datasource, options) : {}
     const m = await model4 (o)
     // check if required service definition exists
     const required = cds.requires[datasource]
@@ -43,7 +43,7 @@ connect.to = (datasource, options) => {
       throw new Error (`No service definition found for '${required.service || datasource}'`)
     }
     // construct new service instance
-    let srv = await new Service (datasource,m,o); await srv._init()
+    let srv = await new Service (datasource,m,o); await Service.init?.(srv)
     if (o.outbox) srv = cds.outboxed(srv)
     if (datasource) {
       if (datasource === 'db') cds.db = srv

package/lib/srv/cds-serve.js

@@ -1,5 +1,5 @@
 const cds = require ('..')
-const { Service } = cds.service.factory
+const Service = cds.service.factory
 const _pending = cds.services._pending ??= {}
 const _ready = Symbol()
 const TRACE = cds.debug('trace')
@@ -84,7 +84,7 @@ module.exports = function cds_serve (som, _options) { // NOSONAR
   // cds.services, so they'll be found when they cds.connect to each others.
   let ready = provided.then (()=> Promise.all (all.map (async srv => {
     if (o.service && o.service._is_service_instance) return srv
-    cds.services[srv.name] = await srv._init()
+    cds.services[srv.name] = await Service.init (srv)
     cds.service.providers.push (srv)
     if (srv[_ready]) srv[_ready](srv)
     return srv

package/lib/srv/cds.Service.js

@@ -0,0 +1,132 @@
+//////////////////////////////////////////////////////////////
+//
+//  PLEASE DO NOT RUN prettier ON THIS FILE
+//
+//////////////////////////////////////////////////////////////
+
+const cds = require('../index')
+const EventHandlers = require('./srv-handlers')
+
+
+/**
+ * Private base class which contains all model & reflection-related APIs.
+ */
+class ModeledService {
+
+  /**
+   * Constructs a new instance. Argument name can be omitted if the model contains only one service.
+   * @param {string} [name] - the name of the service
+   * @param {object} [model] - the CSN model
+   * @param {object} [options] - additional options
+   * @param {string} [options.kind] - the kind of the service
+   * @param {function} [options.impl] - the implementation function
+   */
+  constructor (model, name, options={}) {
+    this.name = name || new.target.name
+    this.options = options
+    if (options.kind) this.kind = options.kind // shortcut
+    if (model) this.model = model
+  }
+
+  /** @param {import('../core/linked-csn').LinkedCSN} csn */
+  set model (csn) {
+    super.model = csn ? cds.compile.for.nodejs(csn) : undefined
+  }
+
+  /**
+   * Lazy get the service definition from this.model
+   * @type import('../core/classes').service
+   */
+  get definition() {
+    const defs = this.model?.definitions; if (!defs) return super.definition = undefined
+    return super.definition = defs[this.options.service] || defs[this.name]
+  }
+
+  /** The namespace always is the service definition name */
+  get namespace()  {
+    return super.namespace  = this.definition?.name
+    || this.model?.namespace
+    || !this.isDatabaseService && !/\W/.test(this.name) && this.name
+    || undefined
+  }
+
+  // Reflection methods
+  get entities()   { return super.entities = this.reflect (d => d.kind === 'entity') }
+  get events()     { return super.events   = this.reflect (d => d.kind === 'event') }
+  get types()      { return super.types    = this.reflect (d => !d.kind || d.kind === 'type') }
+  get actions()    { return super.actions  = this.reflect (d => d.kind === 'action' || d.kind === 'function') }
+  /** @deprecated */ get operations() { return this.actions } // compatibility
+  reflect(filter) { return this.model?.childrenOf (this.namespace, filter) || [] }
+}
+
+
+class Service extends ModeledService {
+
+  constructor (name, model, options) {
+    if (typeof name === 'object') {
+      [ model, options ] = [ name, model ]
+      let srv = cds.linked(model).services[0] || cds.error.expected `${{model}} passed as first argument to be a CSN with a single service definition`
+      name = srv.name
+    }
+    super (model, name, options)
+  }
+
+  /**
+   * Empty init() function to allow custom code to always call super.init()
+   * without having to care for if .init() exists.
+  */
+ init(){ return this }
+
+ // Event Handlers Registration API
+  handlers = new EventHandlers
+  prepend (fn)      { return this.handlers.prepend.call (this,fn) }
+  before  (...args) { return this.handlers.register (this, 'before', ...args) }
+  on      (...args) { return this.handlers.register (this, 'on',     ...args) }
+  after   (...args) { return this.handlers.register (this, 'after',  ...args) }
+  reject  (e, path) { return this.handlers.register (this, '_initial', e, path,
+    r => r.reject (405, `Event "${r.event}" not allowed for entity "${r.path}".`)
+  )}
+
+  // Event Dispatching API
+  dispatch (req) {
+    const { dispatch } = require('./srv-dispatch')
+    return (Service.prototype.dispatch = dispatch) .call (this,req)
+  }
+
+  handle (req) {
+    const { handle } = require('./srv-dispatch')
+    return (Service.prototype.handle = handle) .call (this,req)
+  }
+
+  tx (...args) {
+    return (Service.prototype.tx = require('./srv-tx')) .call (this,...args)
+  }
+
+  /**
+   * @deprecated Flag to control whether this service is extensible.
+   * Can be overridden by subclasses.
+   */
+  get isExtensible() { // REVISIT: can we eliminate this?
+    return this.model === cds.model && !this.name?.startsWith('cds.xt.')
+  }
+
+  /** @deprecated */ get _handlers() { return this.handlers }
+}
+
+/** @deprecated */ Service.prototype.transaction = function(...args) { return this.tx(...args) }
+/** @deprecated */ Service.prototype._implicit_next = cds.env.features.implicit_next
+
+Service.prototype._is_service_instance = true  //> for factory
+Service._is_service_class = true              //> for factory
+
+//--------------------------------------------------------------------------
+// EXPERIMENTAL: It is not decided yet, whether we should keep the stuff below
+// => Please do not use anywhere!
+Service.prototype.onSucceeded = function (...args) { return _req_on (this, 'succeeded', ...args) }
+Service.prototype.onFailed = function (...args) { return _req_on (this, 'failed', ...args) }
+const _req_on = (srv, succeeded_or_failed, event, path, handler) => {
+  if (!handler) [path,handler] = [undefined,path]
+  return srv.before (event,path, req => req.on(succeeded_or_failed,handler))
+}
+
+module.exports = Service

package/lib/srv/{srv-api.js → cds.ServiceClient.js}

@@ -4,33 +4,19 @@
 //
 //////////////////////////////////////////////////////////////
 
-const cds = require('..'), { Event, Request } = cds
-const add_methods_to = require ('./srv-methods')
+const cds = require('../index'), { Event, Request } = cds
+const Service = require('./cds.Service')
 
-class Service extends require('./srv-handlers') {
+const is_rest = x => x && typeof x === 'string' && x[0] === '/'
+const is_query = x => x && x.bind || is_array(x) && !x.raw
+const is_array = (x) => Array.isArray(x) && !x.raw
+const is_object = (x) => typeof x === 'object'
 
-  constructor (name, model, o) {
-    if (is_object(name)) {
-      [ model, o ] = [ name, model ]
-      let srv = cds.linked(model).services[0] || cds.error.expected `${{model}} passed as first argument to be a CSN with a single service definition`
-      name = srv.name
-    }
-    super (name || new.target.name) .options = o || (o={})
-    if (o.kind) this.kind = o.kind // shortcut
-    if (model) this.model = model
-  }
+class ServiceClient extends Service {
 
-  /**
-   * Subclasses may override this to prepare the given model appropriately
-   */
-  set model (csn) {
-    if (csn) {
-      let {definitions:defs={}} = super.model = cds.compile.for.nodejs(csn)
-      super.definition = defs[this.options?.service] || defs[this.name]
-      add_methods_to (this)
-    } else {
-      super.model = undefined
-    }
+  constructor (...args) {
+    super(...args)
+    this.decorate()
   }
 
   /**
@@ -50,7 +36,7 @@ class Service extends require('./srv-handlers') {
   send (method, path, data, headers) {
     const req = method instanceof Request ? method : new Request (
       is_object(method) ? method :
-      is_object(path) ? { method, data:path, headers:data }
+      is_object(path) ? path.is_linked ? { method, entity:path, data, headers } : { method, data:path, headers:data }
       : { method, path, data, headers }
     )
     return this.dispatch (req)
@@ -65,7 +51,8 @@ class Service extends require('./srv-handlers') {
    * Querying API to send synchronous requests...
    */
   run (query, data) {
-    if (typeof query === 'function') {
+    if (query.raw) [ query, data ] = [ cds.ql (...arguments) ]
+    else if (typeof query === 'function') {
       const fn = query; if (this.context) return fn(this)     // if this is a tx -> run fn with this
       const ctx = cds.context, tx = ctx?.tx                   // is there an (open) outer tx? ...
       if (!tx || tx._done === 'committed') return this.tx(fn) // no -> run fn with root tx
@@ -75,7 +62,7 @@ class Service extends require('./srv-handlers') {
     const req = new Request ({ query, data })
     return this.dispatch (req)
   }
-  read   (...args) { return is_query(args[0]) ? this.run(...args) : SELECT(...args).bind(this) }
+  read   (...args) { return is_query(args[0]) ? this.run(...args) : SELECT.read(...args).bind(this) }
   insert (...args) { return INSERT(...args).bind(this) }
   create (...args) { return INSERT.into(...args).bind(this) }
   update (...args) { return UPDATE.entity(...args).bind(this) }
@@ -92,29 +79,6 @@ class Service extends require('./srv-handlers') {
     return this.run (query, data) .then (rows => rows.forEach(callback) || rows)
   }
 
-  /**
-   * Model Reflection API...
-   */
-  get namespace()  {
-    return super.namespace  = this.definition?.name
-    || this.model?.namespace
-    || !this.isDatabaseService && !/\W/.test(this.name) && this.name
-    || undefined
-  }
-  get entities()   { return super.entities   = _reflect (this, d => d.kind === 'entity') }
-  get events()     { return super.events     = _reflect (this, d => d.kind === 'event') }
-  get types()      { return super.types      = _reflect (this, d => !d.kind || d.kind === 'type') }
-  get actions()    { return super.actions    = _reflect (this, d => d.kind === 'action' || d.kind === 'function') }
-  get operations() { return super.operations = _reflect (this, d => d.kind === 'action' || d.kind === 'function') }
-
-  /**
-   * Flag to control whether this service is extensible.
-   * Can be overridden by subclasses.
-   */
-  get isExtensible() {
-    return this.model === cds.model && !this.name?.startsWith('cds.xt.') // REVISIT cds.xt name check should move to respective services
-  }
-
   /**
    * Subclasses may override this to free resources when
    * tenants offboard or the service is disposed.
@@ -126,26 +90,7 @@ class Service extends require('./srv-handlers') {
     // }
     // delete cds.services[this.name] // REVISIT: this is in contrast to some tests
   }
-
-  get path() { return super.path = cds.service.protocols.path4(this) }
-  set path(p) { super.path = p }
-
-  get endpoints() { return super.endpoints = cds.service.protocols.endpoints4(this) }
-  set endpoints(p) { super.endpoints = p }
 }
+ServiceClient.prototype.decorate = require('./srv-methods')
 
-const { dispatch, handle } = require('./srv-dispatch')
-Service.prototype.tx = require('./srv-tx')
-Service.prototype.handle = handle
-Service.prototype.dispatch = dispatch
-Service.prototype.transaction = Service.prototype.tx
-Service.prototype._implicit_next = cds.env.features.implicit_next
-Service.prototype._is_service_instance = Service._is_service_class = true //> for factory
-module.exports = Service
-
-// Helpers...
-const _reflect = (srv,filter) => !srv.model ? [] : srv.model.childrenOf (srv.namespace,filter)
-const is_rest = x => x && typeof x === 'string' && x[0] === '/'
-const is_query = x => x && x.bind || is_array(x) && !x.raw
-const is_array = (x) => Array.isArray(x) && !x.raw
-const is_object = (x) => typeof x === 'object'
+module.exports = ServiceClient

package/lib/srv/cds.ServiceProvider.js

@@ -0,0 +1,20 @@
+//////////////////////////////////////////////////////////////
+//
+//  PLEASE DO NOT RUN prettier ON THIS FILE
+//
+//////////////////////////////////////////////////////////////
+
+const ServiceClient = require('./cds.ServiceClient')
+const cds = require('../index')
+
+
+class ServiceProvider extends ServiceClient {
+
+  get endpoints() { return super.endpoints = cds.service.protocols.endpoints4(this) }
+  set endpoints(p) { super.endpoints = p }
+  get path() { return super.path = cds.service.protocols.path4(this) }
+  set path(p) { super.path = p }
+
+}
+
+module.exports = ServiceProvider

package/lib/srv/factory.js

@@ -1,16 +1,16 @@
 const cds = require('..'), { path, isfile, redacted } = cds.utils
 const paths = Array.from (new Set ([ cds.root, ...require.resolve.paths('x') ]))
-const DEBUG = cds.debug('cds.service.factory',); DEBUG && DEBUG ({ 'cds.root':cds.root, paths })
+const DEBUG = cds.debug('cds.service.factory'); DEBUG?.({ 'cds.root':cds.root, paths })
 
-/** @typedef {import('./srv-api')} Service @type { (()=>Service) & (new()=>Service) } */
+/** @typedef {import('./cds.Service')} Service @type { (()=>Service) & (new()=>Service) } */
 const ServiceFactory = function (name, model, options) { //NOSONAR
 
   const o = { ...options } // avoid changing shared options
   const conf = cds.requires[name]
-  const serve = !(conf && conf.external && (!o.mocked || conf.credentials))
+  const serve = !conf?.external || o.mocked && !conf.credentials
   const defs = !model ? {[name]:{}} : model.definitions || cds.error `Invalid argument for 'model': ${model}`
   const def = !name || name === 'db' ? {} : defs[name] || {}
-  DEBUG?. ({ name, definition:def, options:redacted(o) })
+  DEBUG?.({ name, definition:def, options:redacted(o) })
 
   let it /* eslint-disable no-cond-assign */
   if (it = o.with)                 return _use (it) // from cds.serve (<options>)
@@ -32,13 +32,13 @@ const ServiceFactory = function (name, model, options) { //NOSONAR
     const kind = o.kind = serve && def['@kind'] || o.kind || 'app-service'
     if (_require[kind]) return _require[kind]
     const {impl} = cds.requires[kind] || cds.requires.kinds[kind] || cds.error `No configuration found for 'cds.requires.${kind}'`
-    DEBUG && DEBUG ('requires',{kind,impl})
+    DEBUG?.('requires',{kind,impl})
     return _require[kind] = _require (impl || cds.error `No 'impl' configured for 'cds.requires.${kind}'`)
   }
 }
 
 const _require = (it,d) => {
-  DEBUG && d && DEBUG ('requires',{ service: d.name, source:_source(d), impl:it })
+  d && DEBUG?.('requires',{ service: d.name, source:_source(d), impl:it })
   if (it.startsWith('@sap/cds/')) it = cds.home + it.slice(8)  //> for local tests in @sap/cds dev
   if (it.startsWith('./')) it = _relative (d,it.slice(2))     //> relative to <service>.cds
   try { var resolved = require.resolve(it,{paths}) } catch {
@@ -46,7 +46,7 @@ const _require = (it,d) => {
       throw cds.error `Failed loading service implementation from '${it}' ${{ Reason:e, paths, 'cds.root':cds.root }}`
     }
   }
-  DEBUG && DEBUG({resolved})
+  DEBUG?.({resolved})
   return cds.utils._import(resolved)
 }
 
@@ -75,4 +75,16 @@ const _resolve = (...args) => {
 }
 const _is_class = (impl) => typeof impl === 'function' && impl.prototype && /^class\b/.test(impl)
 
-module.exports = Object.assign (ServiceFactory, { Service: ServiceFactory, resolve:_relative })
+module.exports = Object.assign (ServiceFactory, { init, is_factory:true })
+
+/**
+ * Used internally by cds.connect() and cds.serve() to add handlers
+ * from cds.service.impl-style implementations.
+ * @protected
+ */
+async function init (srv) {
+  const { impl } = srv.options
+  if (typeof impl === 'function' && !/^class\b/.test(impl))
+    await impl.call (srv,srv)
+  return await srv.init?.() ?? srv
+}

package/lib/srv/protocols/hcql.js

@@ -28,7 +28,7 @@ class HCQLAdapter extends require('./http') {
       .get ($(({entity,id,tail}, req) => {
         const body = typeof req.body === 'string' ? req.body : ''
         return tail || body ? {SELECT:{
-          ...CQL(`SELECT from _ ${body} ${tail||''}`).SELECT,
+          ...SELECT (`from _ ${body} ${tail||''}`).SELECT,
           ...SELECT.from (entity,id).SELECT
         }} : SELECT.from (entity,id)
       }))
@@ -70,8 +70,7 @@ class HCQLAdapter extends require('./http') {
    * which is expected to be a plain CQN object or a CQL string.
    */
   query4 (/** @type express.Request */ req) {
-    let b = req.body; if (typeof b === 'string') b = cds.parse.cql(b)
-    let q = req.body = cds.ql.query(b); if (!q) return this.error (400, 'Invalid query', { query: req.body })
+    let q = req.body = cds.ql(req.body) || this.error (400, 'Invalid query', { query: req.body })
     // assert valid target entity
     if (q.target?._unresolved && this.service.definition) {
       q.target = q._target = this.service.entities [q.target.name]

package/lib/srv/protocols/index.js

@@ -61,11 +61,11 @@ class Protocols {
       // construct adapter instance from resolved implementation
       let adapter = cached[kind]; if (!adapter) {
         const conf = this[kind] ??= {}
-        let { impl } = conf; if (typeof impl !== 'function') {
+        let { impl } = conf; if (typeof impl !== 'function') try {
           if (impl[0] === '.') impl = __dirname+impl.slice(1)
-          try { require.resolve(impl) } catch { cds.error `Cannot find impl for protocol adapter: ${impl}` }
+          else impl = require.resolve(impl,{paths:[cds.root]})
           impl = conf.impl = require(impl)
-        }
+        } catch { cds.error `Cannot find impl for protocol adapter: ${impl}` }
         adapter = cached[kind] = impl.prototype ? new impl(srv, conf) : impl(srv, conf)
         if (!adapter) continue
       }

package/lib/srv/srv-dispatch.js

@@ -3,7 +3,7 @@ const cds = require ('../index')
 /**
  * The default implementation of the `srv.dispatch(req)` ensures everything
  * is prepared before calling `srv.handle(req)`
- * @typedef {import('./srv-api')} Service
+ * @typedef {import('./cds.Service')} Service
  * @typedef {import('../req/request')} Request
  * @this {Service}
  * @param {Request} req
@@ -47,21 +47,21 @@ exports.handle = async function handle (req) {
   const srv=this; let handlers //...
 
   // ._initial handlers run in sequence
-  handlers = this._handlers._initial.filter (h => h.for(req))
+  handlers = this.handlers._initial.filter (h => h.for(req))
   if (handlers.length) {
     for (const each of handlers) await each.handler.call (this,req)
     if (req.errors) throw req.reject()
   }
 
   // .before handlers run in parallel
-  handlers = this._handlers.before.filter (h => h.for(req))
+  handlers = this.handlers.before.filter (h => h.for(req))
   if (handlers.length) {
     await Promise.all (handlers.map (each => each.handler.call (this,req)))
     if (req.errors) throw req.reject()
   }
 
   // .on handlers run in parallel for async events, and as interceptors stack for sync requests
-  handlers = this._handlers.on.filter (h => h.for(req))
+  handlers = this.handlers.on.filter (h => h.for(req))
   if (handlers.length) {
     if (!req.reply) await Promise.all (handlers.map (each => each.handler.call (this,req,_dummy)))
     else await async function next (r=req) { //> handlers may pass a new req object into next()
@@ -76,7 +76,7 @@ exports.handle = async function handle (req) {
   else if (req.query) throw _unhandled (this,req)
 
   // .after handlers run in parallel
-  handlers = this._handlers.after.filter (h => h.for(req))
+  handlers = this.handlers.after.filter (h => h.for(req))
   if (handlers.length) {
     const results = req.event === 'READ' && !_is_array(req.results) ? (req.results == null ? [] : [req.results]) : req.results
     await Promise.all (handlers.map (each => each.handler.call (this, results, req)))
@@ -100,13 +100,14 @@ const _ensure_target = (srv,req) => {
     else if (q.UPDATE) _ensure_fqn (q.UPDATE,'entity',srv)
     else if (q.DELETE) _ensure_fqn (q.DELETE,'from',srv)
   }
-  const m = srv.model, defs = m && m.definitions || {}
+  const defs = srv.model?.definitions || {}
   req.target = typeof q === 'object' ? cds.infer(q,defs) : defs[req.path]
 }
 
 const _ensure_fqn = (x,p,srv, from = x[p]) => {
   if (!from) return
   if (typeof from === 'string') {
+    if (from in srv.entities) return x[p] = srv.entities[from].name
     if (srv.isDatabaseService) return
     if (srv.model && from in srv.model.definitions) return
     if (from.startsWith(srv.namespace)) return