@sap/cds 5.4.6 → 5.5.0

package/lib/connect/index.js

@@ -1,4 +1,4 @@
-const cds = require('..'), {one_model} = cds.env.features
+const cds = require('..'), {one_model} = cds.env.features, LOG = cds.log('cds.connect')
 const factory = require('../serve/factory')
 const _pending = cds.services._pending || {} // used below to chain parallel connect.to(<same>)
 
@@ -6,12 +6,12 @@ const _pending = cds.services._pending || {} // used below to chain parallel con
  * Connect to a service as primary datasource, i.e. cds.db.
  */
 const connect = module.exports = async function cds_connect (options) {
-	if (typeof options === 'object' && cds.db) throw cds.error (
-		`You need to disconnect before creating a new primary connection with different options!`
-	)
-	if (typeof options === 'string') cds.db = await connect.to (options)
-	else await connect.to ('db',options)
-	return cds
+  if (typeof options === 'object' && cds.db) throw cds.error (
+    `You need to disconnect before creating a new primary connection with different options!`
+  )
+  if (typeof options === 'string') cds.db = await connect.to (options)
+  else await connect.to ('db',options)
+  return cds
 }
 
 /**
@@ -21,51 +21,50 @@ const connect = module.exports = async function cds_connect (options) {
  * @param {{ kind?:String, impl?:String }} [options]
  * @returns { Promise<import('../serve/Service-api')> }
  */
-connect.to = async (datasource, options) => { //NOSONAR
-	let Service = factory, _done = x=>x
-	if (typeof datasource === 'object') [options,datasource] = [datasource]
-	else if (datasource) {
-		if (datasource._is_service_class) [ Service, datasource ] = [ datasource, datasource.name ]
-		if (!options) { //> specifying ad-hoc options disallows caching
-			if (datasource in cds.services) return cds.services[datasource]
-			if (datasource in _pending) return _pending[datasource]
-		}
-		// queue parallel requests to a single promise, to avoid creating multiple services
-		_pending[datasource] = new Promise (r=>_done=r).finally(()=>{ delete _pending[datasource] })
-	}
-	const o = Service === factory ? options4 (datasource, options) : {}
-	const m = await model4 (o)
-	const srv = new Service (datasource,m,o)
-	await srv.prepend (srv.init, srv.options.impl)
-	if (datasource === 'db') cds.db = srv
-	_done (cds.services[datasource] = srv)
-	cds.emit ('connect',srv)
-	return srv
+connect.to = async (datasource, options) => {
+  let Service = factory, _done = x=>x
+  if (typeof datasource === 'object') [options,datasource] = [datasource]
+  else if (datasource) {
+    if (datasource._is_service_class) [ Service, datasource ] = [ datasource, datasource.name ]
+    if (!options) { //> specifying ad-hoc options disallows caching
+      if (datasource in cds.services) return cds.services[datasource]
+      if (datasource in _pending) return _pending[datasource]
+    }
+    // queue parallel requests to a single promise, to avoid creating multiple services
+    _pending[datasource] = new Promise (r=>_done=r).finally(()=>{ delete _pending[datasource] })
+  }
+  const o = Service === factory ? options4 (datasource, options) : {}
+  const m = await model4 (o)
+  // check if required service definition exists
+  const required = cds.requires[datasource]
+  if (required && required.model && datasource !== 'db' && !m.definitions[required.service||datasource]) {
+    LOG.error (`No service definition found for '${required.service || datasource}', as required by 'cds.requires.${datasource}':`, required)
+    throw new Error (`No service definition found for '${required.service || datasource}'`)
+  }
+  // construct new service instance
+  const srv = new Service (datasource,m,o)
+  await srv.prepend (srv.init, srv.options.impl)
+  if (datasource === 'db') cds.db = srv
+  _done (cds.services[datasource] = srv)
+  cds.emit ('connect',srv)
+  return srv
 }
 
-function options4 (name, _o) { // NOSONAR
-	const [, kind=_o && (_o.use || _o.kind || _o.driver), url] = /^(\w+):(.*)/.exec(name) || []
-	const conf = cds.requires [name] || cds.requires [kind]
-	const o = { kind, ...conf, ..._o }
-	if (!(o.kind = o.use || o.driver || o.kind) && !o.silent && !o.impl) throw cds.error(
-		conf ? `Configuration for 'cds.requires.${name}' lacks mandatory property 'kind' or 'impl'` :
-			name ? `Didn't find a configuration for 'cds.requires.${name}'` :
-				`Provided options object lacks mandatory property 'kind' or 'impl'`
-	)
-	if (url) o.credentials = { ...o.credentials, url, database: url }
-	if (o.kind === 'sqlite') { // REVISIT: should move to sqlite module
-		const creds = o.credentials
-		for (let p of ['url','database']) {
-			const each = creds[p]
-			if (!each || each === ':memory:') continue
-			else creds[p] = cds.utils.path.resolve(cds.root,each)
-		}
-	}
-	return o
+function options4 (name, _o) {
+  const [, kind=_o && _o.kind, url] = /^(\w+):(.*)/.exec(name) || []
+  const conf = cds.requires[name] || cds.requires[kind]
+  const o = { kind, ...conf, ..._o }
+  if (!o.kind && !o.impl && !o.silent) throw cds.error(
+    conf ? `Configuration for 'cds.requires.${name}' lacks mandatory property 'kind' or 'impl'` :
+      name ? `Didn't find a configuration for 'cds.requires.${name}'` :
+        `Provided options object lacks mandatory property 'kind' or 'impl'`
+  )
+  if (url) o.credentials = { ...o.credentials, url }
+  return o
 }
 
 function model4 (o) {
-	if (o.model && o.model.definitions) return o.model
-	if (one_model && cds.model) return cds.model
-	else return o.model && cds.load(o.model)
+  if (o.model && o.model.definitions) return o.model
+  if (one_model && cds.model) return cds.model
+  else return o.model && cds.load(o.model)
 }

package/lib/core/classes.js

@@ -6,7 +6,7 @@ class any {
   set name(n) { this.set('name', n, false) }
   set kind(k) { this.set('kind', k, true) }
   get kind() { return this.set('kind', this.parent ? 'element' : 'type') }
-  is (kind) { return this.kind === kind }
+  is (kind) { return this.kind === kind || kind === 'any' }
   valueOf() { return this.name }
 
   own (property) {

package/lib/core/reflect.js

@@ -57,7 +57,7 @@ class LinkedCSN extends any {
       if (d.includes)  d.includes.forEach(i => _visit(all[i]))  // Note: with delete d.includes, redirects in AFC broke
       if (d.query)     d.query._target && _visit (d.query._target)
       if (d.type)      _builtin(d.type) || _visit (d.__proto__)
-      if (d.target)    _visit (d._target)
+      if (d.target)    _visit (d._target) ; else if (d.targetAspect) _visit (typeof d.targetAspect === 'object' ? d.targetAspect : all[d.targetAspect])
       if (d.returns)   _visit (d.returns)
       if (d.items)     _visit (d.items)
       if (d.parent)    _visit (d.parent)
@@ -65,7 +65,15 @@ class LinkedCSN extends any {
       for (let a in d.actions) _visit (d.actions[a])
       for (let p in d.params) _visit (d.params[p])
     }
-    for (let d in all) if (!reached.has(all[d])) delete all[d]
+    for (let n in all) {
+      if (n.endsWith('.texts') && reached.has(all[n.slice(0,-6)])) continue
+      if (reached.has(all[n])) continue
+      else {
+        delete all[n]
+        // also delete the legacy _texts proxy (not enumerable, installed by _localized.unfold_csn)
+        if (n.endsWith('.texts'))  delete all[n.replace('.texts','_texts')]
+      }
+    }
     return csn
   }
 

package/lib/deploy.js

@@ -1,5 +1,6 @@
 const cds = require('./index'), { local } = cds.utils
 const DEBUG = cds.debug('deploy')
+let LOG
 
 /**
  * Implementation of `cds.deploy` common to all databases.
@@ -11,6 +12,7 @@ exports = module.exports = function cds_deploy (model,options) { return {
 
   /** @param {cds.Service} db */
   async to (db, o=options||{}) { // NOSONAR
+    LOG = cds.log('deploy')
 
     if (model && !model.definitions)  model = await cds.load (model)
     if (o.mocked) exports.include_external_entities_in (model)
@@ -26,12 +28,12 @@ exports = module.exports = function cds_deploy (model,options) { return {
     }
 
     // fill in initial data...
-    const SILENT = o.silent || global.it || process.env.NODE_ENV === 'test'
+    const SILENT = o.silent || !LOG._info
     await init_from_code (db,model,SILENT)
     await init_from_csv (db,model,SILENT)
     await init_from_json (db,model,SILENT)
 
-    const {credentials} = db.options, file = credentials && credentials.database
+    const {credentials} = db.options, file = credentials && (credentials.database || credentials.url)
     if (!SILENT) {
       if (file !== ':memory:')  console.log (`/> successfully deployed to ./${file}\n`)
       else console.log (`/> successfully deployed to sqlite in-memory db\n`)
@@ -170,28 +172,29 @@ async function init_from_ (locations, filter, db, csn, SILENT, INSERT_into) { //
 
   if (folders.size === 0) return
 
-  const tx = await db.tx(), err = new Error
-  const inits = [], {local} = cds.utils
-  for (let folder of folders) {
-    const files = await readdir (folder)
-    for (let each of files.filter (filter)) {
-      let name = each.replace(/-/g,'.').slice(0, -path.extname(each).length)
-      let entity = _entity4 (name)
-      if (!entity) { DEBUG && DEBUG (`warning: ${name} not in model`); continue }
-      if (entity['@cds.persistence.skip'] === true) continue
-      const file = path.join(folder,each)
-      const src = await read (file,'utf8'); if (!src) continue
-      const q = INSERT_into (entity,src); if (!q) continue
-      SILENT || console.log (`\x1b[2m > filling ${entity.name} from ${local(file)} \x1b[0m`) // eslint-disable-line
-      inits.push (tx.run(q).catch(e=>{ const ex = new Error
-        e.stack = e.message +'\n'+ require('util').inspect(q) + err.stack.slice(5)
-          .replace (/deploy\.js:\d+:/, ex.stack.slice(5).match(/deploy\.js:\d+:/)[0])
-        throw e
-      }))
+  const {local} = cds.utils, inits = [], err = new Error
+  await db.tx (async tx => {
+    for (let folder of folders) {
+      const files = await readdir (folder)
+      for (let each of files.filter (filter)) {
+        let name = each.replace(/-/g,'.').slice(0, -path.extname(each).length)
+        let entity = _entity4 (name)
+        if (!entity) { DEBUG && DEBUG (`warning: ${name} not in model`); continue }
+        if (entity['@cds.persistence.skip'] === true) continue
+        const file = path.join(folder,each)
+        const src = await read (file,'utf8'); if (!src) continue
+        const q = INSERT_into (entity,src)
+        if (!q)  { DEBUG && DEBUG (`skipping empty ${local(file)}`); continue }
+        SILENT || console.log (`\x1b[2m > filling ${entity.name} from ${local(file)} \x1b[0m`) // eslint-disable-line
+        inits.push (tx.run(q).catch(e=>{ const ex = new Error
+          e.stack = e.message +'\n'+ require('util').inspect(q) + err.stack.slice(5)
+            .replace (/deploy\.js:\d+:/, ex.stack.slice(5).match(/deploy\.js:\d+:/)[0])
+          throw e
+        }))
+      }
     }
-  }
-  await Promise.all(inits)
-  if (!db.context) await tx.commit()
+    await Promise.all(inits)
+  })
 
   function _entity4 (name) {
     let entity = csn.definitions [name]

package/lib/env/defaults.js

@@ -17,7 +17,10 @@ module.exports = {
     // skip_unused: 'all',
     skip_unused: true,
     one_model: true,
-    localized: true
+    localized: true,
+    // assert_integrity: true,
+    cds_tx_protection: true,
+    cds_tx_inheritance: true,
   },
 
   log: {
@@ -25,6 +28,9 @@ module.exports = {
     levels: {
       compile: 'warn',
       cli: 'warn',
+      deploy: 'info',
+      serve:  'info',
+      server: 'info',
     },
     service: false,
     // adds custom fields in kibana's error rendering (unknown fields are ignored); key: index
@@ -119,16 +125,17 @@ module.exports = {
     api: {
       model: true,
       provisioning: true,
-      metadata: true
+      metadata: true,
+      diagnose: true
     },
     domain: '__default__'
   },
 
   cdsc: {
-    cv2: {
-      _localized_entries: true,
-      _texts_entries: true,
-    }
+    // cv2: {
+    //   _localized_entries: true,
+    //   _texts_entries: true,
+    // }
     // toSql: { associations: 'joins' },
     // newCsn: true,
   },

package/lib/env/index.js

@@ -3,7 +3,6 @@ const DEFAULTS = require('./defaults'), defaults = require.resolve ('./defaults'
 const user_home = require('os').homedir()
 const compat = require('./compat')
 const path = require('path')
-const cache = {}
 
 
 /**
@@ -15,20 +14,11 @@ class Config {
    * This is the one and only way to construct new instances.
    * Public API is through `cds.env.for (<context>)`
    * @param context - the app context, like 'cds' or 'your-app'
-   * @returns {Config}
+   * @returns {Config & typeof DEFAULTS}
    */
-  for (context, cwd, _force_cache_update=false, _filter_default_values=false) {
+  for (context, cwd, _defaults=true) {
     if (!cwd) cwd = global.cds && global.cds.root || process.cwd()
-    const cached = cache[cwd] || (cache[cwd] = {})
-
-    if (_filter_default_values) {
-      // never update cache without default values
-      return new Config (context, cwd, false)
-    }
-    if(!cached[context] || _force_cache_update) {
-      cached[context] = new Config (context, cwd)
-    }
-    return cached[context]
+    return new Config (context, cwd, _defaults)
   }
 
 
@@ -37,8 +27,8 @@ class Config {
    */
   constructor (_context, _home, _defaults=true) {
     Object.assign (this, { _context, _home, _sources:[] })
-    this.profiles = _determineProfilesFrom (process.env)
-    this._profiles_defined = new Set()
+    this._profiles = _determineProfilesFrom (process.env)
+    this._profiles._defined = new Set()
 
     // compat requires default values
     if (_context === 'cds' && _defaults)  this.add (DEFAULTS, defaults)
@@ -74,6 +64,20 @@ class Config {
     }
   }
 
+  /**
+   * This is `this.requires` plus additional entries for all cds.required.<name>.service
+   */
+  get required_services_or_defs() {
+    const dict = Object.create (this.requires)
+    for (let [name,e] of Object.entries (this.requires)) if (e.service) {
+      if (e.service in dict && e.service !== name) {
+        console.error (`Datasource name '${e.service}' conflicts with 'service' definition referred to in 'cds.requires.${name}':`, e)
+        throw new Error (`Datasource name '${e.service}' conflicts with service definition`)
+      }
+      else dict[e.service] = { ...e, name }
+    }
+    return super.required_services_or_defs = dict
+  }
 
   set roots(v) { set (this, 'roots', v) }
   get roots() {
@@ -118,7 +122,11 @@ class Config {
    * For BAS only: get all defined profiles (could include some from the defaults)
    */
   get "defined-profiles" () {
-    return Array.from (this._profiles_defined)
+    return Array.from (this._profiles._defined)
+  }
+
+  get profiles() {
+    return super.profiles = Array.from (this._profiles)
   }
 
 
@@ -129,24 +137,15 @@ class Config {
 //
 
 
-  /** @returns {Config} */
-  _load (cwd, res, _conf=o=>o) {
-    const json = _readJson (res = path.join(cwd, res))  // only support JSON
-    if (json) {
-      const conf  = _conf (json)
-      if (conf) {
-        this._sources.push (res)
-        _merge (this, conf, this.profiles, this._profiles_defined)
-      }
-    }
-    return this
+  _load (cwd, file, _conf=o=>o) {
+    const json = _readJson (file = path.join(cwd, file))  // only support JSON
+    if (json) this.add (_conf (json), file)
   }
 
-  /** @returns {Config} */
   add (conf, /*from:*/ _src) {
     if (!conf)  return this
     if (_src)  this._sources.push (_src)
-    _merge (this, conf, this.profiles, this._profiles_defined)
+    _merge (this, conf, this._profiles)
     return this
   }
 
@@ -170,12 +169,11 @@ class Config {
     const { requires } = this
     for (let each in requires)  requires[each] = _merged (each)
     function _merged (key) {
-      let entry = requires [key]
-      if (entry._is_merged || entry.kind === key || !(entry.kind in requires))  return entry
-      else return Object.defineProperty (
-        _merge ({..._merged(entry.kind)}, entry, false, false, 'cloned'),
-        '_is_merged', {value:true}
-      )
+      const entry = requires[key]
+      if (entry._is_merged || entry.kind === key || !(entry.kind in requires)) return entry
+      const clone = _merge ({}, _merged (entry.kind))        // first apply inherited data
+      _merge (clone, entry, false, false, o => _merge({},o)) // then apply overridden data
+      return Object.defineProperty (clone, '_is_merged', {value:true})
     }
   }
 
@@ -207,12 +205,12 @@ class Config {
     const env = new Config('cds')
     this._for_tests.vcaps = (vcaps) => { _add_vcap_services_to (env, vcaps)}
     // merge all configs, then resolve profiles (same as in 'for' function above)
-    for (let c of [...conf].reverse())  _merge(env, c, env.profiles, env._profiles_defined)
+    for (let c of [...conf].reverse())  _merge(env, c, env._profiles)
     return env
   }
   // FOR TESTS ONLY! --> PLEASE: tests should test public APIs (only)
   _merge_with (src) {
-    _merge (this, src, this.profiles, this._profiles_defined)
+    _merge (this, src, this._profiles)
     return this
   }
 }
@@ -228,31 +226,37 @@ class Config {
 /**
  * @returns {Config} dst
  */
-function _merge (dst, src, _profiles, _profiles_defined, _clone) { // NOSONAR
-  const profiled = []
-  for (let p of Object.getOwnPropertyNames(src)) {
-    const v = src[p]
-    if (_profiles_defined && p[0] === '[')  _profiles_defined.add (p.slice(1,-1))
-    if (_profiles && p[0] === '[') {
-      if (_profiles.includes(p.slice(1,-1)))
-        profiled.push (()=> _merge (dst, v, _profiles, _profiles_defined, _clone))
+function _merge (dst, src, _profiles, _cloned) {
+  const profiled = [], descr = Object.getOwnPropertyDescriptors(src)
+  for (let p in descr) {
+    const pd = descr[p]
+
+    if ('get' in pd || !pd.enumerable) {
+      Object.defineProperty(dst,p,pd)
+      continue
     }
-    else if (typeof v === 'object' && !Array.isArray(v)) {
-      if (!dst[p])  dst[p] = {}
-      else if (_clone)  dst[p] = {...dst[p]}
-      _merge (dst[p], v, _profiles, _profiles_defined)
+
+    if (_profiles && p[0] === '[') {
+      if (_profiles._defined)  _profiles._defined.add (p.slice(1,-1))
+      if (_profiles.has(p.slice(1,-1)))
+        profiled.push (()=> _merge (dst, src[p], _profiles, _cloned))
+      continue
     }
-    else if (v !== undefined) {
-      // eslint-disable-next-line no-prototype-builtins
-      if (src.propertyIsEnumerable(p)) dst[p] = v
-      else if (dst[p] === undefined) Object.defineProperty(dst, p, {value: v})
+
+    const v = pd.value
+    if (typeof v === 'object' && !Array.isArray(v)) {
+      if (!dst[p]) dst[p] = {}; else if (_cloned)  dst[p] = _cloned(dst[p])
+      _merge (dst[p], v, _profiles, _cloned)
+      continue
     }
+
+    if (v !== undefined) dst[p] = v
   }
   for (let each of profiled) each()
   return dst
 }
 
-function _process_env4 (prefix) { // NOSONAR
+function _process_env4 (prefix) {
   const {env} = process
   const PREF = prefix.toUpperCase(), my = { CONFIG: PREF+'_CONFIG', ENV: PREF+'_ENV' }
   const out = JSON.parse (env[my.CONFIG] || '{}')
@@ -280,7 +284,7 @@ function _value4 (val) {
 }
 
 
-function _add_vcap_services_to (env, vcaps={}) { //NOSONAR
+function _add_vcap_services_to (env, vcaps={}) {
   let any
   for (let service in env.requires) {
     const conf = env.requires [service]
@@ -288,40 +292,31 @@ function _add_vcap_services_to (env, vcaps={}) { //NOSONAR
       conf.vcap && _fetch (conf.vcap) ||  //> alternatives, e.g. { name:'foo', tag:'foo' }
       _fetch ({ name: service })  ||
       _fetch ({ tag: env._context+':'+service }) ||
-      _fetch ({ tag: conf.use || conf.kind }) || // important for hanatrial, labeled 'hanatrial', tagged 'hana'
-      _fetch ({ label: conf.use || conf.kind }) ||
+      _fetch ({ tag: conf.dialect || conf.kind }) || // important for hanatrial, labeled 'hanatrial', tagged 'hana'
+      _fetch ({ label: conf.dialect || conf.kind }) ||
       {/* not found */}
     )
-    // `credentials.database` is used as indicator for sqlite, so must not appear for other DBs
-    if (conf.credentials && conf.use !== 'sqlite')  delete conf.credentials.database
     // Merge `credentials`.  Needed because some app-defined things like `credentials.destination` must survive.
     if (credentials)  any = conf.credentials = Object.assign ({}, conf.credentials, credentials)
   }
   return any
 
-  function _fetch (predicate) { //NOSONAR
-    const filter = _filter4 (predicate)
-    for (let stype in vcaps) {
-      const found = _array(vcaps,stype) .find (filter)
-      if (found)  return found
-    }
-  }
-
-  function _filter4 (predicate) {
-    let filter;  for (let key in predicate) {
-      const val = predicate[key], prev=filter, next=(
-        key === 'tag' ? e => _array(e,'tags').includes (val)
-        : e => val !== undefined ? e[key] === val : false
-      )
-      filter = prev ? e => prev(e) || next(e) : next
+  function _fetch (predicate) {
+    for (let k of Object.keys(predicate).reverse()) {
+      const v = predicate[k]; if (!v) continue
+      const filter = k === 'tag' ? e => _array(e,'tags').includes(v) : e => e[k] === v
+      for (let stype in vcaps) {
+        const found = _array(vcaps,stype) .find (filter)
+        if (found)  return found
+      }
     }
-    return filter
   }
 
   function _array(o,p) {
     const v = o[p]
-    if (!v || Array.isArray(v))  return v || []
-    throw new Error(`Expected '${p}' to be an array, but was: ${require('util').inspect(vcaps)}`)
+    if (!v) return []
+    if (Array.isArray(v)) return v
+    throw new Error(`Expected VCAP entry '${p}' to be an array, but was: ${require('util').inspect(vcaps)}`)
   }
 
 }
@@ -343,7 +338,7 @@ function _determineProfilesFrom (env = process.env) {
   }
   const split = (x) => env[x] ? env[x].split (/\s*,\s*/) : []
   const profiles = [ ...split ('NODE_ENV'), ...split ('CDS_ENV') ]
-  return [...new Set (profiles)]
+  return new Set (profiles)
 }
 
 

package/lib/env/requires.js

@@ -30,20 +30,17 @@ module.exports = {
   logging: undefined,
   audit: undefined,
   "sql": {
-    '[development]': { kind: 'sqlite', credentials: { database: ':memory:' } },
+    '[development]': { kind: 'sqlite', credentials: { url: ':memory:' } },
     '[production]': { kind: 'hana' },
   },
-  "sqlite": {
-    // use: '@sap/cds-sqlite', // enforce using sqlite when accessed through <sql>
-    use: 'sqlite', // enforce using sqlite when accessed through <sql>
-    credentials: { database: 'sqlite.db' },
-    impl: `${_runtime}/sqlite/Service.js`
-  },
-  "hana": {
-    // use: '@sap/cds-hana', // enforce using hana when accessed through <sql>
-    use: 'hana', // enforce using hana when accessed through <sql>
-    impl: `${_runtime}/hana/Service.js`
-  },
+  "sqlite": _compat_to_use({
+    dialect: 'sqlite', credentials: { url: 'sqlite.db' },
+    impl: `${_runtime}/sqlite/Service.js`,
+  }),
+  "hana": _compat_to_use ({
+    dialect: 'hana',
+    impl: `${_runtime}/hana/Service.js`,
+  }),
   "rest": {
     impl: `${_runtime}/remote/Service.js`
   },
@@ -57,21 +54,37 @@ module.exports = {
     kind: 'odata'
   },
   "local-messaging": {
-    impl: `${_runtime}/messaging/service.js`
+    impl: `${_runtime}/messaging/service.js`,
+    local: true
   },
   "file-based-messaging": {
     outbox: true,
     impl: `${_runtime}/messaging/file-based.js`,
     credentials: { file:'~/.cds-msg-box' }
   },
-  "enterprise-messaging-shared": {
-    outbox: true,
-    impl: `${_runtime}/messaging/enterprise-messaging-shared.js`,
-    use: "enterprise-messaging" // make sure to search for the correct label in config
+  "default-messaging": {
+    "[development]": { "kind": "local-messaging" },
+    "[hybrid]": { "kind": "enterprise-messaging-amqp" },
+    "[production]": {
+      "kind": "enterprise-messaging-amqp",
+      "[multitenant]": { "kind": "enterprise-messaging-http" }
+    }
   },
   "enterprise-messaging": {
+    kind: "enterprise-messaging-http",
+  },
+  "enterprise-messaging-shared": { // for temporary compat only
+    kind: "enterprise-messaging-amqp",
+  },
+  "enterprise-messaging-http": {
+    outbox: true,
+    impl: `${_runtime}/messaging/enterprise-messaging.js`,
+    vcap: { label: "enterprise-messaging" },
+  },
+  "enterprise-messaging-amqp": {
     outbox: true,
-    impl: `${_runtime}/messaging/enterprise-messaging.js`
+    impl: `${_runtime}/messaging/enterprise-messaging-shared.js`,
+    vcap: { label: "enterprise-messaging" },
   },
   'message-queuing': {
     outbox: true,
@@ -85,6 +98,12 @@ module.exports = {
     // REVISIT: how to load model?
     // model: 'AuditLogService.cds',
     outbox: true,
-    use: "auditlog" // > without "-" for credentials lookup
+    vcap: { label: "auditlog" },
   }
 }
+
+
+function _compat_to_use(o) { return Object.defineProperties (o,{
+  // NOTE: Property .use is for compatibility only -> use .dialect instead!
+  use: { get(){ return this.dialect }, enumerable:true },
+})}