@sap/cds 5.5.3 → 5.6.1

package/lib/req/context.js

@@ -12,41 +12,20 @@ class EventContext {
 
   toString() { return `${this.event} ${this.path}` }
 
-  static new (data) {
-    const base = cds.context
-    if (base && features.cds_tx_inheritance) {
-      const { tenant, user, locale, _ } = base
-      data = { user: user && Object.create(user), tenant, locale, _, ...data }
-      // REVISIT: Do we have to propagate hidden subdomain as well?
-      // let subdomain = _ && _.req && _.req && _.req.authInfo && _.req.authInfo.getSubdomain()
-      // if (subdomain) {
-      //   if (!data._) data._ = {}
-      //   if (!data._.req) data._.req = {}
-      //   if (!data._.req.authInfo) data._.req.authInfo = { setSubdomain(v){ this.subdomain = v } }
-      //   if (!data._.req.authInfo.getSubdomain()) data._.req.authInfo.setSubdomain (subdomain)
-      // }
-    } else if (data && 'user' in data) {
-      data = { user:1, ...data } // IMPORTANT: ensure user is first to be assigned to call setter
+  static new (data={}, base = cds.context) {
+    if (data && base && features.cds_tx_inheritance) {
+      let u = _inherit('user', u => typeof u === 'object' ? Object.create(u) : u)
+      if (!u || !u.tenant) _inherit('tenant')
+      if (!u || !u.locale) _inherit('locale')
     }
-    return new this (data)
-  }
-
-  static spawn (background_job,o) {
-    const fn = async ()=> {
-      // create a new transaction for each run of the background job
-      // which inherits from the current event context by default
-      const tx = cds.context = cds.tx({...o})
-      try {
-        await background_job(tx)
-        await tx.commit()
-      } catch(e) {
-        console.trace (`ERROR occured in background job:`, e) // eslint-disable-line no-console
-        await tx.rollback()
-      }
+    function _inherit (p,fn) {
+      if (p in data) return data[p]
+      let pd = Reflect.getOwnPropertyDescriptor(base,p); if (!pd) return
+      return data[p] = fn ? fn(pd.value) : pd.value
     }
-    if (o && o.after) return setTimeout (fn, o.after)
-    if (o && o.every) return setInterval (fn, o.every)
-    else return setImmediate (fn)
+    // IMPORTANT: ensure user is first to be assigned to call setter_
+    if (data.user) data = { user:1, ...data }
+    return new this (data)
   }
 
   constructor(_={}) {
@@ -107,7 +86,7 @@ class EventContext {
     if (t) super.tenant = this.user.tenant = t
   }
   get tenant() {
-    return this.tenant = this._propagated('tenant') || this.user.tenant
+    return this.tenant = this.user.tenant || this._propagated('tenant')
   }
 
   set user(u) {
@@ -124,7 +103,7 @@ class EventContext {
     if (l) super.locale = this.user.locale = l
   }
   get locale() {
-    return this.locale = this._propagated('locale') || this.user.locale
+    return this.locale = this.user.locale || this._propagated('locale')
   }
 
   get timestamp() {
@@ -177,7 +156,78 @@ class EventContext {
   }
 }
 
-EventContext.propagateHeaders = [ 'x-correlation-id' ]
+
+/**
+ * Continuation Local Storage for cds.context
+ */
+ const cls = (cds,v) => {
+
+  if (cds.env.features.cls) {
+
+    const { executionAsyncResource:current, createHook } = module.require ('async_hooks')
+    const _context = Symbol('cds.context')
+
+    createHook ({ init(id,t,tid, res) {
+      const cr = current(); if (!cr) return
+      const ctx = cr[_context]
+      if (ctx) res[_context] = ctx
+    }}).enable()
+
+    Reflect.defineProperty (cds,'context',{ enumerable:1,
+      set(v) {
+        const cr = current(); if (!cr) return
+        const ctx = typeof v !== 'object' ? v : v.context || (v instanceof EventContext ? v : EventContext.new(v,false))
+        cr[_context] = ctx
+      },
+      get() {
+        const cr = current(); if (!cr) return undefined
+        return cr[_context]
+      },
+    })
+
+  } else {
+
+    Reflect.defineProperty (cds,'context',{ enumerable:1,
+      get:()=> undefined,
+      set:()=> {},
+    })
+
+  }
+
+  return v ? cds.context = v : cds.context
+}
+
+
+function cds_spawn (o,fn) {
+  if (typeof o === 'function') [ fn, o ] = [ o, fn ]
+  if (!o) o = {}
+  const em = new EventEmitter()
+  const fx = async ()=> {
+    // create a new transaction for each run of the background job
+    // which inherits from the current event context by default
+    const tx = cds.context = cds.tx({...o})
+    try {
+      const res = await fn(tx)
+      await tx.commit()
+      for (const handler of em.listeners('succeeded')) await handler(res)
+      for (const handler of em.listeners('done')) await handler()
+    } catch(e) {
+      console.trace (`ERROR occured in background job:`, e) // eslint-disable-line no-console
+      await tx.rollback()
+      for (const handler of em.listeners('failed')) await handler(e)
+      for (const handler of em.listeners('done')) await handler()
+    }
+  }
+  const timer = (
+    (o && o.after) ? setTimeout (fx, o.after) :
+    (o && o.every) ? setInterval (fx, o.every) :
+    setImmediate (fx) )
+  return Object.assign(em, { timer })
+}
+
+
 module.exports = Object.assign (EventContext,{
-  /** @type {(cds,v)=>EventContext} */ for: require('./cls')
+  /** @type {(cds,v)=>EventContext} */ for: cls,
+  spawn: cds_spawn,
+  propagateHeaders: [ 'x-correlation-id' ]
 })

package/lib/req/{impl.js → request.js}

@@ -1,4 +1,4 @@
-const { Responses, Errors } = require('./res')
+const { Responses, Errors } = require('./response')
 
 /**
  * Class Request represents requests received via synchronous protocols.

package/lib/serve/Service-api.js

@@ -77,7 +77,7 @@ class Service extends require('./Service-handlers') {
   get namespace()  {
     return super.namespace  = this.definition && this.definition.name
     || this.model && this.model.namespace
-    || this.name !== 'db' && !/\W/.test(this.name) && this.name || undefined
+    || !(this instanceof cds.DatabaseService) && !/\W/.test(this.name) && this.name || undefined
   }
 
   get operations() { return super.operations = _reflect (this, d => d.kind === 'action' || d.kind === 'function') }

package/lib/serve/Service-dispatch.js

@@ -4,7 +4,7 @@ const cds = require ('../index')
  * The default implementation of the `srv.dispatch(req)` ensures everything
  * is prepared before calling `srv.handle(req)`
  * @typedef {import('./Service-api')} Service
- * @typedef {import('../req/impl')} Request
+ * @typedef {import('../req/request')} Request
  * @this {Service}
  * @param {Request} req
  * @returns {Promise} resolving to the outcome/return value of last .on handler
@@ -32,7 +32,17 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
 
   // Ensure target and fqns
   if (!req.target) _ensure_target (this,req)
-  if (req.query && typeof req.query === 'object' && !req.query._srv) Object.defineProperty (req.query,'_srv',{value:this})
+  if (typeof req.query === 'object') {
+    if (req.query._target !== req.target) Object.defineProperty (req.query,'_target',{ value:req.target, configurable:true, writable:true })
+    if (!req.query._srv) Object.defineProperty (req.query,'_srv',{ value:this, configurable:true, writable:true })
+  }
+
+  // REVISIT: Ensure req._.req and req._.res in case of srv.run(query)?!
+  /*
+  if (this instanceof cds.ApplicationService && !req._.req) {
+    // TODO: add req and res to req._ from tx
+  }
+  */
 
   return this.handle(req)
 }

package/lib/serve/Service-handlers.js

@@ -3,7 +3,7 @@ const cds = require('..'), {expected} = cds.error
 class EventHandlers {
 
   constructor (name) {
-    this._handlers = { on:[], before:[], after:[], _initial:[], _error:[] }
+    this._handlers = { _initial:[], before:[], on:[], after:[], _error:[] }
     this.name = name
   }
 
@@ -77,17 +77,31 @@ const _register = function (srv, phase, event, path, handler) { //NOSONAR
 
   // Finally register with a filter function to match requests to be handled
   const _handlers = srv._handlers [event === 'error' ? '_error' : (handler._initial ? '_initial' : phase)] // REVISIT: remove _initial handlers
-  _handlers.push ({ handler, for: (
-    event && path ? (req) => (event === req.event) && (path === req.path || path === req.entity) :
-    event ? (req) => (event === req.event) :
-    path ? (req) => (path === req.path || path === req.entity) :
-    () => true
-  )})
+  _handlers.push (new EventHandler (phase, event, path, handler))
 
   if (phase === 'on') cds.emit('subscribe',srv,event) //> inform messaging service
   return srv
 }
 
+
+class EventHandler {
+  constructor (phase, event, path, handler) {
+    this[phase] = event || '*'
+    if (path) this.path = path
+    this.handler = handler
+    Object.defineProperties (this, { // non-enumerable properties to improve debugging
+      _initial: { value: handler._initial },
+      for: { value:
+        event && path ? (req) => (event === req.event) && (path === req.path || path === req.entity) :
+        event ? (req) => (event === req.event) :
+        path ? (req) => (path === req.path || path === req.entity) :
+        /* else: */ () => true
+      }
+    })
+  }
+}
+
+
 const is_impl = x => typeof x === 'function' && !(x.prototype && /^class\b/.test(x))
 const is_array = Array.isArray
 const AlternativeEvents = {

package/lib/serve/Service-methods.js

@@ -47,7 +47,7 @@ const add_handler_for = (srv, def) => {
 
       // object variant of params, ensure at least one param is present in args[0]
       // REVISIT: still not bullet proof, but parameters might be optional
-      if (typeof args[0] === 'object' && args.length === 1 && Object.keys(def.params).some(p => p in args[0])) {
+      if ( args[0] !== null && typeof args[0] === 'object' && args.length === 1 && Object.keys(def.params).some(p => p in args[0])) {
         const params = args.shift()
         for (const p in def.params)  {
           data[p] = params[p]

package/lib/serve/Transaction.js

@@ -6,12 +6,18 @@ const _context = Symbol()
  * a new Transaction as a derivate of the `srv` (i.e. {__proto__:srv})
  * @returns { Transaction & import('./Service-api') }
  */
-module.exports = function tx (req,o) { const srv = this
+module.exports = function tx (req,fn) { const srv = this
   if (srv.context) return srv
   if (!req) {
     // called as srv.tx() -> new root transaction
     return RootTransaction.for (srv, Context.new())
   }
+  if (typeof req === 'function') [ req, fn ] = [ Context.new(), req ]
+  if (typeof fn === 'function') {
+    // auto-committed transaction, i.e. cds.tx (tx => {...})
+    const tx = srv.tx(req)
+    return Promise.resolve(tx).then(fn) .then (tx.commit,tx.rollback)
+  }
   if (req instanceof Context) {
     // called for a nested req -> nested tx
     if (req.context !== req) return NestedTransaction.for (srv, req.context)
@@ -20,11 +26,6 @@ module.exports = function tx (req,o) { const srv = this
     // called for a top-level req -> root tx
     else return RootTransaction.for (srv, req)
   }
-  if (typeof req === 'function') {
-    // auto-committed transaction, i.e. cds.tx (tx => {...})
-    const tx = srv.tx(o)
-    return Promise.resolve().then (()=> req(tx)) .then (tx.commit,tx.rollback)
-  }
   if (req[_context]) {
     // called again for an arbitrary context object -> see below
     return NestedTransaction.for (srv, req[_context])

package/lib/serve/index.js

@@ -85,7 +85,7 @@ function cds_serve (som, _options) { // NOSONAR
     ready = ready.then (()=>{
       for (let each of all) {
         ProtocolAdapter.serve(each).in(app)
-        cds.emit ('serving',each)
+        if (!o.silent) cds.emit ('serving',each)
       }
     })
     return fluent

package/lib/utils/axios.js

@@ -36,6 +36,13 @@ const _args = (args) => {
 }
 
 const _error = (e) => {
+  if (e.code === 'ECONNREFUSED' && e.port === 80 /*unchanged default port*/) {
+    // retain original error properties (code,...)
+    e = Object.assign(new Error(e.message +
+      '\nIt seems that the server was not started. Make sure to call \'cds.test(...)\' or \'cds.test.run(...)\'.'),e)
+    e.stack = null // stack is just clutter here
+    throw e
+  }
   if (!e.response)  throw e
   if (!e.response.data)  throw e
   if (!e.response.data.error)  throw new Error(e.message + '\n\n' + e.response.data)

package/lib/utils/data.js

@@ -6,7 +6,7 @@ class DataUtil {
     if (!db)  db = await cds.connect.to('db')
     if (!this._deletes) {
       this._deletes = []
-      for (const entity of db.model.minified().all('entity')) {
+      for (const entity of db.model.each('entity')) {
         if (!entity.query && entity['@cds.persistence.skip'] !== true) {
           this._deletes.push(cds.ql.DELETE.from(entity))
         }

package/libx/_runtime/audit/Service.js

@@ -3,6 +3,13 @@ const LOG = cds.log('audit-log')
 
 const v2utils = require('./utils/v2')
 
+const ANONYMOUS = 'anonymous'
+
+const _getTenantAndUser = () => ({
+  user: (cds.context && cds.context.user && cds.context.user.id) || ANONYMOUS,
+  tenant: (cds.context && cds.context.tenant) || ANONYMOUS
+})
+
 module.exports = class AuditLogService extends cds.MessagingService {
   async init() {
     // call MessagingService's init, which handles outboxing
@@ -13,7 +20,8 @@ module.exports = class AuditLogService extends cds.MessagingService {
     this.ready = !!this.alc
   }
 
-  async emit(event, data) {
+  async emit(first, second) {
+    const { event, data } = typeof first === 'object' ? first : { event: first, data: second }
     if (!this.options.outbox) return this.send(event, data)
 
     if (this.ready && this[event]) {
@@ -33,10 +41,7 @@ module.exports = class AuditLogService extends cds.MessagingService {
   async dataAccessLog({ accesses }) {
     if (!this.ready) throw new Error('AuditLogService not connected')
 
-    const {
-      tenant,
-      user: { id: user }
-    } = cds.context
+    const { tenant, user } = _getTenantAndUser()
 
     // build the logs
     const { entries, errors } = v2utils.buildDataAccessLogs(this.alc, accesses, tenant, user)
@@ -59,10 +64,7 @@ module.exports = class AuditLogService extends cds.MessagingService {
   async dataModificationLog({ modifications }) {
     if (!this.ready) throw new Error('AuditLogService not connected')
 
-    const {
-      tenant,
-      user: { id: user }
-    } = cds.context
+    const { tenant, user } = _getTenantAndUser()
 
     // build the logs
     const { entries, errors } = v2utils.buildDataModificationLogs(this.alc, modifications, tenant, user)
@@ -87,8 +89,9 @@ module.exports = class AuditLogService extends cds.MessagingService {
     // cds.context not always set on auth-related errors -> try to extract from data
     let user, tenant
     if (cds.context) {
-      tenant = cds.context.tenant
-      user = cds.context.user && cds.context.user.id
+      const tenantAndUser = _getTenantAndUser()
+      tenant = tenantAndUser.tenant
+      user = tenantAndUser.user
     } else {
       try {
         const parsed = JSON.parse(data)
@@ -101,10 +104,10 @@ module.exports = class AuditLogService extends cds.MessagingService {
           delete parsed.user
         }
         data = JSON.stringify(parsed)
-      } catch (e) {
-        // ignore
-      }
+      } catch (e) {}
     }
+    if (!tenant) tenant = ANONYMOUS
+    if (!user) user = ANONYMOUS
 
     // build the log
     const entry = v2utils.buildSecurityLog(this.alc, action, data, tenant, user)
@@ -117,10 +120,7 @@ module.exports = class AuditLogService extends cds.MessagingService {
   async configChangeLog({ action, success, configurations }) {
     if (!this.ready) throw new Error('AuditLogService not connected')
 
-    const {
-      tenant,
-      user: { id: user }
-    } = cds.context
+    const { tenant, user } = _getTenantAndUser()
 
     // build the logs
     const { entries, errors } = v2utils.buildConfigChangeLogs(this.alc, configurations, tenant, user)

package/libx/_runtime/audit/generic/personal/access.js

@@ -40,7 +40,7 @@ const _processorFnAccess = (accessLogs, model, req) => {
       element.parent['@PersonalData.EntitySemantics'] === 'DataSubjectDetails' &&
       accessLog.dataSubject.id.length === 0 // > id still an array -> promise not yet set
     ) {
-      addDataSubjectForDetailsEntity(row, accessLog, req, entity, model)
+      addDataSubjectForDetailsEntity(row, accessLog, req, entity, model, element)
     }
   }
 }

package/libx/_runtime/audit/generic/personal/modification.js

@@ -41,7 +41,8 @@ const _getOldAndNew = (action, row, key) => {
 const _addAttribute = (log, action, row, key) => {
   if (!log.attributes.find(ele => ele.name === key)) {
     const { oldValue, newValue } = _getOldAndNew(action, row, key)
-    if (oldValue !== newValue) log.attributes.push({ name: key, oldValue, newValue })
+    if (oldValue !== newValue)
+      log.attributes.push({ name: key, oldValue: String(oldValue), newValue: String(newValue) })
   }
 }
 
@@ -75,7 +76,7 @@ const _processorFnModification = (modificationLogs, model, req, beforeWrite) =>
     element.parent['@PersonalData.EntitySemantics'] === 'DataSubjectDetails' &&
     modificationLog.dataSubject.id.length === 0 // > id still an array -> promise not yet set
   ) {
-    addDataSubjectForDetailsEntity(row, modificationLog, req, entity, model)
+    addDataSubjectForDetailsEntity(row, modificationLog, req, entity, model, element)
   }
 }
 

package/libx/_runtime/audit/generic/personal/utils.js

@@ -1,7 +1,6 @@
 const cds = require('../../../cds')
 
 const { getDataSubject } = require('../../../common/utils/csn')
-const { getBackLinks, isSelfManaged } = require('../../../common/utils/backlinks')
 
 const WRITE = { CREATE: 1, UPDATE: 1, DELETE: 1 }
 const ASPECTS = { CREATE: '_auditCreate', READ: '_auditRead', UPDATE: '_auditUpdate', DELETE: '_auditDelete' }
@@ -23,8 +22,11 @@ const getPick = event => {
     const categories = []
     if (!element.isAssociation && element.key) categories.push('ObjectID')
     if (
-      element.parent['@PersonalData.EntitySemantics'] === 'DataSubject' &&
-      element['@PersonalData.FieldSemantics'] === 'DataSubjectID'
+      element['@PersonalData.FieldSemantics'] === 'DataSubjectID' &&
+      // item element of arrayed element has no parent, but
+      // at the moment annotation on item level is not supported
+      element.parent &&
+      element.parent['@PersonalData.EntitySemantics'] === 'DataSubject'
     )
       categories.push('DataSubjectID')
     if (event in WRITE && element['@PersonalData.IsPotentiallyPersonal']) categories.push('IsPotentiallyPersonal')
@@ -55,14 +57,15 @@ const createLogEntry = (logs, entity, row) => {
 }
 
 const addObjectID = (log, row, key) => {
-  if (!log.dataObject.id.find(ele => ele.keyName === key)) log.dataObject.id.push({ keyName: key, value: row[key] })
+  if (!log.dataObject.id.find(ele => ele.keyName === key))
+    log.dataObject.id.push({ keyName: key, value: String(row[key]) })
 }
 
 const addDataSubject = (log, row, key, entity) => {
   if (!log.dataSubject.type) log.dataSubject.type = entity.name
   if (!log.dataSubject.id.find(ele => ele.key === key)) {
     const value = row[key] || (row._old && row._old[key])
-    log.dataSubject.id.push({ keyName: key, value })
+    log.dataSubject.id.push({ keyName: key, value: String(value) })
   }
 }
 
@@ -77,82 +80,39 @@ const _addKeysToWhere = (child, row) => {
   return keysWithValue
 }
 
-const _addForeignKeysToWhere = (parent, child, assoc) => {
-  const foreignKeys = []
-  const backlinks = getBackLinks(assoc)
-  let parentName, childName
-  if (assoc.isComposition && assoc.is2one && !assoc.on) {
-    // look for foreign keys in parent
-    parentName = parent.name
-    childName = child.name
-  } else if (assoc.is2many && isSelfManaged(assoc)) {
-    // look for foreign keys in child
-    parentName = child.name
-    childName = parent.name
-  }
-
-  backlinks.forEach(el => {
-    if (foreignKeys.length > 0) foreignKeys.push('and')
-    foreignKeys.push({ ref: [parentName, el.entityKey] }, '=', {
-      ref: [childName, el.targetKey]
-    })
-  })
-  return foreignKeys
-}
-
-const _buildWhere = (child, dataSubjectInfo, row) => {
-  const where = []
-  where.push(
-    ..._addForeignKeysToWhere(dataSubjectInfo.entity, child, dataSubjectInfo.assoc),
-    'and',
-    ..._addKeysToWhere(child, row)
-  )
-  return where
-}
-
-const _buildSubSelect = (child, dataSubjectInfo, row) => {
-  let previousCqn
+const _buildSubSelect = (model, child, { element, up }, row, previousCqn) => {
+  const entity = element.parent
   const childCqn = SELECT.from(child.name)
     .columns(Object.keys(child.keys))
-    .where(_buildWhere(child, dataSubjectInfo.previous[0] ? dataSubjectInfo.previous[0] : dataSubjectInfo, row))
-  if (dataSubjectInfo.previous.length > 0) {
-    let currentCQN
-
-    dataSubjectInfo.previous.forEach((el, i) => {
-      const nextEl = dataSubjectInfo.previous[i + 1]
-      const args = nextEl
-        ? [nextEl.entity, el.entity, nextEl.assoc]
-        : [dataSubjectInfo.entity, el.entity, dataSubjectInfo.assoc]
-
-      currentCQN = SELECT.from(el.entity.name)
-        .columns(Object.keys(el.entity.keys))
-        .where([..._addForeignKeysToWhere(...args), 'and', 'exists', previousCqn || childCqn])
-
-      previousCqn = currentCQN
-    })
+    .where(entity._relations[element.name].join(child.name, entity.name))
+  if (previousCqn) {
+    childCqn.where('exists', previousCqn)
+  } else {
+    childCqn.where(_addKeysToWhere(child, row))
   }
-  return previousCqn || childCqn
+  if (up) return _buildSubSelect(model, entity, up, {}, childCqn)
+  return childCqn
 }
 
-const _getDataSubjectIdPromise = (child, dataSubjectInfo, row, req) => {
+const _getDataSubjectIdPromise = (child, dataSubjectInfo, row, req, model) => {
   const root = dataSubjectInfo.entity
   const cqn = SELECT.from(root.name)
     .columns(Object.keys(root.keys))
-    .where(['exists', _buildSubSelect(child, dataSubjectInfo, row)])
+    .where(['exists', _buildSubSelect(model, child, dataSubjectInfo.up, row)])
   return cds
     .tx(req)
     .run(cqn)
     .then(res => {
       const id = []
-      for (const k in res[0]) id.push({ keyName: k, value: res[0][k] })
+      for (const k in res[0]) id.push({ keyName: k, value: String(res[0][k]) })
       return id
     })
 }
 
-const addDataSubjectForDetailsEntity = (row, log, req, entity, model) => {
+const addDataSubjectForDetailsEntity = (row, log, req, entity, model, element) => {
   const role = entity['@PersonalData.DataSubjectRole']
 
-  const dataSubjectInfo = getDataSubject(entity, model, role)
+  const dataSubjectInfo = getDataSubject(entity, model, role, element)
 
   log.dataSubject.type = dataSubjectInfo.entity.name
 
@@ -165,7 +125,7 @@ const addDataSubjectForDetailsEntity = (row, log, req, entity, model) => {
   if (!req.context._audit.dataSubjects.has(mapKey)) req.context._audit.dataSubjects.set(mapKey, new Map())
   const map = req.context._audit.dataSubjects.get(mapKey)
   if (map.has(role)) log.dataSubject.id = map.get(role)
-  else map.set(role, _getDataSubjectIdPromise(entity, dataSubjectInfo, row, req))
+  else map.set(role, _getDataSubjectIdPromise(entity, dataSubjectInfo, row, req, model))
 }
 
 const resolveDataSubjectPromises = async logs => {

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

@@ -3,6 +3,8 @@ const LOG = cds.log('odata')
 
 const OData = require('./OData')
 
+const { alias2ref } = require('../../../common/utils/csn')
+
 function _createNewService(name, csn, defaultOptions) {
   const reflectedModel = cds.linked(cds.compile.for.odata(csn))
   const options = Object.assign({}, defaultOptions, { reflectedModel })
@@ -13,6 +15,8 @@ function _createNewService(name, csn, defaultOptions) {
   service._isExtended = true
 
   const edm = cds.compile.to.edm(csn, { service: name })
+  alias2ref(service, edm)
+
   const odataService = new OData(edm, csn, options)
   odataService.addCDSServiceToChannel(service)
 
@@ -84,6 +88,7 @@ class Dispatcher {
    * @returns {Promise}
    */
   async dispatch(req, res) {
+    // here, req is express' req -> req.tenant not available
     if (cds._mtxEnabled && req.user && req.user.tenant) {
       // enable mtx, if not done yet
       if (!this._extMap) {
@@ -95,6 +100,7 @@ class Dispatcher {
 
       const { alpha_toggles: alphaToggles } = cds.env.features
 
+      // here, req is express' req -> req.tenant not available
       const hash = alphaToggles ? cds.mtx._getHash(req) : req.user.tenant
 
       // add hash to map, if not done yet