@sap/cds 7.4.2 → 7.5.1

package/lib/i18n/localize.js

@@ -6,7 +6,7 @@ const DEBUG = cds.debug('i18n')
 const _node_modules = cds.env.cdsc.moduleLookupDirectories.map(d => sep+d.slice(0, -1))
 
 module.exports = Object.assign (localize, {
-  localize, lookup, bundles4, folders4, folder4, bundle4
+  localize, lookup, bundles4, folders4, folder4, bundle4, files4, allLocales4
 })
 
 /**
@@ -61,11 +61,12 @@ function localize (aString, locale, model = cds.context?.model || cds.model, ext
 function bundles4 (model, locales = cds.env.i18n.languages) {
 
   const folders = folders4 (model); if (folders.length === 0) return
+  const {i18n} = cds.env
 
   if (locales.split) locales = locales.split(',')
   if (locales[0] === '*' || locales[0] === 'all') {
     locales = allLocales4 (folders); if (!locales) return {}
-    if (!locales.includes(cds.env.i18n.fallback_bundle))  locales.push (cds.env.i18n.fallback_bundle)
+    if (!locales.includes(i18n.fallback_bundle))  locales.push (i18n.fallback_bundle)
   }
 
   DEBUG?.('Languages:', locales)
@@ -79,23 +80,29 @@ function bundles4 (model, locales = cds.env.i18n.languages) {
   })()
 }
 
-/**
- * Return locales for all bundles found in given folders derived from .json, .properties or .csv files.
- *
- * TODO - .csv file handling seems to be questionable - do we need to check all .csv files additionally for locales ???
- */
-function allLocales4 (folders) {
-  // find all languages in all folders
+
+function files4 (folders_or_model) {
+  const {i18n} = cds.env
+  const folders = folders_or_model.map ? folders_or_model : folders4(folders_or_model)
   const files = folders.map (folder => readdirSync(folder)
-    .filter (e => e.startsWith(cds.env.i18n.file))
+    .filter (e => e.startsWith(i18n.file))
     .map(i18nFile => join (folder, i18nFile))
-  ).reduce ((files, file) => files.concat(file)) // flatten
-
+  ).flat()
   if (files.length === 0) {
     DEBUG?.('No languages for folders:', folders)
     return null
   }
+  return files
+}
 
+/**
+ * Return locales for all bundles found in given folders derived from .json, .properties or .csv files.
+ *
+ * TODO - .csv file handling seems to be questionable - do we need to check all .csv files additionally for locales ???
+ */
+function allLocales4 (folders_or_model) {
+  const files = files4(folders_or_model)
+  if (!files) return null
   if (files[0].endsWith('.csv')) {
     return cds.load.csv (files[0])[0].slice(1)
   } else {
@@ -129,35 +136,29 @@ function bundle4 (model, locale) {
   const bundles = model.texts || Object.defineProperty (model,'texts',{value:{}}).texts
   if (locale in bundles) return bundles[locale]
 
-  const bundle = {}
   const folders = folders4(model)
-  try {
-    if (!folders.length) return bundle
-
-    add (cds.env.i18n.fallback_bundle)  // e.g. i18n.properties
-    if (locale === cds.env.i18n.fallback_bundle) return bundle
-
-    add (cds.env.i18n.default_language)  // e.g. i18n_en.properties
-    if (locale === cds.env.i18n.default_language) return bundle
-
-    add (locale)  // e.g. i18n_de.properties
-    return bundle
-
-  } finally { bundles[locale] = bundle }
-
-  function add (lang) {
-    for (let each of folders) {
-      const suffix = lang === '' ? '' : '_' + lang
-      const file = join (each, cds.env.i18n.file),  key = file+suffix
-      const next = bundle4[key] || (bundle4[key] = (
-        loadFromJSON (file, lang)  ||
+  if (!folders.length) return bundles[locale] = {}
+
+  const {i18n} = cds.env
+  let bundle = null, locales = (
+    locale === i18n.fallback_bundle ? [ i18n.fallback_bundle ] :
+    locale === i18n.default_language ? [ i18n.fallback_bundle, i18n.default_language ] :
+    [ i18n.fallback_bundle, i18n.default_language, locale ]
+  )
+  for (let each of locales) {
+    const b = bundle = Object.create(bundle)
+    for (let folder of folders) {
+      const file = join (folder, i18n.file), suffix = each ? '_' + each : ''
+      const next = bundle4[file + suffix] ??= (
+        loadFromJSON (file, each)  ||
         cds.load.properties (file + suffix.replace('-','_')) ||  // e.g. en-UK --> en_UK
         cds.load.properties (file + suffix.match(/\w+/)) ||  // e.g. en_UK --> en
-        loadFromCSV (file, lang)
-      ))
-      Object.assign (bundle, next)
+        loadFromCSV (file, each)
+      )
+      Object.assign (b, next)
     }
   }
+  return bundles[locale] = bundle
 }
 
 /**
@@ -190,8 +191,9 @@ function folder4 (loc) {
   // already cached from a former lookup?
   if (loc in folder4)  return folder4[loc]
   // check whether a <loc>/_i18n exists
-  for (let i18n of cds.env.i18n.folders) {
-    const f = join (loc, i18n)
+  const {i18n} = cds.env
+  for (let each of i18n.folders) {
+    const f = join (loc, each)
     if (existsSync(f)) return folder4[loc] = f
   }
   //> no --> search up the folder hierarchy up to cds.root, cds.home, or some .../node_modules/<package>
@@ -202,7 +204,7 @@ function folder4 (loc) {
     if (!(
       next.startsWith(cds.root) ||
       next.startsWith(cds.home) ||
-      cds.env.i18n.root && next.startsWith(cds.env.i18n.root)
+      i18n.root && next.startsWith(i18n.root)
     )) return folder4[loc] = null
   }
   if (!next || next === loc) return folder4[loc] = null
@@ -212,12 +214,14 @@ function folder4 (loc) {
 
 
 function loadFromJSON (res, lang=cds.env.i18n.default_language) {
-  try {
-    const bundles = require (resolve (cds.root,res+'.json'))
-    return bundles[lang] || bundles [(lang.match(/\w+/)||[])[0]]
+  let cached = loadFromJSON[res]
+  if (!cached) try {
+    cached = loadFromJSON[res] = require (resolve (cds.root,res+'.json'))
   } catch(e) {
     if (e.code !== 'MODULE_NOT_FOUND') throw e
+    else cached = loadFromJSON[res] = {}
   }
+  return cached[lang] || cached[lang.match(/\w+/)?.[0]]
 }
 
 function loadFromCSV (res, lang=cds.env.i18n.default_language) {

package/lib/index.js

@@ -1,7 +1,7 @@
 if (process.env.CDS_STRICT_NODE_VERSION !== 'false') require('./utils/check-version')
 
-const { extend, lazify, lazified } = require('./lazy')
 const { EventEmitter } = require('node:events')
+const { extend, lazify } = require('./lazy')
 
 const cds = module.exports = new class cds extends EventEmitter {
 
@@ -41,13 +41,10 @@ const cds = module.exports = new class cds extends EventEmitter {
   get type()        { return super.type = this.builtin.classes.type }
   get array()       { return super.array = this.builtin.classes.array }
   get struct()      { return super.struct = this.builtin.classes.struct }
-  get service()     { return super.service = extend (this.builtin.classes.service) .with (lazified({
-    impl: (/** @type {(this:Service, srv:Service, ...etc) => any} */ srv) => srv,
-    protocols: lazy => require('./srv/protocols'),
-    bindings: lazy => require('./srv/bindings'),
-    factory: lazy => require('./srv/factory'),
+  get service()     { return super.service = extend (this.builtin.classes.service) .with ({
+    /** @param {( this:Service, srv:Service )} fn */ impl: fn => fn,
     /** @type Service[] */ providers: []
-  }))}
+  })}
 
   // Providing and Consuming Services
   /** @type {{ [name:string]: Service }} */
@@ -57,7 +54,8 @@ const cds = module.exports = new class cds extends EventEmitter {
   get server() { return super.server = require('../server') }
   get serve() { return super.serve = require('./srv/cds-serve') }
   get connect() { return super.connect = require('./srv/cds-connect') }
-  get outboxed() { return super.outboxed = require('../libx/outbox') }
+  get outboxed() { return super.outboxed = require('../libx/outbox').outboxed }
+  get unboxed() { return super.unboxed = require('../libx/outbox').unboxed }
   get middlewares() { return super.middlewares = require('./srv/middlewares') }
   get odata() { return super.odata = require('../libx/odata') }
   get auth() { return super.auth = require('./auth') }

package/lib/linked/classes.js

@@ -30,124 +30,13 @@ class action extends any {}
 class context extends any {}
 
 class service extends context {
-
-  static _protocols = []
-  get endpoints() { return super.endpoints = service.endpoints4(this) }
-  get path() { return super.path = service.path4(this) }
-
-  /**
-   * Return the first service endpoint path to mount it to
-   */
-  static path4 (srv, options = {}) {
-    return this.endpoints4(srv, options)[0]?.path
-  }
-
-  /**
-   * Return an array of protocol names to be served by the given service.
-   * Ensure that 'odata' shortcuts are expanded to 'odata-v4'.
-   */
-  static protocols4 (def, options = {}) {
-    const ov4 = p => p === 'odata' ? 'odata-v4' : p
-
-    if (options.to) return [ov4(options.to)]
-
-    const protocols = this._protocols
-    if (def) {
-      // Check @protocol annotation
-      let atProtocol = def['@protocol']
-      if (atProtocol === 'none') return []
-      if (atProtocol) {
-        const result = (Array.isArray(atProtocol) ? atProtocol : [atProtocol]).map(p => ov4(typeof p === 'string' ? p : p.kind))
-        return [...new Set(result)]
-      }
-
-      // Check @odata, @rest, ... shortcuts
-      const shortcut = Object.keys(protocols).find(p => def['@'+p])
-      if (shortcut) return [ov4(shortcut)]
-    }
-
-    // No protocol annotation found -> serve odata
-    return ['odata-v4']
-  }
-
-  static endpoints4 (srv, options = {}) {
-    const def = srv?.definition || srv
-    if (!def) return []
-
-    // Return a sluggified variant of the service's name
-    const pathFromServiceName4 = (srv) => {
-      return (
-        /[^.]+$/.exec(srv.name)[0]  //> my.very.CatalogService --> CatalogService
-        .replace(/Service$/,'')     //> CatalogService --> Catalog
-        .replace(/_/g,'-')          //> foo_bar_baz --> foo-bar-baz
-        .replace(/([a-z0-9])([A-Z])/g, (_,c,C) => c+'-'+C)  //> ODataFooBarX9 --> OData-Foo-Bar-X9
-        .toLowerCase()              //> FOO --> foo
-      )
-    }
-
-    // Return an array of service paths for a given service and protocol.
-    // The results are not prefixed with the protocol's path.
-    // Can return multiple results to support serving the same protocol on multiple paths:
-    // `@protocol: [{kind: 'odata', path: '/a'}, {kind: 'odata', path: '/b'}]`
-    const unprefixedPaths4 = (protocol, srv, options) => {
-      const def = srv?.definition || srv
-      if (options.at) return [options.at]
-      if (options.path) return [options.path]
-
-      const atProtocol = def['@protocol']
-      if (atProtocol) {
-        let paths = []
-        let protocols = Array.isArray(atProtocol) ? atProtocol : [atProtocol]
-        for (let p of protocols) {
-          let pName = (p.kind || p) === 'odata' ? 'odata-v4' : p.kind || p
-          if (pName === protocol) {
-            if (p.path) paths.push(p.path)
-            else paths.push(def['@path'] || pathFromServiceName4(srv))
-          }
-        }
-
-        // in case protocol is set via options.at but not contained in @protocol
-        if (paths.length === 0) paths.push(def['@path'] || pathFromServiceName4(srv))
-
-        return paths
-      }
-
-      if (def['@path']) return [def['@path']]
-      return [pathFromServiceName4(srv)]
-    }
-
-    const protocols = this.protocols4(def, options)
-
-    if (protocols.length > 1 && def['@path']?.[0] === '/') {
-      throw new Error(`Absolute @path (starting with '/') cannot be set for more than one protocol`)
-    }
-
-    const endpoints = [], env_protocols = global.cds?.env.protocols
-    const serve_on_root = global.cds?.env.features.serve_on_root
-
-    for (let each of protocols) {
-      let p = this._protocols[each] || env_protocols[each]
-      if (!p) throw new Error(`Protocol "${each}" is unknown`)
-
-      const middlewares = global.cds?.requires.middlewares
-      const kind = each
-      let prefix = middlewares ? p.path || '/' : '/' // > no middlewares, no prefix
-      if (!prefix.endsWith('/')) prefix += '/'
-      const unprefixedPaths = unprefixedPaths4(each, srv, options)
-      for (let path of unprefixedPaths) {
-        if (path.startsWith('/')) endpoints.push({ kind, path})
-        else {
-          // Extra serve in root if serve_on_root=true, but not(!) in case of ...
-          //   - multiple protocols
-          //   - empty prefix, which is the case for legacy protocol adapter
-          //   - middlewares=false (check only needed for handling of custom protocols)
-          if (middlewares && serve_on_root && protocols.length === 1 && prefix !== '/') endpoints.push({ kind, path: '/' + path })
-          endpoints.push({ kind, path: prefix + path })
-        }
-      }
-    }
-    return endpoints
-  }
+  /** @type <T> (p,v:T) => T */ static _lazy (p,v) { Reflect.defineProperty (this,p,{value:v}); return v }
+  static get protocols() { return this._lazy ('protocols', require('../srv/protocols')) }
+  static get bindings() { return this._lazy ('bindings', require('../srv/bindings')) }
+  static get factory() { return this._lazy ('factory', require('../srv/factory')) }
+  static endpoints4(..._) { return this.protocols.endpoints4(..._) }
+  static path4(..._) { return this.protocols.path4(..._) }
+  get _serves_odata() { return super._serves_odata = service.protocols._serves_odata(this) }
 }
 
 class array extends type { is(kind) { return kind === 'array' || super.is(kind) }}

package/lib/linked/entities.js

@@ -56,7 +56,7 @@ class Association extends struct {
 
   set keys(k) { super.keys = k }
   get keys() {
-    if (this.on || this.is2many || !this._target) return this._keys = undefined
+    if (this.on || this.is2many || !this._target) return this.set('_keys', undefined)
     const keys=[], tks = this._target.keys
     for (let k in tks) keys.push({ ref: [tks[k].name] })
     return this.keys = keys

package/lib/log/cds-log.js

@@ -1,12 +1,14 @@
-const cds = require ('../index'), conf = cds.env.log
+const cds = require('../index'), conf = cds.env.log
 const log = module.exports = exports = cds_log
 const path = require('path')
 
+
 /**
  * Cache used for all constructed loggers.
  */
 exports.loggers = {}
 
+
 /**
  * Returns a trace logger for the given module if trace is switched on for it,
  * otherwise returns null. All cds runtime packages use this method for their
@@ -130,20 +132,25 @@ exports.winstonLogger = (options) => (label, level) => {
   })
 }
 
+
 /**
  * Built-in formatters
  */
- const { simple } = exports.formatters = {
-  simple: (label, level, ...args) => [ `[${label}] -`, ...args ],
-  mt: (label, level, ...args) => {
+ const { _simple, _mt } = exports.formatters = {
+  _simple: (label, level, ...args) => [ `[${label}] -`, ...args ],
+  _mt: (label, level, ...args) => {
     const t = cds.context?.tenant; if (t) label += '|'+t
-    return simple (label, level, ...args)
+    return _simple (label, level, ...args)
+  },
+  get plain() {
+    return this._plain || (this._plain = cds.requires.multitenancy ? _mt : _simple)
   },
   get json() {
-    return this._json || (this._json = require('./format/cf'))
+    return this._json || (this._json = require('./format/json'))
   }
 }
 
+
 /**
  * Formats log outputs by returning an array of arguments which are passed to
  * console.log() et al.
@@ -155,10 +162,7 @@ exports.winstonLogger = (options) => (label, level) => {
  * @param {number} level the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
  * @param {any[]} args  the arguments passed to Logger.debug|log|info|warn|error()
  */
-exports.format = (
-  process.env.NODE_ENV === 'production' && cds.env.features.kibana_formatter ? log.formatters.json :
-  cds.requires.multitenancy ? log.formatters.mt : simple
-)
+exports.format = log.formatters[cds.env.log.format || 'plain']
 
 
 const DEBUG_matches = (m) => process.env.DEBUG?.match(RegExp(`\\b(y|all|${m||'any'})\\b`))
@@ -166,6 +170,7 @@ const { ERROR, WARN, INFO, DEBUG, TRACE } = exports.levels = {
   SILENT:0, ERROR:1, WARN:2, INFO:3, DEBUG:4, TRACE:5, SILLY:5, VERBOSE:5
 }
 
+
 ;(function _init() {
   const conf = cds.env.log
   if (conf.Logger) {

package/lib/log/format/aspects/als.js

@@ -0,0 +1,41 @@
+const cds = require('../../..')
+
+const $remove = Symbol('remove')
+
+const _is_custom_fields = (arg, custom_fields) => {
+  for (const k in arg) if (!(k in custom_fields)) return false
+  return true
+}
+
+const _is_categories = arg => arg.categories && Array.isArray(arg.categories) && Object.keys(arg).length === 1
+
+function als_aspect(module, level, args, toLog) {
+  // REVISIT: kibana_custom_fields for backward compatibility. remove in cds^8.
+  const { als_custom_fields, kibana_custom_fields } = cds.env.log
+  this._CUSTOM_FIELDS ??= kibana_custom_fields ? { ...kibana_custom_fields } : { ...als_custom_fields }
+  this._HAS_CUSTOM_FIELDS ??= Object.keys(this._CUSTOM_FIELDS).length > 0
+
+  // extract custom fields and categories from remaining args (while avoiding as many loops/ iterations as possible)
+  if (args.length) {
+    let filter4removed = false
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i]
+      if (typeof arg !== 'object') continue
+      if ((this._HAS_CUSTOM_FIELDS && _is_custom_fields(arg, this._CUSTOM_FIELDS)) || _is_categories(arg)) {
+        Object.assign(toLog, arg)
+        args[i] = $remove
+        filter4removed = true
+      }
+    }
+    if (filter4removed) args.sort((a, b) => (b === $remove) * -1).splice(args.lastIndexOf($remove))
+  }
+
+  // ALS custom fields
+  if (this._HAS_CUSTOM_FIELDS) {
+    const cf = []
+    for (const k in this._CUSTOM_FIELDS) if (toLog[k]) cf.push({ k, v: toLog[k], i: this._CUSTOM_FIELDS[k] })
+    if (cf.length) toLog['#cf'] = { string: cf }
+  }
+}
+
+module.exports = process.env.VCAP_SERVICES?.match(/"label":\s*"application-logs"/) ? als_aspect : () => {}

package/lib/log/format/aspects/cf.js

@@ -0,0 +1,36 @@
+const cds = require('../../..')
+
+const _get_cf_fields = () => {
+  const cf_fields = {
+    layer: 'cds',
+    component_type: 'application',
+    container_id: process.env.CF_INSTANCE_IP
+  }
+  const VCAP_APPLICATION = process.env.VCAP_APPLICATION && JSON.parse(process.env.VCAP_APPLICATION)
+  if (VCAP_APPLICATION) {
+    Object.assign(cf_fields, {
+      component_id: VCAP_APPLICATION.application_id,
+      component_name: VCAP_APPLICATION.application_name,
+      component_instance: VCAP_APPLICATION.instance_index,
+      source_instance: VCAP_APPLICATION.instance_index,
+      organization_name: VCAP_APPLICATION.organization_name,
+      organization_id: VCAP_APPLICATION.organization_id,
+      space_name: VCAP_APPLICATION.space_name,
+      space_id: VCAP_APPLICATION.space_id
+    })
+  }
+  return cf_fields
+}
+
+function cf_aspect(module, level, args, toLog) {
+  this._CF_FIELDS ??= _get_cf_fields()
+
+  // add static fields from environment
+  Object.assign(toLog, this._CF_FIELDS)
+
+  // add subdomain, if available (use cds.context._ instead of cds.context.http because of messaging)
+  const tenant_subdomain = cds.context?._?.req?.authInfo?.getSubdomain?.()
+  if (tenant_subdomain) toLog.tenant_subdomain = tenant_subdomain
+}
+
+module.exports = process.env.CF_INSTANCE_GUID ? cf_aspect : () => {}

package/lib/log/format/json.js

@@ -0,0 +1,96 @@
+const cds = require('../../')
+
+const util = require('util')
+
+const L2L = { 1: 'error', 2: 'warn', 3: 'info', 4: 'debug', 5: 'trace' }
+const HEADER_MAPPINGS = {
+  x_vcap_request_id: 'request_id',
+  content_length: 'request_size_b'
+}
+
+const _is4xx = ele =>
+  (ele.code >= 400 && ele.code < 500) ||
+  (ele.status >= 400 && ele.status < 500) ||
+  (ele.statusCode >= 400 && ele.statusCode < 500)
+
+const _getCircularReplacer = () => {
+  const seen = new WeakSet()
+  return (key, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) return 'cyclic'
+      seen.add(value)
+    }
+    return value
+  }
+}
+
+/*
+ * JSON-based log formatter for use in production
+ */
+module.exports = function format(module, level, ...args) {
+  // config
+  const { user: log_user, mask_headers, aspects } = cds.env.log
+  this._MASK_HEADERS ??= (mask_headers || []).map(s => {
+    const parts = s.match(/\/(.+)\/(\w*)/)
+    if (parts) return new RegExp(parts[1], parts[2])
+    return new RegExp(s)
+  })
+  this._ASPECTS ??= (aspects || []).map(require)
+
+  // the object to log
+  const toLog = {
+    level: L2L[level] || 'info',
+    logger: module
+  }
+
+  // add correlation
+  if (cds.context) {
+    const { id, tenant, user } = cds.context
+    toLog.correlation_id = id
+    if (tenant) toLog.tenant_id = tenant
+    // log user id, if configured (data privacy)
+    if (user && log_user) toLog.remote_user = user.id
+    // if available, add headers (normalized to lowercase and with _ instead of -) with masking as configured and mappings applied
+    const req = cds.context._ && cds.context._.req
+    if (req && req.headers) {
+      for (const k in req.headers) {
+        const h = k.replace(/-/g, '_').toLowerCase()
+        toLog[h] = (() => {
+          if (this._MASK_HEADERS.some(m => k.match(m))) return '***'
+          return req.headers[k]
+        })()
+        if (h in HEADER_MAPPINGS) toLog[HEADER_MAPPINGS[h]] = toLog[h]
+      }
+    }
+  }
+  toLog.timestamp = new Date()
+
+  // merge toLog with passed Error (or error-like object)
+  if (args.length && typeof args[0] === 'object' && args[0].message) {
+    const err = args.shift()
+    toLog.msg = err.message
+    if (typeof err.stack === 'string' && !_is4xx(err)) toLog.stacktrace = err.stack.split(/\s*\r?\n\s*/)
+    if (Array.isArray(err.details))
+      for (const d of err.details)
+        if (typeof d.stack === 'string' && !_is4xx(d)) d.stacktrace = d.stack.split(/\s*\r?\n\s*/)
+    Object.assign(toLog, err, { level: toLog.level })
+  }
+
+  // apply aspects
+  for (const each of this._ASPECTS) each.call(this, module, level, args, toLog)
+
+  // append remaining args via util.format()
+  if (args.length) toLog.msg = toLog.msg ? util.format(toLog.msg, ...args) : util.format(...args)
+
+  // REVISIT: should not be necessary with new protocol adapters
+  // 4xx: lower to warning (if error)
+  if (toLog.level && toLog.level.match(/error/i) && _is4xx(toLog)) toLog.level = 'warn'
+
+  // return array with the stringified toLog (to avoid multiple log lines) as the sole element
+  try {
+    return [JSON.stringify(toLog)]
+  } catch (e) {
+    // try again with removed circular references
+    return [JSON.stringify(toLog, _getCircularReplacer())]
+  }
+}

package/lib/plugins.js

@@ -1,5 +1,8 @@
+
 const cds = require('.')
 
+exports.require = require
+
 /**
  * Fetch cds-plugins from project's package dependencies.
  * Used in and made available through cds.env.plugins.
@@ -9,11 +12,12 @@ exports.fetch = function (DEV = process.env.NODE_ENV !== 'production') {
   fetch_plugins_in (cds.home, false)
   fetch_plugins_in (cds.root, DEV)
   function fetch_plugins_in (root, dev) {
-    let pkg; try { pkg = require(root + '/package.json') } catch { return }
+    let pkg; try { pkg = exports.require(root + '/package.json') } catch { return }
     let deps = { ...pkg.dependencies, ...dev && pkg.devDependencies }
     for (let each in deps) try {
-      let impl = require.resolve(each + '/cds-plugin', { paths: [root] })
-      plugins[each] = { impl }
+      let impl = exports.require.resolve(each + '/cds-plugin', { paths: [root] })
+      const packageJson = exports.require.resolve(each + '/package.json', { paths: [root] })
+      plugins[each] = { impl, packageJson }
     } catch { /* no cds-plugin.js */ }
   }
   return plugins

package/lib/req/context.js

@@ -16,8 +16,10 @@ class EventContext {
     const ctx = new this (_)
     const base = cds.context
     if (base) {
-      ctx._set('_propagated', base) // we inherit from former cds.currents
-      if (!_as_root) {
+      // we inherit from former cds.currents (except for the timestamp if new root ctx)
+      if (_as_root) ctx._set('_propagated', Object.create(base, { timestamp: { value: undefined } }))
+      else {
+        ctx._set('_propagated', base)
         if (!ctx.context) ctx._set('context', base.context) // all transaction handling works with root contexts
         if (!ctx.tx && base.tx) ctx.tx = base.tx
       }

package/lib/srv/cds-connect.js

@@ -43,11 +43,9 @@ connect.to = async (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.prepend (srv.init, srv.options.impl)
+  let srv = await new Service (datasource,m,o); await srv._init()
+  if (o.outbox) srv = cds.outboxed(srv)
   if (datasource === 'db') cds.db = srv
-  // outbox the service, if configured
-  if (srv.options.outbox) srv = cds.outboxed(srv)
   _done (cds.services[datasource] = srv)
   if (!o.silent) cds.emit ('connect',srv)
   TRACE?.timeEnd(`cds.connect ${datasource} `)
@@ -55,7 +53,7 @@ connect.to = async (datasource, options) => {
 }
 
 function options4 (name, _o) {
-  const [, kind=_o && _o.kind, url] = /^(\w+):(.*)/.exec(name) || []
+  const [, kind=_o?.kind, url ] = /^(\w+):(.*)/.exec(name) || []
   const conf = cds.requires[name] || cds.requires[kind] || cds.requires.kinds[name] || cds.requires.kinds[kind]
   const o = { kind, ...conf, ..._o }
   if (!o.kind && !o.impl && !o.silent) throw cds.error(