@sap/cds-dk 9.9.2 → 10.0.3

package/node_modules/@sap/cds/lib/index.js

@@ -0,0 +1,156 @@
+if (process.env.CDS_STRICT_NODE_VERSION !== 'false') require('./utils/version').checkNodeVersion()
+
+const { AsyncLocalStorage } = require ('async_hooks')
+const context = new AsyncLocalStorage
+
+const { EventEmitter } = require('node:events')
+const cds = exports = module.exports = global.cds = new class cds extends EventEmitter {
+
+  /** Contexts and Transactions @type {import('./req/context.js')} */
+  get context()  { return context.getStore() }
+  set context(x) { this._with(x) }
+  _with (x,fn,...args) {
+    const ctx = typeof x !== 'object' || x instanceof exports.EventContext ? x : x.context || exports.EventContext.for(x)
+    return fn ? context.run (ctx,fn,...args) : context.enterWith (ctx)
+  }
+  get spawn() { return super.spawn = require('./req/spawn.js') }
+
+  /** @import {LinkedCSN} from './core/linked-csn.js' */
+  /** @import {Service} from './srv/cds.Service.js' */
+  /** @type LinkedCSN */ model = undefined
+  /** @type Service */ db = undefined
+  /** CLI args */ cli = { command:'', options:{}, argv:[] }
+  /** Working dir */ root = process.cwd()
+
+  emit (eve, ...args) {
+    if (eve === 'served') return this.listeners(eve) .reduce (
+      (p,each) => p.then(()=> each.call(this,...args)),
+      Promise.resolve()
+    )
+    else return super.emit (eve, ...args)
+  }
+
+  // Configuration & Information
+  get requires() { return super.requires = this.env.requires._resolved() }
+  get plugins()  { return super.plugins = require('./plugins.js').activate() }
+  get version()  { return super.version = require('../package.json').version }
+  get env()      { return super.env = require('./env/cds-env.js').for(this) }
+  get home()     { return super.home = __dirname.slice(0,-4) }
+  get schema()   { return super.schema = require('./env/schemas/index.js') } // REVISIT: Better move that to cds-dk?
+
+  // Loading and Compiling Models
+  get compiler() { return super.compiler = require('./compile/cdsc.js') }
+  get compile()  { return super.compile = require('./compile/cds-compile.js') }
+  get resolve()  { return super.resolve = require('./compile/resolve.js') }
+  get load()     { return super.load = require('./compile/load.js') }
+  get get()      { return super.get = this.load.parsed }
+  get parse()    { return super.parse = require('./compile/parse.js') }
+  get minify()   { return super.minify = require('./compile/minify.js') }
+  get extend()   { return super.extend = require('./compile/extend.js') }
+  get deploy()   { return super.deploy = require('./dbs/cds-deploy.js') }
+  get localize() { return super.localize = require('./i18n/localize.js') }
+  get i18n()     { return super.i18n = require('./i18n/index.js') }
+
+  // Model Reflection, Builtin types and classes
+  get entities()    { return (this.model||this.db?.model)?.entities }
+  get reflect()     { return super.reflect = this.linked }
+  get linked()      { return super.linked = require('./core/linked-csn.js') }
+  get builtin()     { return super.builtin = require('./core/types.js') }
+  get Association() { return super.Association = this.builtin.classes.Association }
+  get Composition() { return super.Composition = this.builtin.classes.Composition }
+  get entity()      { return super.entity = this.builtin.classes.entity }
+  get event()       { return super.event = this.builtin.classes.event }
+  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 = Object.assign (this.builtin.classes.service, {
+    /** @param {( this:Service, srv:Service )} fn */ impl: fn => fn,
+    /** @type Service[] */ providers: []
+  })}
+
+  // Providing and Consuming Services
+  /** @type { Record<string,Service> } */ services = new class {
+    *[Symbol.iterator](){ for (let e in this) yield this[e] }
+  }
+  get server() { return super.server = require('../server.js') }
+  get serve() { return super.serve = require('./srv/cds-serve.js') }
+  get connect() { return super.connect = require('./srv/cds-connect.js') }
+  get outboxed() { return this.queued }
+  get unboxed() { return this.unqueued }
+  get queued() { return super.queued = require('../libx/queue/api.js').queued }
+  get unqueued() { return super.unqueued = require('../libx/queue/api.js').unqueued }
+  get flush() { return super.flush = require('../libx/queue/api.js').cdsFlush }
+  get middlewares() { return super.middlewares = require('./srv/middlewares/index.js') }
+  get odata() { return super.odata = require('../libx/odata/index.js') }
+  get auth() { return super.auth = require('./srv/middlewares/auth/index.js') }
+  shutdown() { this.app?.server && process.exit() } // is overridden in bin/serve.js
+
+  // Core Services API
+  get Service() { return super.Service = require('./srv/cds.Service.js') }
+  get EventContext() { return super.EventContext = require('./req/context.js') }
+  get Request() { return super.Request = require('./req/request.js') }
+  get Event() { return super.Event = require('./req/event.js') }
+  get User() { return super.User = require('./req/user.js') }
+  get validate() { return super.validate = require('./req/validate.js') }
+
+  // Services, Protocols and Periphery
+  get ApplicationService() { return super.ApplicationService = require('../srv/app-service.js') }
+  get MessagingService() { return super.MessagingService = require('../srv/msg-service.js') }
+  get DatabaseService() { return super.DatabaseService = require('../srv/db-service.js') }
+  get RemoteService() { return super.RemoteService = require('../srv/remote-service.js') }
+
+  // Helpers
+  get utils() { return super.utils = require('./utils/cds-utils.js') }
+  get error() { return super.error = require('./log/cds-error.js') }
+  get exec() { return super.exec = require('../bin/serve.js').exec }
+  get test() { return super.test = require('./test/cds-test.js') }
+  get log() { return super.log = require('./log/cds-log.js') }
+  get debug() { return super.debug = this.log.debug }
+  clone(x) { return structuredClone(x) }
+
+  // Querying and Databases
+  get infer(){ return super.infer = require('./ql/cds.ql-infer.js') }
+  get txs()  { return super.txs = new this.Service('cds.tx') }
+  get ql()   { return super.ql = require('./ql/cds-ql.js') }
+  // get tx() { return super.tx = this.Service.prototype.tx.bind (new this.Service) } // Note: this would break too much of existing code/tests
+  tx         (..._) { return (this.db || this.txs).tx(..._) }
+  run        (..._) { return (this.db || typeof _[0] === 'function' && this.txs || this.error._no_primary_db).run(..._) }
+  foreach    (..._) { return (this.db || this.error._no_primary_db).foreach(..._) }
+  read       (..._) { return this.ql.SELECT(..._) }
+  create     (..._) { return this.ql.INSERT.into(..._) }
+  insert     (..._) { return this.ql.INSERT(..._) }
+  upsert     (..._) { return this.ql.UPSERT(..._) }
+  update     (..._) { return this.ql.UPDATE.entity(..._) }
+  delete     (..._) { return this.ql.DELETE.from(..._) }
+  disconnect (..._) { return this.db?.disconnect(..._) }
+
+  // Deprecated stuff to be removed in upcomming releases...
+  /** @deprecated */ get lazified() { return this.lazify }
+  /** @deprecated */ get lazify() { return super.lazify = require('./utils/lazify.js') }
+  /** @deprecated */ get in() { return super.in = cwd => !cwd ? this : {__proto__:this, cwd, env: this.env.for('cds',cwd) } }
+  /** @deprecated */ exit(code){ return this.app?.server ? this.shutdown() : process.exit(code) }
+  /** @deprecated */ transaction (..._) { return (this.db||this.error._no_primary_db).transaction(..._) }
+}
+
+// Add global convenience shortcuts for cds.ql and cds.parse commands
+cds.extend (global) .with ( class globals {
+  get SELECT() { return Q('SELECT') }
+  get INSERT() { return Q('INSERT') }
+  get UPSERT() { return Q('UPSERT') }
+  get UPDATE() { return Q('UPDATE') }
+  get DELETE() { return Q('DELETE') }
+  /** @deprecated */ get CREATE() { return D('CREATE', '{CREATE} = cds.ql', cds.ql.CREATE) }
+  /** @deprecated */ get DROP() { return D('DROP', '{DROP} = cds.ql', cds.ql.DROP) }
+  /** @deprecated */ get CDL() { return D('CDL', 'cds.parse.cdl', cds.parse.cdl) }
+  /** @deprecated */ get CQL() { return D('CQL', 'cds.parse.cql', cds.parse.cql) }
+  /** @deprecated */ get CXL() { return D('CXL', 'cds.parse.expr', cds.parse.expr) }
+} .prototype )
+function Q (p) { return G (p, cds.ql[p]) }
+function D (old,use,fn) { return G (old, cds.utils.deprecated (fn,{kind:'Global constant',old,use})) }
+function G (p,v) { Object.defineProperty (global, p, { value:v, enumerable:1,configurable:1}); return v }
+
+// Allow for `import cds from '@sap/cds'` without `esModuleInterop` in tsconfig.json
+Object.defineProperties (exports, { default: {value:cds}, __esModule: {value:true} })
+
+// track from where we loaded cds, lowercase to avoid path duplicates on Windows
+!(global.__cds_loaded_from ??= new Set).add(cds.home.toLowerCase()) 

package/node_modules/@sap/cds/lib/log/cds-error.js

@@ -0,0 +1,114 @@
+const { format, inspect } = require('../utils/cds-utils')
+
+
+/**
+ * Constructs and optionally throws an Error object.
+ * Usage variants:
+ *
+ *       cds.error (404, 'code', 'message', { ... details })
+ *       cds.error (404, { ... details })
+ *       cds.error ({ ... any details })
+ *       cds.error ('code', 'message', { ... details })
+ *       cds.error ('message', { ... details })
+ *       cds.error `template string usage variant`
+ *       cds.error (new Error, { ... any details })
+ *
+ * When called with `new` the newly created Error is returned.
+ * When called without `new` the error is thrown immediately.
+ * The latter is useful for usages like that:
+ *
+ *       let x = y || cds.error `expected y to be defined`
+ *
+ * @param {number} [status] - HTTP status code
+ * @param {string} [code] - Stable error code, which clients can rely on
+ * @param {string} [message] - Human-readable error message
+ * @param {object} [details] - Additional error details
+ * @param {Function} [caller] - The function calling us => stack trace cut off here
+ * @returns {Error} The constructed Error (only when called with `new`)
+ */
+const error = exports = module.exports = function error ( status, code, msg, details, caller ) {
+  let e = details
+  if (status?.raw) [ msg, status, code, e, caller ] = [ error.message(...arguments) ]
+  if (typeof status !== 'number') [ status, code, msg, e, caller ] = [ undefined, status, code, msg, e, caller ]
+  if (typeof code === 'object') [ code, msg, e, caller ] = [ undefined, undefined, code, msg ]
+  if (typeof msg === 'object') [ code, msg, e, caller ] = [ undefined, code, msg, e ]
+  if (typeof e === 'string') [ status, msg, e, caller ] = [ msg, e, caller, error ]
+  if (code && !msg) [ code, msg ] = [ undefined, code ]
+  if (e instanceof Error || typeof e === 'object' && 'stack' in e) { // is error?
+    e = Object.assign (e, caller) //> yes -> just decorate it
+  } else {
+    e = Object.assign (new Error (msg, e), e)
+    Error.captureStackTrace (e, caller || error)
+  }
+  if (status) e.status = status
+  if (code) e.code = code
+  if (new.target) return e; else throw e
+}
+
+/**
+ * Constructs a message from a tagged template string. In contrast to usual
+ * template strings embedded values are formatted using `util.format`
+ * not just `toString()`.
+ *
+ *     let x = `A sample message with ${'a string'}, ${{an:'object'}}, and ${[1,2,3]}`
+ *     let y = cds.error.message`with ${'a string'}, ${{an:'object'}}, and ${[1,2,3]}`
+ *     //> x = A sample message with a string and [object Object], and 1,2,3
+ *     //> y = with a string, { an: 'object' }, and [ 1, 2, 3 ]
+ */
+exports.message = (strings,...values) => {
+  return String.raw(strings,...values.map(v => format(v)))
+}
+
+
+/**
+ * Use that to construct and throw errors from a tagged template string
+ * in validations of function arguments.
+ * Use it like that:
+ *
+ *     let x = {foo:'bar'}
+ *     typeof x === 'string' || cds.error.expected `${{x}} to be a string`
+ *     //> Error: Expected argument 'x' to be a string, but got: { foo: 'bar' }
+ */
+exports.expected = function expected ([,_to_be_expected], arg) {
+  const [name] = Object.keys(arg), value = arg[name]
+  return error (`Expected argument ${inspect(name)}${_to_be_expected}, but got: ${inspect(value)}`, undefined, expected)
+}
+
+exports.isSystemError = err => {
+  // all errors thrown by the peggy parser or body-parser (used by express.json) should not crash the app
+  if (err.name === 'SyntaxError' && (err.constructor?.name === 'peg$SyntaxError' || err.type === 'entity.parse.failed')) return false
+  return err.name in {
+    TypeError:1,
+    ReferenceError:1,
+    SyntaxError:1,
+    RangeError:1,
+    URIError:1,
+  }
+}
+
+//
+// Private helpers ...
+//
+
+exports._duplicate_cds = (...locations) => {
+  const { local } = require('../utils/cds-utils')
+  throw error `Duplicate @sap/cds/common!
+
+  There are duplicate versions of @sap/cds loaded from these locations:
+
+    ${locations.map(local).join('\n    ')}
+
+  To fix this, check all dependencies to "@sap/cds" in your package.json and
+  those of reused packages and ensure they allow deduped use of @sap/cds.
+  `
+}
+
+exports._no_primary_db = new Proxy ({},{ get: function fn(_,p) { error (`Not connected to primary datasource!
+
+  Attempt to use 'cds.${p}' without prior connect to primary datasource,
+  i.e. cds.connect.to('db').
+  ${ process.argv[1].endsWith('cds') && process.argv[2] in {run:1,serve:1} ? `
+  Please configure one thru 'cds.requires.db' or use in-memory db:
+  cds ${process.argv[2]} --in-memory` : ''}`
+
+,{},fn) }})

package/node_modules/@sap/cds/lib/log/cds-log.js

@@ -0,0 +1,215 @@
+const log = module.exports = exports = cds_log
+const cds = require('../index'), defaults = { format: 'plain', levels: {} }
+let conf = Object.hasOwn(cds,'env') ? cds.env.log : defaults
+/* eslint-disable no-console */
+
+
+/**
+ * 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
+ * trace and debug output. It can also be used in applications like that:
+ *
+ *    const LOG = cds.log('sql')
+ *    LOG._info && LOG.info ('whatever', you, 'like...')
+ *
+ * You can also specify alternate module names:
+ *
+ *    const LOG = cds.log('sql|db')
+ *
+ * By default this logger would prefix all output with '[sql] - '.
+ * You can change this by specifying another prefix in the options:
+ *
+ *    const LOG = cds.log('sql|db',{ prefix:'cds.ql' })
+ *
+ * Call cds.log() for a given module again to dynamically change the log level
+ * of all formerly created loggers, for example:
+ *
+ *    const LOG = cds.log('sql')
+ *    LOG.info ('this will show, as default level is info')
+ *    cds.log('sql','warn')
+ *    LOG.info ('this will be suppressed now')
+ *
+ * Tracing can be switched on/off through env variable DEBUG:
+ * Set it to a comma-separated list of modules to switch on tracing.
+ * Set it to 'all' or 'y' to switch on tracing for all modules.
+ *
+ * @param {string} [module] the module for which a logger is requested
+ * @param {string|number|{ level, prefix }} [options] the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
+ */
+function cds_log (module, options) {
+  const id = module?.match(/^[^|]+/)[0] || 'cds', cache = log.loggers
+  const cached = cache[id]
+  if (cached && options == undefined) return cached // Note: SILENT = 0, so falsy check on option would be wrong
+
+  let label = options?.label || options?.prefix || cached?.label || id
+  let level = typeof options === 'object' ? options.level : options
+  if (level == undefined) level = DEBUG_matches(module) ? DEBUG : conf.levels[id] || INFO
+  if (typeof level === 'string') level = log.levels [level.toUpperCase()]
+  if (cached && cached.level === level) return cached
+
+  const logger = new Logger (label, level)
+  return cache[id] = Object.assign (cached || logger.log, {
+    id, label, level, setFormat(fn){ logger.format = fn; return this },
+    _trace: level >= TRACE,
+    _debug: level >= DEBUG,
+    _info:  level >= INFO,
+    _warn:  level >= WARN,
+    _error: level >= ERROR,
+  }, logger)
+}
+
+
+/**
+ * Shortcut to `cds.log(...).debug`, returning undefined if `cds.log(...)._debug` is false.
+ * @param {string} [module] the module for which a logger is requested
+ * @param {object} [options] logger options
+ */
+exports.debug = function cds_debug (id, options) {
+  const L = cds_log (id, options)
+  return Object.assign((..._) => L._debug && L.debug (..._), {
+    time:    label => L._debug && console.time    (`[${id}] - ${label}`),
+    timeEnd: label => L._debug && console.timeEnd (`[${id}] - ${label}`),
+  })
+}
+
+
+/**
+ * Constructs a new Logger with the method signature of `{ debug, log, info, warn, error }`
+ * from console. The default implementation actually maps it to `global.console`.
+ * You can assign different implementations, e.g. to integrate with advanced
+ * logging frameworks, for example like that:
+ *
+ *    cds.log.Logger = () => winston.createLogger (...)
+ *
+ * @param {string} [label] the module for which a logger is requested
+ * @param {number} [level]  the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
+ */
+exports.Logger = (label, level) => {
+  const fmt = (level,args) => logger.format (label,level,...args)
+  const logger = {
+    format: exports.format, // use logger.format as this could be changed dynamically
+    trace:  level < DEBUG ? ()=>{} : (...args) => console.trace (...fmt(TRACE,args)),
+    debug:  level < DEBUG ? ()=>{} : (...args) => console.debug (...fmt(DEBUG,args)),
+    log:    level < INFO  ? ()=>{} : (...args) => console.log (...fmt(INFO,args)),
+    info:   level < INFO  ? ()=>{} : (...args) => console.info (...fmt(INFO,args)),
+    warn:   level < WARN  ? ()=>{} : (...args) => console.warn (...fmt(WARN,args)),
+    error:  level < ERROR ? ()=>{} : (...args) => console.error (...fmt(ERROR,args)),
+  }
+  return logger
+}
+function Logger (label, level) { return exports.Logger (label, level) }
+
+
+/**
+ * Convenience method to construct winston loggers, very similar to `winston.createLogger()`.
+ * @param {object} options - as in `winston.createLogger()`
+ * @returns The winston logger, decorated with the standard cds.log methods
+ * .debug(), .info(), .warn(), .error(), etc.
+ */
+exports.winstonLogger = (options) => (label, level) => {
+  const winston = require("winston")
+  const logger = winston.createLogger({
+    levels: log.levels, level: Object.keys(log.levels)[level],
+    transports: [new winston.transports.Console()],
+    ...options
+  })
+  const { formatWithOptions } = require('util')
+  const _fmt = ([...args]) => formatWithOptions(
+    { colors: false }, `[${label}] -`, ...args
+  )
+  return Object.assign (logger, {
+    trace: (...args) => logger.TRACE (_fmt(args)),
+    debug: (...args) => logger.DEBUG (_fmt(args)),
+    log:   (...args) => logger.INFO  (_fmt(args)),
+    info:  (...args) => logger.INFO  (_fmt(args)),
+    warn:  (...args) => logger.WARN  (_fmt(args)),
+    error: (...args) => logger.ERROR (_fmt(args)),
+  })
+}
+
+
+/**
+ * Built-in formatters
+ */
+ exports.formatters = new class {
+  plain (label, level, ...args) { return [ `[${label}] -`, ...args ] }
+  get json() { return super.json = require('./format/json') }
+}
+
+
+/**
+ * Formats log outputs by returning an array of arguments which are passed to
+ * console.log() et al.
+ * You can assign custom formatters like that:
+ *
+ *    cds.log.format = (label, level, ...args) => [ '[', label, ']', ...args ]
+ *
+ * @param {string} label the label to prefix to log output
+ * @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 = log.formatters[conf.format || 'plain']
+
+
+const DEBUG_matches = (m='cds') => process.env.DEBUG?.match(RegExp(`\\b(y|all|${m||'any'})\\b`))
+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 applyLogConfig() {
+  let { loggers, format } = exports, fmt = format
+  let { plain } = log.formatters
+  conf = cds.env.log
+
+  // Update log levels for already existing loggers
+  if (conf.levels) {
+    for (let each in conf.levels) cds_log (each, conf.levels[each])
+  }
+
+  // User configured formatter, if any
+  if (conf.format) {
+    fmt = exports.format = log.formatters [conf.format]
+  }
+
+  // Include tenant in plain log output if multitenancy is enabled
+  if (fmt === plain && cds.env.requires.multitenancy) {
+    fmt = exports.format = (label, level, ...args) => {
+      const t = cds.context?.tenant; if (t) label += '|'+t
+      return plain (label, level, ...args)
+    }
+  }
+
+  // If formatter got changed above, propagate to all loggers
+  if (fmt !== format) {
+    for (let each in loggers) loggers[each] .setFormat (fmt)
+  }
+
+  _init()
+}
+
+// If cds.env is not yet loaded, update the loggers when it is
+if (conf === defaults) cds.once ('env', applyLogConfig);
+else applyLogConfig() // otherwise apply the current config
+
+function _init() {
+  if (conf.Logger) {
+    const path = require('path')
+    let resolvedPath
+    try { resolvedPath = require.resolve(conf.Logger) } catch {
+      try { resolvedPath = require.resolve(path.join(cds.root, conf.Logger)) } catch {
+        throw new Error(`Cannot find logger at "${conf.Logger}"`)
+      }
+    }
+    exports.Logger = require (resolvedPath) // Use configured logger in case of cds serve
+  }
+  if (conf.service) {
+    const {app} = cds, serveIn = app => require('./service').serveIn(app)
+    app ? setImmediate(() => serveIn(app)) : cds.on('bootstrap', app => serveIn(app))
+  }
+}

package/node_modules/@sap/cds/lib/log/format/aspects/als.js

@@ -0,0 +1,27 @@
+const cds = require('../../..')
+
+function als_aspect(module, level, args, toLog) {
+  this._ALS_CUSTOM_FIELDS ??= { ...cds.env.log.als_custom_fields }
+  this._ALS_HAS_CUSTOM_FIELDS ??= Object.keys(this._ALS_CUSTOM_FIELDS).length > 0
+
+  // ALS custom fields
+  if (this._ALS_HAS_CUSTOM_FIELDS) {
+    const cf = []
+    for (const k in this._ALS_CUSTOM_FIELDS) {
+      if (toLog[k]) {
+        const i = cf.findIndex(e => e.i === this._ALS_CUSTOM_FIELDS[k])
+        if (i > -1) cf[i] = { k, v: toLog[k], i: this._ALS_CUSTOM_FIELDS[k] }
+        else cf.push({ k, v: toLog[k], i: this._ALS_CUSTOM_FIELDS[k] })
+      }
+    }
+    if (cf.length) toLog['#cf'] = { string: cf }
+  }
+}
+
+als_aspect.cf = () => Object.keys({ ...cds.env.log.als_custom_fields })
+
+const vcap_services = process.env.VCAP_SERVICES_FILE_PATH
+  ? cds.utils.fs.readFileSync(process.env.VCAP_SERVICES_FILE_PATH, 'utf-8')
+  : process.env.VCAP_SERVICES
+
+module.exports = vcap_services?.match(/"label":\s*"application-logs"/) ? als_aspect : () => {}

package/node_modules/@sap/cds/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
+  const tenant_subdomain = cds.context?.user?.authInfo?.getSubdomain?.()
+  if (tenant_subdomain) toLog.tenant_subdomain = tenant_subdomain
+}
+
+module.exports = process.env.CF_INSTANCE_GUID ? cf_aspect : () => {}

package/node_modules/@sap/cds/lib/log/format/aspects/cls.js

@@ -0,0 +1,19 @@
+const cds = require('../../..')
+
+function cls_aspect(/* module, level, args, toLog */) {
+  // actually nothing to do
+}
+
+cls_aspect.cf = () => [...cds.env.log.cls_custom_fields]
+
+const vcap_services = JSON.parse(
+  process.env.VCAP_SERVICES_FILE_PATH
+    ? cds.utils.fs.readFileSync(process.env.VCAP_SERVICES_FILE_PATH, 'utf-8')
+    : process.env.VCAP_SERVICES || '{}'
+)
+
+module.exports =
+  vcap_services['cloud-logging'] ||
+  vcap_services['user-provided']?.find(e => e.tags.includes('cloud-logging') || e.tags.includes('Cloud Logging'))
+    ? cls_aspect
+    : () => {}