@sap/cds 6.0.4 → 6.1.2

package/lib/log/{errors.js → cds-error.js}

@@ -60,7 +60,7 @@ exports.expected = ([,type], arg) => {
 //
 
 exports._duplicate_cds = (...locations) => {
-  const { local } = require('../utils')
+  const { local } = require('../utils/cds-utils')
   throw error `Duplicate @sap/cds/common!
 
   There are duplicate versions of @sap/cds loaded from these locations:

package/lib/log/format/kibana.js

@@ -56,6 +56,24 @@ module.exports = (module, level, ...args) => {
     if (cf.length) toLog['#cf'] = { string: cf }
   }
 
+  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
+    }
+  }
+  
   // return array with the stringified toLog (to avoid multiple log lines) as the sole element
-  return [util.inspect(toLog, { compact: true, breakLength: Infinity, depth: null })]
+  try {
+    return [JSON.stringify(toLog)]
+  } catch (e) {
+    // try again with removed circular references
+    return [JSON.stringify(toLog, getCircularReplacer())]
+  }
 }

package/lib/ql/Query.js

@@ -1,7 +1,8 @@
+const { AsyncResource } = require('async_hooks')
 const { inspect } = require('util')
 const cds = require('../index')
 
-module.exports = class Query {
+class Query {
 
   constructor(_={}) { this[this.cmd] = _ }
 
@@ -16,8 +17,10 @@ module.exports = class Query {
   }
 
   /** Turns all queries into Thenables which execute with primary db by default */
-  then (r,e) {
-    return (this._srv || cds.db) .run (this) .then (r,e)
+  get then() {
+    const srv = this._srv || cds.db || cds.error `Can't execute query as no primary database is connected.`
+    const q = new AsyncResource('await cds.query')
+    return (r,e) => q.runInAsyncScope (srv.run, srv, this) .then (r,e)
   }
 
   /** Beautifies output in REPL */
@@ -87,3 +90,6 @@ const _target4 = (target, arg2) =>  target && (
 )
 
 const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
+
+
+module.exports = Query

package/lib/ql/SELECT.js

@@ -94,7 +94,7 @@ module.exports = class SELECT extends Whereable {
     return Object.defineProperty(this, '_where_or_having', { value: 'on', configurable: true })
   }
   on (...args) {
-    if (!this.SELECT.from || !this.SELECT.from.join)
+    if (!this.SELECT.from || !this.SELECT.from.join || !this.SELECT.from.args) // `join` can also be a function, e.g. in SELECT.from(SELECT.from('foo'))
       throw new Error(`Invalid call of "SELECT.on()" without prior call of "SELECT.join()"`)
     return this._where (args,'and','on')
   }
@@ -116,7 +116,7 @@ module.exports = class SELECT extends Whereable {
 
   limit (rows, offset) {
     if (is_number(rows) || rows) this.SELECT.limit = rows.rows ? rows : { rows: {val:rows} }
-    if (is_number(offset)) this.SELECT.limit.offset = { val: offset }
+    if (is_number(offset)) (this.SELECT.limit = (this.SELECT.limit || {})) .offset = { val: offset }
     return this
   }
 

package/lib/ql/UPDATE.js

@@ -54,8 +54,8 @@ module.exports = class UPDATE extends Whereable {
       const o = args[0]
       for (let col in o) {
         let op = '=', v = o[col]
-        if (typeof v === 'object' && !(v === null || v.map || v.pipe || v instanceof Buffer || v instanceof Date)) {
-          let o = Object.keys(v)[0] || this._expected `${{v}} to be an object with an operator as single key`
+        if (typeof v === 'object' && !(v === null || v.map || v.pipe || v instanceof Buffer || v instanceof Date || v instanceof RegExp)) {
+          let o = Object.keys(v)[0] //|| this._expected `${{v}} to be an object with an operator as single key`
           if (o in operators) v = v[op=o]
         }
         _add (this, col, op, v && (v.val !== undefined || v.ref || v.xpr || v.func || v.SELECT) ? v : {val:v})

package/lib/ql/{index.js → cds-ql.js}

@@ -1,4 +1,5 @@
 const cds = require('../index')
+const Query = require('./Query')
 require = path => { // eslint-disable-line no-global-assign
   const clazz = module.require (path); if (!clazz._api) return clazz
   Object.defineProperty (clazz.prototype, 'cmd', { value: path.match(/\w+$/)[0] })
@@ -6,12 +7,14 @@ require = path => { // eslint-disable-line no-global-assign
 }
 
 module.exports = Object.assign (_deprecated_srv_ql, { cdr: true,
+  Query,
   SELECT: require('./SELECT'),
   INSERT: require('./INSERT'),
   UPDATE: require('./UPDATE'),
   DELETE: require('./DELETE'),
   CREATE: require('./CREATE'),
   DROP: require('./DROP'),
+  clone(q) { return Query.prototype.clone.call(q) }
 })
 
 function _deprecated_srv_ql() { // eslint-disable-next-line no-console
@@ -22,18 +25,9 @@ function _deprecated_srv_ql() { // eslint-disable-next-line no-console
   return module.exports
 }
 
-if (cds.env.features.cls && cds.env.features.debug_queries) {
-  const Query = require('./Query'), { then } = Query.prototype
-  const { AsyncResource } = require('async_hooks')
-  Object.defineProperty (Query.prototype,'then',{ get(){
-    const q = new AsyncResource('cds.Query')
-    return (r,e) => q.runInAsyncScope (then,this,r,e)
-  }})
-}
-
 module.exports._reset = ()=>{ // for strange tests only
   const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
-  Object.defineProperty (require('./Query').prototype,'valueOf',{ configurable:1, value: function(cmd=this.cmd) {
+  Object.defineProperty (Query.prototype,'valueOf',{ configurable:1, value: function(cmd=this.cmd) {
     return `${cmd} ${_name(this._target.name)} `
   }})
   return this

package/lib/req/context.js

@@ -12,11 +12,15 @@ const { EventEmitter } = require('events')
 class EventContext {
 
   /** Creates a new instance that inherits from cds.context */
-  static for (_) {
+  static for (_,_as_root) {
     const ctx = new this (_)
-    if (features.cds_tx_inheritance) {
-      const base = cds.context
-      if (base) ctx._set('_propagated', base)
+    const base = cds.context
+    if (base) {
+      ctx._set('_propagated', base) // we inherit from former cds.currents
+      if (!_as_root) {
+        if (!ctx.context) ctx._set('context', base.context) // all transaction handling works with root contexts
+        if (!ctx.tx && base.tx) ctx.tx = base.tx
+      }
     }
     return ctx
   }
@@ -38,7 +42,7 @@ class EventContext {
   //
 
   get emitter() {
-    return this.context._emitter || (this.context._emitter = new EventEmitter)
+    return this.context._emitter || this.context._set('_emitter', new EventEmitter)
   }
 
   async emit (event,...args) {
@@ -104,6 +108,24 @@ class EventContext {
     || this.hasOwnProperty('locale') && this.locale // eslint-disable-line no-prototype-builtins
   }
 
+  get _features() {
+    return super._features = this._propagated._features || _features4 (this.http?.req?.features || this.user?.features || this.http?.req?.user?.features)
+  }
+  get features() {
+    return super.features = this._features || noFeatures
+  }
+  set features(v) {
+    super.features = _features4(v)
+  }
+
+  get model() {
+    const m = this._propagated.model || this.http?.req.__model // IMPORTANT: Never use that anywhere else
+    return this._set('model',m)
+  }
+  set model(m) {
+    super.model = m
+  }
+
   get timestamp() {
     return super.timestamp = this._propagated.timestamp || new Date
   }
@@ -139,30 +161,40 @@ class EventContext {
    */
   set tx (tx) {
     Object.defineProperty (this,'tx',{value:tx}) //> allowed only once!
-    const ctx = tx.context
-    if (ctx && ctx !== this) {
-      if (!this.hasOwnProperty('context')) this.context = ctx // eslint-disable-line no-prototype-builtins
-
+    const root = tx.context?.context
+    if (root && root !== this) {
+      if (!this.hasOwnProperty('context')) this.context = root // eslint-disable-line no-prototype-builtins
       if (features.assert_integrity && features.assert_integrity_type == 'RT') {
-        const reqs = ctx._children || ctx._set('_children', {})
+        const reqs = root._children || root._set('_children', {})
         const all = reqs[tx.name] || (reqs[tx.name] = [])
         all.push(this)
       }
     }
   }
   get _tx() { return this.tx } // REVISIT: for compatibility to bade usages of req._tx
-
-
-  /** REVISIT: remove -> @deprecated */
-  set _model(m){ Object.defineProperty(this,'_model',{value:m}) }
-  get _model() {
-    return this._model = this.tx && this.tx.model || this._propagated._model
-  }
 }
 
 const _TENANT_LOCALE = { tenant:1, locale:2 }
 const _anonymous = new cds.User.default
 
+const _features4 = features => { // normalizes features to an object
+  if (!features) return
+  if (features === '*') return allFeatures
+  const o = (
+    Array.isArray(features) ? features.reduce((fts,f)=>{ fts[f] = true; return fts },{}) :
+    typeof features === 'object' ? Object.fromEntries (Object.entries(features).filter(([,v])=>v)) :
+    (''+features).split(',').reduce((fts,f)=>{ fts[f] = true; return fts },{})
+  )
+  return Object.defineProperty (o,'$hash',$hash)
+}
+const $hash = {
+  get() { return this.$hash = Object.keys(this).join(',') },
+  set(v){ Object.defineProperty(this,'$hash',{value:v}) },
+  configurable:true
+}
+const allFeatures = new Proxy ({'*':true},{ has:() => true, get:(_,p) => p === '$hash' ? '*' : true })
+const noFeatures = {__proto__:{ $hash:'' }}
+
 EventContext.prototype._set('_propagated', Object.seal({}))
 EventContext.propagateHeaders = [ 'x-correlation-id' ]
 module.exports = EventContext

package/lib/req/locale.js

@@ -4,7 +4,11 @@ const INCLUDE_LIST = i18n.preserved_locales.reduce((p,n)=>{
   p[n]=n; p[n.toUpperCase()]=n; return p
 },{
   en_US_x_saptrc: 'en_US_saptrc',
-  en_US_x_sappsd: 'en_US_sappsd'
+  en_US_x_sappsd: 'en_US_sappsd',
+  en_US_x_saprigi: 'en_US_saprigi',
+  '1Q': 'en_US_saptrc',
+  '2Q': 'en_US_sappsd',
+  '3Q': 'en_US_saprigi'
 })
 
 const from_req = req => req && (

package/lib/{serve → srv}/adapters.js

@@ -32,22 +32,11 @@ class ProtocolAdapter {
   /**
   * Mounts the adapter to an express app.
   */
-  in (app, at) {
-    const LOG = cds.log(), DEBUG = cds.debug('server')
-    const srv = this.service, path = at || srv.path
-    app.use (path+'/webapp/', (_,res)=> res.sendStatus(404))
-    lib.auth (srv, app, srv.options)
-    lib.perf (app)
-    app.use (path, (req,_,next) => {
-      if (req.user?.tenant && !cds.context?.tenant) cds.context = { user: req.user } // REVISIT: should move to auth middleware
-      LOG && LOG (req.method, decodeURI(req.originalUrl), req.body||'')
-      if (/\$batch/.test(req.url))  req.on ('dispatch', (req) => {
-        LOG && LOG ('>', req.event, decodeURI(req._path), req._query||'')
-        if (DEBUG && req.query) DEBUG (req.query)
-      })
-      next()
-    })
-    app.use (path, this)
+  in (app) {
+    const srv = this.service
+    app.use (srv.path+'/webapp/', (_,res)=> res.sendStatus(404))
+    const cds_context_model = require('./srv-models')
+    app.use (srv.path, logger, lib.perf, lib.auth(srv), cds_context_model.middleware4(srv), this)
     return srv
   }
 
@@ -72,10 +61,25 @@ class ProtocolAdapter {
 
 const _protocol4 = (srv) => {
   const {to} = srv.options; if (to) return to
-  const def = srv.definition
-  return !def ? default_protocol : def['@protocol'] || def['@rest'] && 'rest' || def['@odata'] && 'odata_v4' || default_protocol
+  return _protocol4Service(srv.definition)
 }
 
+const _protocol4Service = (service) => {
+  return !service ? default_protocol : service['@protocol'] || service['@rest'] && 'rest' || service['@odata'] && 'odata_v4' || default_protocol
+}
+
+
+const LOG = cds.log(), DEBUG = cds.debug('server')
+const logger = function cap_req_logger (req,_,next) {
+  LOG && LOG (req.method, decodeURI(req.originalUrl), req.body||'')
+  if (/\$batch/.test(req.url))  req.on ('dispatch', (req) => {
+    LOG && LOG ('>', req.event, decodeURI(req._path), req._query||'')
+    if (DEBUG && req.query) DEBUG (req.query)
+  })
+  next()
+}
+
+
 const default_protocol = 'odata_v4'
 const _prototype = Object.getOwnPropertyDescriptors (ProtocolAdapter.prototype)
-module.exports = { ProtocolAdapter }
+module.exports = { ProtocolAdapter, _protocol4Service }

package/lib/{connect/index.js → srv/cds-connect.js}

@@ -18,7 +18,7 @@ const connect = module.exports = async function cds_connect (options) {
  * or with options configured in cds.env.requires.<datasource>.
  * @param {string} [datasource]
  * @param {{ kind?:String, impl?:String }} [options]
- * @returns { Promise<import('../serve/Service-api')> }
+ * @returns { Promise<import('./srv-api')> }
  */
 connect.to = async (datasource, options) => {
   let Service = cds.service.factory, _done = x=>x

package/lib/{serve → srv}/factory.js

@@ -2,7 +2,7 @@ const cds = require('..'), { path, isfile } = cds.utils
 const paths = Array.from (new Set ([ cds.root, ...require.resolve.paths('x') ]))
 const DEBUG = cds.debug('srv.factory'); DEBUG && DEBUG ({ 'cds.root':cds.root, paths })
 
-/** @typedef {import('./Service-api')} Service @type { (()=>Service) & (new()=>Service) } */
+/** @typedef {import('./srv-api')} Service @type { (()=>Service) & (new()=>Service) } */
 const ServiceFactory = function (name, model, options) { //NOSONAR
 
   const o = { ...options } // avoid changing shared options

package/lib/{serve/Service-api.js → srv/srv-api.js}

@@ -1,13 +1,13 @@
 const cds = require('..'), { Event, Request } = cds
-const add_methods_to = require ('./Service-methods')
+const add_methods_to = require ('./srv-methods')
 
 
-class Service extends require('./Service-handlers') {
+class Service extends require('./srv-handlers') {
 
   constructor (name, model, o) {
     if (is_object(name)) {
       [ model, o ] = [ name, model ]
-      let srv = cds.linked(model).services[0] || cds.error.expected `${{arg0:name}} to be a CSN with a service definition`
+      let srv = cds.linked(model).services[0] || cds.error.expected `${{model}} passed as first argument to be a CSN with a single service definition`
       name = srv.name
     }
     super (name || new.target.name) .options = o || (o={})
@@ -56,6 +56,14 @@ class Service extends require('./Service-handlers') {
    * Querying API to send synchronous requests...
    */
   run (query, data) {
+    if (typeof query === 'function') {
+      const ctx = cds.context, fn = query
+      if (ctx?.tx && !ctx.tx._done) {
+        return fn (this.tx(ctx)) // with nested tx
+      } else {
+        return this.tx (fn) // with root tx
+      }
+    }
     const req = new Request ({ query, data })
     return this.dispatch (req)
   }
@@ -94,6 +102,13 @@ class Service extends require('./Service-handlers') {
   get events()     { return super.events     = _reflect (this, d => d.kind === 'event') }
   get types()      { return super.types      = _reflect (this, d => !d.kind || d.kind === 'type') }
 
+  /**
+   * Flag to control whether this service is extensible.
+   * Can be overridden by subclasses.
+   * REVISIT cds.xt name check should move to respective services
+   */
+  get isExtensible() { return !this.name?.startsWith('cds.xt.') && this.model === cds.model}
+
   /**
    * Subclasses may override this to free private resources
    */
@@ -107,10 +122,11 @@ class Service extends require('./Service-handlers') {
 
 }
 
-const { dispatch, handle } = require('./Service-dispatch')
-Service.prototype.dispatch = dispatch
+const { dispatch, handle } = require('./srv-dispatch')
+Service.prototype.tx = require('./srv-tx')
 Service.prototype.handle = handle
-Service.prototype.transaction = Service.prototype.tx = require('./Transaction')
+Service.prototype.dispatch = dispatch
+Service.prototype.transaction = Service.prototype.tx
 Service.prototype._implicit_next = cds.env.features.implicit_next
 Service.prototype._is_service_instance = Service._is_service_class = true //> for factory
 module.exports = Service

package/lib/{serve/Service-dispatch.js → srv/srv-dispatch.js}

@@ -3,7 +3,7 @@ const cds = require ('../index')
 /**
  * The default implementation of the `srv.dispatch(req)` ensures everything
  * is prepared before calling `srv.handle(req)`
- * @typedef {import('./Service-api')} Service
+ * @typedef {import('./srv-api')} Service
  * @typedef {import('../req/request')} Request
  * @this {Service}
  * @param {Request} req
@@ -13,18 +13,23 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
 
   // Ensure we are in a proper transaction
   if (!this.context) {
-    const gc = cds.context
-    if (gc && gc.tx && !gc.tx._done) return this.tx(gc).dispatch(req) // with nested tx
-    else return this.tx(tx => tx.dispatch(req)) // as root tx
+    const ctx = cds.context
+    if (ctx?.tx && !ctx.tx._done) {
+      return this.tx (ctx) .dispatch(req)      // with nested tx
+    } else {
+      return this.tx (tx => tx.dispatch(req))  // with root tx
+    }
   }
   if (!req.tx) req.tx = this // `this` is a tx from now on...
 
   // Inform potential listeners // REVISIT: -> this should move into protocol adapters
-  if (_is_root(req)) req._.req.emit ('dispatch',req)
+  let _is_root = req.constructor.name in { ODataRequest:1, RestRequest:2 }
+  if (_is_root) req._.req.emit ('dispatch',req)
 
   // Handle batches of queries
-  if (_is_array(req.query))
-    return Promise.all (req.query.map (q => this.dispatch ({query:q,__proto__:req,context:req})))
+  if (_is_array(req.query)) return Promise.all (req.query.map (
+    q => this.dispatch ({ query:q, context: req.context, __proto__:req })
+  ))
 
   // Ensure target and fqns
   if (!req.target) _ensure_target (this,req)
@@ -88,7 +93,6 @@ exports.handle = async function handle (req) {
 }
 
 
-const _is_root = (req) => /OData|REST/i.test(req.constructor.name)
 const _is_array = Array.isArray
 const _dummy = ()=>{} // REVISIT: required for some messaging tests which obviously still expect and call next()
 
@@ -107,6 +111,7 @@ const _ensure_target = (srv,req) => {
 
 const _ensure_fqn = (x,p,srv, name = x[p]) => {
   if (typeof name === 'string') {
+    if (srv instanceof cds.DatabaseService) return
     if (srv.model && name in srv.model.definitions) return
     if (name.startsWith(srv.namespace)) return
     if (name.endsWith('_drafts')) return // REVISIT: rather fix test/fiori/localized-draft.test.js ?

package/lib/{serve/Service-handlers.js → srv/srv-handlers.js}

@@ -1,4 +1,5 @@
 const cds = require('..'), {expected} = cds.error
+const LOG = cds.log()
 
 class EventHandlers {
 
@@ -41,6 +42,15 @@ const _register = function (srv, phase, event, path, handler) { //NOSONAR
 
   if (!handler) [ handler, path ] = [ path ] // argument path is optional
   if (typeof handler !== 'function') expected `${{handler}} to be a function`
+  if (handler._is_stub) {
+    LOG.warn (`\n
+      WARNING: You are trying to register a frameworks-generated stub method for
+      custom action/function '${event}' in implementation of service '${srv.name}'.
+      We're ignoring that as we already registered the according handler.
+      Please fix your implementation, i.e., just don't register that handler.
+    `)
+    return srv
+  }
 
   // Canonicalize event argument
   if (!event || event === '*') event = undefined

package/lib/{serve/Service-methods.js → srv/srv-methods.js}

@@ -3,19 +3,21 @@ const LOG = cds.log('cds-app-service-methods')
 
 
 module.exports = (srv) => {
-  if (!( //> we only support that for app services
+  if (srv.model && ( //> we only support that for app services
     srv instanceof cds.ApplicationService ||
     srv instanceof cds.RemoteService ||
     srv._add_stub_methods
-  )) return
-  for (const each of srv.operations) {
-    add_handler_for (srv, each)
-  }
-  for (const each of srv.entities) {
-    for (const a in each.actions) {
-      add_handler_for (srv, each.actions[a])
+  )) {
+    for (const each of srv.operations) {
+      add_handler_for (srv, each)
+    }
+    for (const each of srv.entities) {
+      for (const a in each.actions) {
+        add_handler_for (srv, each.actions[a])
+      }
     }
   }
+  return srv
 }
 
 const add_handler_for = (srv, def) => {